]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp,
2893
2894 wxArrayDouble2PyList_helper,
2895 wxPoint2D_LIST_helper
2896 };
2897
2898 #endif
2899
2900
2901 #if !WXWIN_COMPATIBILITY_2_4
2902 #define wxHIDE_READONLY 0
2903 #endif
2904
2905
2906 #define SWIG_From_long PyInt_FromLong
2907
2908
2909 SWIGINTERNINLINE PyObject *
2910 SWIG_From_int (int value)
2911 {
2912 return SWIG_From_long (value);
2913 }
2914
2915 static const wxString wxPyEmptyString(wxEmptyString);
2916 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2917 return self->GetClassInfo()->GetClassName();
2918 }
2919 SWIGINTERN void wxObject_Destroy(wxObject *self){
2920 delete self;
2921 }
2922
2923 #ifndef __WXMAC__
2924 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2925 #endif
2926
2927
2928 #include <limits.h>
2929 #ifndef LLONG_MIN
2930 # define LLONG_MIN LONG_LONG_MIN
2931 #endif
2932 #ifndef LLONG_MAX
2933 # define LLONG_MAX LONG_LONG_MAX
2934 #endif
2935 #ifndef ULLONG_MAX
2936 # define ULLONG_MAX ULONG_LONG_MAX
2937 #endif
2938
2939
2940 SWIGINTERN int
2941 SWIG_AsVal_long (PyObject* obj, long* val)
2942 {
2943 if (PyNumber_Check(obj)) {
2944 if (val) *val = PyInt_AsLong(obj);
2945 return SWIG_OK;
2946 }
2947 return SWIG_TypeError;
2948 }
2949
2950
2951 SWIGINTERN int
2952 SWIG_AsVal_int (PyObject * obj, int *val)
2953 {
2954 long v;
2955 int res = SWIG_AsVal_long (obj, &v);
2956 if (SWIG_IsOK(res)) {
2957 if ((v < INT_MIN || v > INT_MAX)) {
2958 return SWIG_OverflowError;
2959 } else {
2960 if (val) *val = static_cast< int >(v);
2961 }
2962 }
2963 return res;
2964 }
2965
2966 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2967 wxSize temp, *obj = &temp;
2968 if ( other == Py_None ) return false;
2969 if ( ! wxSize_helper(other, &obj) ) {
2970 PyErr_Clear();
2971 return false;
2972 }
2973 return self->operator==(*obj);
2974 }
2975 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2976 wxSize temp, *obj = &temp;
2977 if ( other == Py_None ) return true;
2978 if ( ! wxSize_helper(other, &obj)) {
2979 PyErr_Clear();
2980 return true;
2981 }
2982 return self->operator!=(*obj);
2983 }
2984
2985 #include <float.h>
2986
2987
2988 SWIGINTERN int
2989 SWIG_AsVal_double (PyObject *obj, double* val)
2990 {
2991 if (PyNumber_Check(obj)) {
2992 if (val) *val = PyFloat_AsDouble(obj);
2993 return SWIG_OK;
2994 }
2995 return SWIG_TypeError;
2996 }
2997
2998
2999 SWIGINTERN int
3000 SWIG_AsVal_float (PyObject * obj, float *val)
3001 {
3002 double v;
3003 int res = SWIG_AsVal_double (obj, &v);
3004 if (SWIG_IsOK(res)) {
3005 if ((v < -FLT_MAX || v > FLT_MAX)) {
3006 return SWIG_OverflowError;
3007 } else {
3008 if (val) *val = static_cast< float >(v);
3009 }
3010 }
3011 return res;
3012 }
3013
3014 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3015 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3016 PyObject* tup = PyTuple_New(2);
3017 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3018 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3019 wxPyEndBlockThreads(blocked);
3020 return tup;
3021 }
3022
3023 #define SWIG_From_double PyFloat_FromDouble
3024
3025 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3026 wxRealPoint temp, *obj = &temp;
3027 if ( other == Py_None ) return false;
3028 if ( ! wxRealPoint_helper(other, &obj) ) {
3029 PyErr_Clear();
3030 return false;
3031 }
3032 return self->operator==(*obj);
3033 }
3034 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3035 wxRealPoint temp, *obj = &temp;
3036 if ( other == Py_None ) return true;
3037 if ( ! wxRealPoint_helper(other, &obj)) {
3038 PyErr_Clear();
3039 return true;
3040 }
3041 return self->operator!=(*obj);
3042 }
3043 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3044 self->x = x;
3045 self->y = y;
3046 }
3047 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3048 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3049 PyObject* tup = PyTuple_New(2);
3050 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3051 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3052 wxPyEndBlockThreads(blocked);
3053 return tup;
3054 }
3055 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3056 wxPoint temp, *obj = &temp;
3057 if ( other == Py_None ) return false;
3058 if ( ! wxPoint_helper(other, &obj) ) {
3059 PyErr_Clear();
3060 return false;
3061 }
3062 return self->operator==(*obj);
3063 }
3064 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3065 wxPoint temp, *obj = &temp;
3066 if ( other == Py_None ) return true;
3067 if ( ! wxPoint_helper(other, &obj)) {
3068 PyErr_Clear();
3069 return true;
3070 }
3071 return self->operator!=(*obj);
3072 }
3073 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3074 self->x = x;
3075 self->y = y;
3076 }
3077 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3078 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3079 PyObject* tup = PyTuple_New(2);
3080 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3081 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3082 wxPyEndBlockThreads(blocked);
3083 return tup;
3084 }
3085 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3086 wxRect temp, *obj = &temp;
3087 if ( other == Py_None ) return false;
3088 if ( ! wxRect_helper(other, &obj) ) {
3089 PyErr_Clear();
3090 return false;
3091 }
3092 return self->operator==(*obj);
3093 }
3094 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3095 wxRect temp, *obj = &temp;
3096 if ( other == Py_None ) return true;
3097 if ( ! wxRect_helper(other, &obj)) {
3098 PyErr_Clear();
3099 return true;
3100 }
3101 return self->operator!=(*obj);
3102 }
3103 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3104 self->x = x;
3105 self->y = y;
3106 self->width = width;
3107 self->height = height;
3108 }
3109 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3110 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3111 PyObject* tup = PyTuple_New(4);
3112 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3113 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3114 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3115 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3116 wxPyEndBlockThreads(blocked);
3117 return tup;
3118 }
3119
3120 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3121 wxRegion reg1(*r1);
3122 wxRegion reg2(*r2);
3123 wxRect dest(0,0,0,0);
3124 PyObject* obj;
3125
3126 reg1.Intersect(reg2);
3127 dest = reg1.GetBox();
3128
3129 if (dest != wxRect(0,0,0,0)) {
3130 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3131 wxRect* newRect = new wxRect(dest);
3132 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3133 wxPyEndBlockThreads(blocked);
3134 return obj;
3135 }
3136 Py_INCREF(Py_None);
3137 return Py_None;
3138 }
3139
3140 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3141 wxPoint2D temp, *obj = &temp;
3142 if ( other == Py_None ) return false;
3143 if ( ! wxPoint2D_helper(other, &obj) ) {
3144 PyErr_Clear();
3145 return false;
3146 }
3147 return self->operator==(*obj);
3148 }
3149 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3150 wxPoint2D temp, *obj = &temp;
3151 if ( other == Py_None ) return true;
3152 if ( ! wxPoint2D_helper(other, &obj)) {
3153 PyErr_Clear();
3154 return true;
3155 }
3156 return self->operator!=(*obj);
3157 }
3158 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3159 self->m_x = x;
3160 self->m_y = y;
3161 }
3162 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3163 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3164 PyObject* tup = PyTuple_New(2);
3165 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3166 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3167 wxPyEndBlockThreads(blocked);
3168 return tup;
3169 }
3170
3171 #include "wx/wxPython/pyistream.h"
3172
3173 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3174 wxInputStream* wxis = wxPyCBInputStream::create(p);
3175 if (wxis)
3176 return new wxPyInputStream(wxis);
3177 else
3178 return NULL;
3179 }
3180
3181 SWIGINTERN swig_type_info*
3182 SWIG_pchar_descriptor()
3183 {
3184 static int init = 0;
3185 static swig_type_info* info = 0;
3186 if (!init) {
3187 info = SWIG_TypeQuery("_p_char");
3188 init = 1;
3189 }
3190 return info;
3191 }
3192
3193
3194 SWIGINTERNINLINE PyObject *
3195 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3196 {
3197 if (carray) {
3198 if (size > INT_MAX) {
3199 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3200 return pchar_descriptor ?
3201 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3202 } else {
3203 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3204 }
3205 } else {
3206 return SWIG_Py_Void();
3207 }
3208 }
3209
3210
3211 SWIGINTERNINLINE PyObject *
3212 SWIG_From_char (char c)
3213 {
3214 return SWIG_FromCharPtrAndSize(&c,1);
3215 }
3216
3217
3218 SWIGINTERNINLINE PyObject*
3219 SWIG_From_unsigned_SS_long (unsigned long value)
3220 {
3221 return (value > LONG_MAX) ?
3222 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3223 }
3224
3225
3226 SWIGINTERNINLINE PyObject *
3227 SWIG_From_size_t (size_t value)
3228 {
3229 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3230 }
3231
3232
3233 SWIGINTERN int
3234 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3235 {
3236 if (PyString_Check(obj)) {
3237 char *cstr; Py_ssize_t len;
3238 PyString_AsStringAndSize(obj, &cstr, &len);
3239 if (cptr) {
3240 if (alloc) {
3241 /*
3242 In python the user should not be able to modify the inner
3243 string representation. To warranty that, if you define
3244 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3245 buffer is always returned.
3246
3247 The default behavior is just to return the pointer value,
3248 so, be careful.
3249 */
3250 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3251 if (*alloc != SWIG_OLDOBJ)
3252 #else
3253 if (*alloc == SWIG_NEWOBJ)
3254 #endif
3255 {
3256 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3257 *alloc = SWIG_NEWOBJ;
3258 }
3259 else {
3260 *cptr = cstr;
3261 *alloc = SWIG_OLDOBJ;
3262 }
3263 } else {
3264 *cptr = PyString_AsString(obj);
3265 }
3266 }
3267 if (psize) *psize = len + 1;
3268 return SWIG_OK;
3269 } else {
3270 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3271 if (pchar_descriptor) {
3272 void* vptr = 0;
3273 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3274 if (cptr) *cptr = (char *) vptr;
3275 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3276 if (alloc) *alloc = SWIG_OLDOBJ;
3277 return SWIG_OK;
3278 }
3279 }
3280 }
3281 return SWIG_TypeError;
3282 }
3283
3284
3285 SWIGINTERN int
3286 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3287 {
3288 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3289 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3290 if (SWIG_IsOK(res)) {
3291 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3292 if (csize <= size) {
3293 if (val) {
3294 if (csize) memcpy(val, cptr, csize*sizeof(char));
3295 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3296 }
3297 if (alloc == SWIG_NEWOBJ) {
3298 delete[] cptr;
3299 res = SWIG_DelNewMask(res);
3300 }
3301 return res;
3302 }
3303 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3304 }
3305 return SWIG_TypeError;
3306 }
3307
3308
3309 SWIGINTERN int
3310 SWIG_AsVal_char (PyObject * obj, char *val)
3311 {
3312 int res = SWIG_AsCharArray(obj, val, 1);
3313 if (!SWIG_IsOK(res)) {
3314 long v;
3315 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3316 if (SWIG_IsOK(res)) {
3317 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3318 if (val) *val = static_cast< char >(v);
3319 } else {
3320 res = SWIG_OverflowError;
3321 }
3322 }
3323 }
3324 return res;
3325 }
3326
3327 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3328 // We use only strings for the streams, not unicode
3329 PyObject* str = PyObject_Str(obj);
3330 if (! str) {
3331 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3332 return;
3333 }
3334 self->Write(PyString_AS_STRING(str),
3335 PyString_GET_SIZE(str));
3336 Py_DECREF(str);
3337 }
3338
3339 #include "wx/wxPython/pyistream.h"
3340
3341
3342 class wxPyFileSystemHandler : public wxFileSystemHandler
3343 {
3344 public:
3345 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3346
3347 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3348 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3349 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3350 DEC_PYCALLBACK_STRING__pure(FindNext);
3351
3352 wxString GetProtocol(const wxString& location) {
3353 return wxFileSystemHandler::GetProtocol(location);
3354 }
3355
3356 wxString GetLeftLocation(const wxString& location) {
3357 return wxFileSystemHandler::GetLeftLocation(location);
3358 }
3359
3360 wxString GetAnchor(const wxString& location) {
3361 return wxFileSystemHandler::GetAnchor(location);
3362 }
3363
3364 wxString GetRightLocation(const wxString& location) {
3365 return wxFileSystemHandler::GetRightLocation(location);
3366 }
3367
3368 wxString GetMimeTypeFromExt(const wxString& location) {
3369 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3370 }
3371
3372 PYPRIVATE;
3373 };
3374
3375
3376 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3377 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3378 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3379 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3380
3381
3382 SWIGINTERN int
3383 SWIG_AsVal_bool (PyObject *obj, bool *val)
3384 {
3385 if (obj == Py_True) {
3386 if (val) *val = true;
3387 return SWIG_OK;
3388 } else if (obj == Py_False) {
3389 if (val) *val = false;
3390 return SWIG_OK;
3391 } else {
3392 long v = 0;
3393 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3394 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3395 return res;
3396 }
3397 }
3398
3399 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3400 wxFileName fname = wxFileSystem::URLToFileName(url);
3401 return fname.GetFullPath();
3402 }
3403
3404 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3405 wxImage& image,
3406 long type) {
3407 wxMemoryFSHandler::AddFile(filename, image, type);
3408 }
3409
3410 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3411 const wxBitmap& bitmap,
3412 long type) {
3413 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3414 }
3415
3416 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3417 PyObject* data) {
3418 if (! PyString_Check(data)) {
3419 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3420 "Expected string object"));
3421 return;
3422 }
3423
3424 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3425 void* ptr = (void*)PyString_AsString(data);
3426 size_t size = PyString_Size(data);
3427 wxPyEndBlockThreads(blocked);
3428
3429 wxMemoryFSHandler::AddFile(filename, ptr, size);
3430 }
3431
3432
3433 #include "wx/wxPython/pyistream.h"
3434
3435
3436 SWIGINTERN int
3437 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3438 {
3439 long v = 0;
3440 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3441 return SWIG_TypeError;
3442 }
3443 else if (val)
3444 *val = (unsigned long)v;
3445 return SWIG_OK;
3446 }
3447
3448
3449 SWIGINTERN int
3450 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3451 {
3452 unsigned long v;
3453 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3454 if (SWIG_IsOK(res)) {
3455 if ((v > UCHAR_MAX)) {
3456 return SWIG_OverflowError;
3457 } else {
3458 if (val) *val = static_cast< unsigned char >(v);
3459 }
3460 }
3461 return res;
3462 }
3463
3464
3465 SWIGINTERNINLINE PyObject *
3466 SWIG_From_unsigned_SS_char (unsigned char value)
3467 {
3468 return SWIG_From_unsigned_SS_long (value);
3469 }
3470
3471 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3472 wxImageHistogramEntry e = (*self)[key];
3473 return e.value;
3474 }
3475 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3476 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3477 wxImageHistogramEntry e = (*self)[key];
3478 return e.value;
3479 }
3480 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3481 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3482 colour.Green(),
3483 colour.Blue());
3484 wxImageHistogramEntry e = (*self)[key];
3485 return e.value;
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
3635 wxImage* _ImageFromBuffer(int width, int height,
3636 buffer data, int DATASIZE,
3637 buffer alpha=NULL, int ALPHASIZE=0)
3638 {
3639 if (DATASIZE != width*height*3) {
3640 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3641 return NULL;
3642 }
3643 if (alpha != NULL) {
3644 if (ALPHASIZE != width*height) {
3645 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3646 return NULL;
3647 }
3648 return new wxImage(width, height, data, alpha, true);
3649 }
3650 return new wxImage(width, height, data, true);
3651 }
3652
3653 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3654 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3655 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3656 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3659 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3660 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3661 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3662 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3663 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3664 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3665 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3666 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3667 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3668
3669 #include <wx/quantize.h>
3670
3671 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3672 return wxQuantize::Quantize(src, dest,
3673 //NULL, // palette
3674 desiredNoColours,
3675 NULL, // eightBitData
3676 flags);
3677 }
3678 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3679 if (PyCallable_Check(func)) {
3680 self->Connect(id, lastId, eventType,
3681 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3682 new wxPyCallback(func));
3683 }
3684 else if (func == Py_None) {
3685 self->Disconnect(id, lastId, eventType,
3686 (wxObjectEventFunction)
3687 &wxPyCallback::EventThunker);
3688 }
3689 else {
3690 wxPyBLOCK_THREADS(
3691 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3692 }
3693 }
3694 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3695 return self->Disconnect(id, lastId, eventType,
3696 (wxObjectEventFunction)
3697 &wxPyCallback::EventThunker);
3698 }
3699 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3700 if (_self && _self != Py_None) {
3701 self->SetClientObject(new wxPyOORClientData(_self, incref));
3702 }
3703 else {
3704 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3705 if (data) {
3706 self->SetClientObject(NULL); // This will delete it too
3707 }
3708 }
3709 }
3710
3711 #if ! wxUSE_HOTKEY
3712 #define wxEVT_HOTKEY -9999
3713 #endif
3714
3715 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3716 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3717 if (data) {
3718 Py_INCREF(data->m_obj);
3719 return data->m_obj;
3720 } else {
3721 Py_INCREF(Py_None);
3722 return Py_None;
3723 }
3724 }
3725 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3726 wxPyClientData* data = new wxPyClientData(clientData);
3727 self->SetClientObject(data);
3728 }
3729 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3730 #if wxUSE_UNICODE
3731 return self->GetUnicodeKey();
3732 #else
3733 return 0;
3734 #endif
3735 }
3736 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3737 #if wxUSE_UNICODE
3738 self->m_uniChar = uniChar;
3739 #endif
3740 }
3741
3742 SWIGINTERNINLINE PyObject *
3743 SWIG_From_unsigned_SS_int (unsigned int value)
3744 {
3745 return SWIG_From_unsigned_SS_long (value);
3746 }
3747
3748
3749 SWIGINTERN int
3750 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3751 {
3752 unsigned long v;
3753 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3754 if (SWIG_IsOK(res)) {
3755 if ((v > UINT_MAX)) {
3756 return SWIG_OverflowError;
3757 } else {
3758 if (val) *val = static_cast< unsigned int >(v);
3759 }
3760 }
3761 return res;
3762 }
3763
3764 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3765 self->m_size = size;
3766 }
3767 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3768 int count = self->GetNumberOfFiles();
3769 wxString* files = self->GetFiles();
3770 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3771 PyObject* list = PyList_New(count);
3772
3773 if (!list) {
3774 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3775 wxPyEndBlockThreads(blocked);
3776 return NULL;
3777 }
3778
3779 for (int i=0; i<count; i++) {
3780 PyList_SetItem(list, i, wx2PyString(files[i]));
3781 }
3782 wxPyEndBlockThreads(blocked);
3783 return list;
3784 }
3785
3786
3787 SWIGINTERN wxPyApp *new_wxPyApp(){
3788 wxPythonApp = new wxPyApp();
3789 return wxPythonApp;
3790 }
3791 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3792 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3793 return wxPyTestDisplayAvailable();
3794 }
3795
3796 void wxApp_CleanUp() {
3797 __wxPyCleanup();
3798 }
3799
3800
3801 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3802
3803
3804
3805
3806
3807 SWIGINTERNINLINE PyObject *
3808 SWIG_FromCharPtr(const char *cptr)
3809 {
3810 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3811 }
3812
3813
3814 #if 0 // #ifdef __WXMAC__
3815
3816 // A dummy class that raises an exception if used...
3817 class wxEventLoop
3818 {
3819 public:
3820 wxEventLoop() { wxPyRaiseNotImplemented(); }
3821 int Run() { return 0; }
3822 void Exit(int rc = 0) {}
3823 bool Pending() const { return false; }
3824 bool Dispatch() { return false; }
3825 bool IsRunning() const { return false; }
3826 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3827 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3828 };
3829
3830 #else
3831
3832 #include <wx/evtloop.h>
3833
3834 #endif
3835
3836
3837
3838 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3839 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3840 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3841 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3842 wxWindowList& list = self->GetChildren();
3843 return wxPy_ConvertList(&list);
3844 }
3845 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3846 #if wxUSE_HOTKEY
3847 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3848 #else
3849 return false;
3850 #endif
3851 }
3852 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3853
3854
3855
3856 return false;
3857
3858 }
3859 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3860 return wxPyGetWinHandle(self);
3861 }
3862 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3863 self->AssociateHandle((WXWidget)handle);
3864 }
3865 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3866
3867 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3868 return wxWindow::FindWindowById(id, parent);
3869 }
3870
3871 wxWindow* wxFindWindowByName( const wxString& name,
3872 const wxWindow *parent = NULL ) {
3873 return wxWindow::FindWindowByName(name, parent);
3874 }
3875
3876 wxWindow* wxFindWindowByLabel( const wxString& label,
3877 const wxWindow *parent = NULL ) {
3878 return wxWindow::FindWindowByLabel(label, parent);
3879 }
3880
3881
3882 #ifdef __WXMSW__
3883 #include <wx/msw/private.h> // to get wxGetWindowId
3884 #endif
3885
3886
3887 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3888 #ifdef __WXMSW__
3889 WXHWND hWnd = (WXHWND)_hWnd;
3890 long id = wxGetWindowId(hWnd);
3891 wxWindow* win = new wxWindow;
3892 if (parent)
3893 parent->AddChild(win);
3894 win->SetEventHandler(win);
3895 win->SetHWND(hWnd);
3896 win->SetId(id);
3897 win->SubclassWin(hWnd);
3898 win->AdoptAttributesFromHWND();
3899 win->SetupColours();
3900 return win;
3901 #else
3902 wxPyRaiseNotImplemented();
3903 return NULL;
3904 #endif
3905 }
3906
3907
3908 PyObject* GetTopLevelWindows() {
3909 return wxPy_ConvertList(&wxTopLevelWindows);
3910 }
3911
3912
3913 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3914 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3915 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3916
3917 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3918
3919
3920 SWIGINTERNINLINE int
3921 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3922 {
3923 unsigned long v;
3924 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3925 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3926 return res;
3927 }
3928
3929 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3930 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3931 wxMenuItemList& list = self->GetMenuItems();
3932 return wxPy_ConvertList(&list);
3933 }
3934 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3935 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3936 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3937 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3938 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3939 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3940 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3941 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3942 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3943 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3944 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3945 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3946 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3947 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3948 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3949 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3950 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3951 static const wxString wxPyControlNameStr(wxControlNameStr);
3952 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3953 if (clientData) {
3954 wxPyClientData* data = new wxPyClientData(clientData);
3955 return self->Append(item, data);
3956 } else
3957 return self->Append(item);
3958 }
3959 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3960 if (clientData) {
3961 wxPyClientData* data = new wxPyClientData(clientData);
3962 return self->Insert(item, pos, data);
3963 } else
3964 return self->Insert(item, pos);
3965 }
3966 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3967 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3968 if (data) {
3969 Py_INCREF(data->m_obj);
3970 return data->m_obj;
3971 } else {
3972 Py_INCREF(Py_None);
3973 return Py_None;
3974 }
3975 }
3976 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3977 wxPyClientData* data = new wxPyClientData(clientData);
3978 self->SetClientObject(n, data);
3979 }
3980
3981
3982 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3983 wxPyUserData* data = NULL;
3984 if ( userData ) {
3985 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3986 data = new wxPyUserData(userData);
3987 wxPyEndBlockThreads(blocked);
3988 }
3989 return new wxSizerItem(window, proportion, flag, border, data);
3990 }
3991 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3992 wxPyUserData* data = NULL;
3993 if ( userData ) {
3994 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3995 data = new wxPyUserData(userData);
3996 wxPyEndBlockThreads(blocked);
3997 }
3998 return new wxSizerItem(width, height, proportion, flag, border, data);
3999 }
4000 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4001 wxPyUserData* data = NULL;
4002 if ( userData ) {
4003 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4004 data = new wxPyUserData(userData);
4005 wxPyEndBlockThreads(blocked);
4006 }
4007 return new wxSizerItem(sizer, proportion, flag, border, data);
4008 }
4009
4010 SWIGINTERNINLINE PyObject *
4011 SWIG_From_float (float value)
4012 {
4013 return SWIG_From_double (value);
4014 }
4015
4016 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4017 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4018 if (data) {
4019 Py_INCREF(data->m_obj);
4020 return data->m_obj;
4021 } else {
4022 Py_INCREF(Py_None);
4023 return Py_None;
4024 }
4025 }
4026 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4027 wxPyUserData* data = NULL;
4028 if ( userData ) {
4029 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4030 data = new wxPyUserData(userData);
4031 wxPyEndBlockThreads(blocked);
4032 }
4033 self->SetUserData(data);
4034 }
4035
4036 // Figure out the type of the sizer item
4037
4038 struct wxPySizerItemInfo {
4039 wxPySizerItemInfo()
4040 : window(NULL), sizer(NULL), gotSize(false),
4041 size(wxDefaultSize), gotPos(false), pos(-1)
4042 {}
4043
4044 wxWindow* window;
4045 wxSizer* sizer;
4046 bool gotSize;
4047 wxSize size;
4048 bool gotPos;
4049 int pos;
4050 };
4051
4052 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4053
4054 wxPySizerItemInfo info;
4055 wxSize size;
4056 wxSize* sizePtr = &size;
4057
4058 // Find out what the type of the item is
4059 // try wxWindow
4060 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4061 PyErr_Clear();
4062 info.window = NULL;
4063
4064 // try wxSizer
4065 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4066 PyErr_Clear();
4067 info.sizer = NULL;
4068
4069 // try wxSize or (w,h)
4070 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4071 info.size = *sizePtr;
4072 info.gotSize = true;
4073 }
4074
4075 // or a single int
4076 if (checkIdx && PyInt_Check(item)) {
4077 info.pos = PyInt_AsLong(item);
4078 info.gotPos = true;
4079 }
4080 }
4081 }
4082
4083 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4084 // no expected type, figure out what kind of error message to generate
4085 if ( !checkSize && !checkIdx )
4086 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4087 else if ( checkSize && !checkIdx )
4088 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4089 else if ( !checkSize && checkIdx)
4090 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4091 else
4092 // can this one happen?
4093 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4094 }
4095
4096 return info;
4097 }
4098
4099 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4100 if (!self->GetClientObject())
4101 self->SetClientObject(new wxPyOORClientData(_self));
4102 }
4103 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,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 Add method if a valid item type was found
4115 if ( info.window )
4116 return self->Add(info.window, proportion, flag, border, data);
4117 else if ( info.sizer )
4118 return self->Add(info.sizer, proportion, flag, border, data);
4119 else if (info.gotSize)
4120 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4121 proportion, flag, border, data);
4122 else
4123 return NULL;
4124 }
4125 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,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 Insert method if a valid item type was found
4137 if ( info.window )
4138 return self->Insert(before, info.window, proportion, flag, border, data);
4139 else if ( info.sizer )
4140 return self->Insert(before, info.sizer, proportion, flag, border, data);
4141 else if (info.gotSize)
4142 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4143 proportion, flag, border, data);
4144 else
4145 return NULL;
4146 }
4147 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4148
4149 wxPyUserData* data = NULL;
4150 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4151 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4152 if ( userData && (info.window || info.sizer || info.gotSize) )
4153 data = new wxPyUserData(userData);
4154 if ( info.sizer )
4155 PyObject_SetAttrString(item,"thisown",Py_False);
4156 wxPyEndBlockThreads(blocked);
4157
4158 // Now call the real Prepend method if a valid item type was found
4159 if ( info.window )
4160 return self->Prepend(info.window, proportion, flag, border, data);
4161 else if ( info.sizer )
4162 return self->Prepend(info.sizer, proportion, flag, border, data);
4163 else if (info.gotSize)
4164 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4165 proportion, flag, border, data);
4166 else
4167 return NULL;
4168 }
4169 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4170 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4171 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4172 wxPyEndBlockThreads(blocked);
4173 if ( info.window )
4174 return self->Remove(info.window);
4175 else if ( info.sizer )
4176 return self->Remove(info.sizer);
4177 else if ( info.gotPos )
4178 return self->Remove(info.pos);
4179 else
4180 return false;
4181 }
4182 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4183 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4184 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4185 wxPyEndBlockThreads(blocked);
4186 if ( info.window )
4187 return self->Detach(info.window);
4188 else if ( info.sizer )
4189 return self->Detach(info.sizer);
4190 else if ( info.gotPos )
4191 return self->Detach(info.pos);
4192 else
4193 return false;
4194 }
4195 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4196 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4197 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4198 wxPyEndBlockThreads(blocked);
4199 if ( info.window )
4200 return self->GetItem(info.window);
4201 else if ( info.sizer )
4202 return self->GetItem(info.sizer);
4203 else if ( info.gotPos )
4204 return self->GetItem(info.pos);
4205 else
4206 return NULL;
4207 }
4208 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4209 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4210 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4211 wxPyEndBlockThreads(blocked);
4212 if ( info.window )
4213 self->SetItemMinSize(info.window, size);
4214 else if ( info.sizer )
4215 self->SetItemMinSize(info.sizer, size);
4216 else if ( info.gotPos )
4217 self->SetItemMinSize(info.pos, size);
4218 }
4219 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4220 wxSizerItemList& list = self->GetChildren();
4221 return wxPy_ConvertList(&list);
4222 }
4223 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4224 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4225 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4226 wxPyEndBlockThreads(blocked);
4227 if ( info.window )
4228 return self->Show(info.window, show, recursive);
4229 else if ( info.sizer )
4230 return self->Show(info.sizer, show, recursive);
4231 else if ( info.gotPos )
4232 return self->Show(info.pos, show);
4233 else
4234 return false;
4235 }
4236 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4237 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4238 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4239 wxPyEndBlockThreads(blocked);
4240 if ( info.window )
4241 return self->IsShown(info.window);
4242 else if ( info.sizer )
4243 return self->IsShown(info.sizer);
4244 else if ( info.gotPos )
4245 return self->IsShown(info.pos);
4246 else
4247 return false;
4248 }
4249
4250 // See pyclasses.h
4251 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4252 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4253 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4254
4255
4256
4257
4258 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4259 {
4260 if (source == Py_None) {
4261 **obj = wxGBPosition(-1,-1);
4262 return true;
4263 }
4264 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4265 }
4266
4267 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4268 {
4269 if (source == Py_None) {
4270 **obj = wxGBSpan(-1,-1);
4271 return true;
4272 }
4273 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4274 }
4275
4276
4277 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4278 wxGBPosition temp, *obj = &temp;
4279 if ( other == Py_None ) return false;
4280 if ( ! wxGBPosition_helper(other, &obj) ) {
4281 PyErr_Clear();
4282 return false;
4283 }
4284 return self->operator==(*obj);
4285 }
4286 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4287 wxGBPosition temp, *obj = &temp;
4288 if ( other == Py_None ) return true;
4289 if ( ! wxGBPosition_helper(other, &obj)) {
4290 PyErr_Clear();
4291 return true;
4292 }
4293 return self->operator!=(*obj);
4294 }
4295 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4296 self->SetRow(row);
4297 self->SetCol(col);
4298 }
4299 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4300 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4301 PyObject* tup = PyTuple_New(2);
4302 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4303 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4304 wxPyEndBlockThreads(blocked);
4305 return tup;
4306 }
4307 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4308 wxGBSpan temp, *obj = &temp;
4309 if ( other == Py_None ) return false;
4310 if ( ! wxGBSpan_helper(other, &obj) ) {
4311 PyErr_Clear();
4312 return false;
4313 }
4314 return self->operator==(*obj);
4315 }
4316 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4317 wxGBSpan temp, *obj = &temp;
4318 if ( other == Py_None ) return true;
4319 if ( ! wxGBSpan_helper(other, &obj)) {
4320 PyErr_Clear();
4321 return true;
4322 }
4323 return self->operator!=(*obj);
4324 }
4325 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4326 self->SetRowspan(rowspan);
4327 self->SetColspan(colspan);
4328 }
4329 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4330 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4331 PyObject* tup = PyTuple_New(2);
4332 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4333 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4334 wxPyEndBlockThreads(blocked);
4335 return tup;
4336 }
4337 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4338 wxPyUserData* data = NULL;
4339 if ( userData ) {
4340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4341 data = new wxPyUserData(userData);
4342 wxPyEndBlockThreads(blocked);
4343 }
4344 return new wxGBSizerItem(window, pos, span, flag, border, data);
4345 }
4346 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4347 wxPyUserData* data = NULL;
4348 if ( userData ) {
4349 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4350 data = new wxPyUserData(userData);
4351 wxPyEndBlockThreads(blocked);
4352 }
4353 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4354 }
4355 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4356 wxPyUserData* data = NULL;
4357 if ( userData ) {
4358 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4359 data = new wxPyUserData(userData);
4360 wxPyEndBlockThreads(blocked);
4361 }
4362 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4363 }
4364 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4365 int row, col;
4366 self->GetEndPos(row, col);
4367 return wxGBPosition(row, col);
4368 }
4369 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4370
4371 wxPyUserData* data = NULL;
4372 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4373 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4374 if ( userData && (info.window || info.sizer || info.gotSize) )
4375 data = new wxPyUserData(userData);
4376 if ( info.sizer )
4377 PyObject_SetAttrString(item,"thisown",Py_False);
4378 wxPyEndBlockThreads(blocked);
4379
4380 // Now call the real Add method if a valid item type was found
4381 if ( info.window )
4382 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4383 else if ( info.sizer )
4384 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4385 else if (info.gotSize)
4386 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4387 pos, span, flag, border, data);
4388 return NULL;
4389 }
4390
4391
4392 #ifdef __cplusplus
4393 extern "C" {
4394 #endif
4395 SWIGINTERN int EmptyString_set(PyObject *) {
4396 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4397 return 1;
4398 }
4399
4400
4401 SWIGINTERN PyObject *EmptyString_get(void) {
4402 PyObject *pyobj = 0;
4403
4404 {
4405 #if wxUSE_UNICODE
4406 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4407 #else
4408 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4409 #endif
4410 }
4411 return pyobj;
4412 }
4413
4414
4415 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4416 PyObject *resultobj = 0;
4417 wxObject *arg1 = (wxObject *) 0 ;
4418 wxString result;
4419 void *argp1 = 0 ;
4420 int res1 = 0 ;
4421 PyObject *swig_obj[1] ;
4422
4423 if (!args) SWIG_fail;
4424 swig_obj[0] = args;
4425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4426 if (!SWIG_IsOK(res1)) {
4427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4428 }
4429 arg1 = reinterpret_cast< wxObject * >(argp1);
4430 {
4431 PyThreadState* __tstate = wxPyBeginAllowThreads();
4432 result = wxObject_GetClassName(arg1);
4433 wxPyEndAllowThreads(__tstate);
4434 if (PyErr_Occurred()) SWIG_fail;
4435 }
4436 {
4437 #if wxUSE_UNICODE
4438 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4439 #else
4440 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4441 #endif
4442 }
4443 return resultobj;
4444 fail:
4445 return NULL;
4446 }
4447
4448
4449 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4450 PyObject *resultobj = 0;
4451 wxObject *arg1 = (wxObject *) 0 ;
4452 void *argp1 = 0 ;
4453 int res1 = 0 ;
4454 PyObject *swig_obj[1] ;
4455
4456 if (!args) SWIG_fail;
4457 swig_obj[0] = args;
4458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4459 if (!SWIG_IsOK(res1)) {
4460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4461 }
4462 arg1 = reinterpret_cast< wxObject * >(argp1);
4463 {
4464 PyThreadState* __tstate = wxPyBeginAllowThreads();
4465 wxObject_Destroy(arg1);
4466 wxPyEndAllowThreads(__tstate);
4467 if (PyErr_Occurred()) SWIG_fail;
4468 }
4469 resultobj = SWIG_Py_Void();
4470 return resultobj;
4471 fail:
4472 return NULL;
4473 }
4474
4475
4476 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4477 PyObject *obj;
4478 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4479 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4480 return SWIG_Py_Void();
4481 }
4482
4483 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4484 PyObject *resultobj = 0;
4485 wxSize *arg1 = (wxSize *) 0 ;
4486 int arg2 ;
4487 void *argp1 = 0 ;
4488 int res1 = 0 ;
4489 int val2 ;
4490 int ecode2 = 0 ;
4491 PyObject *swig_obj[2] ;
4492
4493 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4495 if (!SWIG_IsOK(res1)) {
4496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4497 }
4498 arg1 = reinterpret_cast< wxSize * >(argp1);
4499 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4500 if (!SWIG_IsOK(ecode2)) {
4501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4502 }
4503 arg2 = static_cast< int >(val2);
4504 if (arg1) (arg1)->x = arg2;
4505
4506 resultobj = SWIG_Py_Void();
4507 return resultobj;
4508 fail:
4509 return NULL;
4510 }
4511
4512
4513 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4514 PyObject *resultobj = 0;
4515 wxSize *arg1 = (wxSize *) 0 ;
4516 int result;
4517 void *argp1 = 0 ;
4518 int res1 = 0 ;
4519 PyObject *swig_obj[1] ;
4520
4521 if (!args) SWIG_fail;
4522 swig_obj[0] = args;
4523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4524 if (!SWIG_IsOK(res1)) {
4525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4526 }
4527 arg1 = reinterpret_cast< wxSize * >(argp1);
4528 result = (int) ((arg1)->x);
4529 resultobj = SWIG_From_int(static_cast< int >(result));
4530 return resultobj;
4531 fail:
4532 return NULL;
4533 }
4534
4535
4536 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4537 PyObject *resultobj = 0;
4538 wxSize *arg1 = (wxSize *) 0 ;
4539 int arg2 ;
4540 void *argp1 = 0 ;
4541 int res1 = 0 ;
4542 int val2 ;
4543 int ecode2 = 0 ;
4544 PyObject *swig_obj[2] ;
4545
4546 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4548 if (!SWIG_IsOK(res1)) {
4549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4550 }
4551 arg1 = reinterpret_cast< wxSize * >(argp1);
4552 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4553 if (!SWIG_IsOK(ecode2)) {
4554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4555 }
4556 arg2 = static_cast< int >(val2);
4557 if (arg1) (arg1)->y = arg2;
4558
4559 resultobj = SWIG_Py_Void();
4560 return resultobj;
4561 fail:
4562 return NULL;
4563 }
4564
4565
4566 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4567 PyObject *resultobj = 0;
4568 wxSize *arg1 = (wxSize *) 0 ;
4569 int result;
4570 void *argp1 = 0 ;
4571 int res1 = 0 ;
4572 PyObject *swig_obj[1] ;
4573
4574 if (!args) SWIG_fail;
4575 swig_obj[0] = args;
4576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4577 if (!SWIG_IsOK(res1)) {
4578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4579 }
4580 arg1 = reinterpret_cast< wxSize * >(argp1);
4581 result = (int) ((arg1)->y);
4582 resultobj = SWIG_From_int(static_cast< int >(result));
4583 return resultobj;
4584 fail:
4585 return NULL;
4586 }
4587
4588
4589 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4590 PyObject *resultobj = 0;
4591 int arg1 = (int) 0 ;
4592 int arg2 = (int) 0 ;
4593 wxSize *result = 0 ;
4594 int val1 ;
4595 int ecode1 = 0 ;
4596 int val2 ;
4597 int ecode2 = 0 ;
4598 PyObject * obj0 = 0 ;
4599 PyObject * obj1 = 0 ;
4600 char * kwnames[] = {
4601 (char *) "w",(char *) "h", NULL
4602 };
4603
4604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4605 if (obj0) {
4606 ecode1 = SWIG_AsVal_int(obj0, &val1);
4607 if (!SWIG_IsOK(ecode1)) {
4608 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4609 }
4610 arg1 = static_cast< int >(val1);
4611 }
4612 if (obj1) {
4613 ecode2 = SWIG_AsVal_int(obj1, &val2);
4614 if (!SWIG_IsOK(ecode2)) {
4615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4616 }
4617 arg2 = static_cast< int >(val2);
4618 }
4619 {
4620 PyThreadState* __tstate = wxPyBeginAllowThreads();
4621 result = (wxSize *)new wxSize(arg1,arg2);
4622 wxPyEndAllowThreads(__tstate);
4623 if (PyErr_Occurred()) SWIG_fail;
4624 }
4625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4626 return resultobj;
4627 fail:
4628 return NULL;
4629 }
4630
4631
4632 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4633 PyObject *resultobj = 0;
4634 wxSize *arg1 = (wxSize *) 0 ;
4635 void *argp1 = 0 ;
4636 int res1 = 0 ;
4637 PyObject *swig_obj[1] ;
4638
4639 if (!args) SWIG_fail;
4640 swig_obj[0] = args;
4641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4642 if (!SWIG_IsOK(res1)) {
4643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4644 }
4645 arg1 = reinterpret_cast< wxSize * >(argp1);
4646 {
4647 PyThreadState* __tstate = wxPyBeginAllowThreads();
4648 delete arg1;
4649
4650 wxPyEndAllowThreads(__tstate);
4651 if (PyErr_Occurred()) SWIG_fail;
4652 }
4653 resultobj = SWIG_Py_Void();
4654 return resultobj;
4655 fail:
4656 return NULL;
4657 }
4658
4659
4660 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4661 PyObject *resultobj = 0;
4662 wxSize *arg1 = (wxSize *) 0 ;
4663 PyObject *arg2 = (PyObject *) 0 ;
4664 bool result;
4665 void *argp1 = 0 ;
4666 int res1 = 0 ;
4667 PyObject * obj0 = 0 ;
4668 PyObject * obj1 = 0 ;
4669 char * kwnames[] = {
4670 (char *) "self",(char *) "other", NULL
4671 };
4672
4673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4675 if (!SWIG_IsOK(res1)) {
4676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4677 }
4678 arg1 = reinterpret_cast< wxSize * >(argp1);
4679 arg2 = obj1;
4680 {
4681 result = (bool)wxSize___eq__(arg1,arg2);
4682 if (PyErr_Occurred()) SWIG_fail;
4683 }
4684 {
4685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4686 }
4687 return resultobj;
4688 fail:
4689 return NULL;
4690 }
4691
4692
4693 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4694 PyObject *resultobj = 0;
4695 wxSize *arg1 = (wxSize *) 0 ;
4696 PyObject *arg2 = (PyObject *) 0 ;
4697 bool result;
4698 void *argp1 = 0 ;
4699 int res1 = 0 ;
4700 PyObject * obj0 = 0 ;
4701 PyObject * obj1 = 0 ;
4702 char * kwnames[] = {
4703 (char *) "self",(char *) "other", NULL
4704 };
4705
4706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4708 if (!SWIG_IsOK(res1)) {
4709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4710 }
4711 arg1 = reinterpret_cast< wxSize * >(argp1);
4712 arg2 = obj1;
4713 {
4714 result = (bool)wxSize___ne__(arg1,arg2);
4715 if (PyErr_Occurred()) SWIG_fail;
4716 }
4717 {
4718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4719 }
4720 return resultobj;
4721 fail:
4722 return NULL;
4723 }
4724
4725
4726 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4727 PyObject *resultobj = 0;
4728 wxSize *arg1 = (wxSize *) 0 ;
4729 wxSize *arg2 = 0 ;
4730 wxSize result;
4731 void *argp1 = 0 ;
4732 int res1 = 0 ;
4733 wxSize temp2 ;
4734 PyObject * obj0 = 0 ;
4735 PyObject * obj1 = 0 ;
4736 char * kwnames[] = {
4737 (char *) "self",(char *) "sz", NULL
4738 };
4739
4740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4742 if (!SWIG_IsOK(res1)) {
4743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4744 }
4745 arg1 = reinterpret_cast< wxSize * >(argp1);
4746 {
4747 arg2 = &temp2;
4748 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4749 }
4750 {
4751 PyThreadState* __tstate = wxPyBeginAllowThreads();
4752 result = (arg1)->operator +((wxSize const &)*arg2);
4753 wxPyEndAllowThreads(__tstate);
4754 if (PyErr_Occurred()) SWIG_fail;
4755 }
4756 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4757 return resultobj;
4758 fail:
4759 return NULL;
4760 }
4761
4762
4763 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4764 PyObject *resultobj = 0;
4765 wxSize *arg1 = (wxSize *) 0 ;
4766 wxSize *arg2 = 0 ;
4767 wxSize result;
4768 void *argp1 = 0 ;
4769 int res1 = 0 ;
4770 wxSize temp2 ;
4771 PyObject * obj0 = 0 ;
4772 PyObject * obj1 = 0 ;
4773 char * kwnames[] = {
4774 (char *) "self",(char *) "sz", NULL
4775 };
4776
4777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4779 if (!SWIG_IsOK(res1)) {
4780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4781 }
4782 arg1 = reinterpret_cast< wxSize * >(argp1);
4783 {
4784 arg2 = &temp2;
4785 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4786 }
4787 {
4788 PyThreadState* __tstate = wxPyBeginAllowThreads();
4789 result = (arg1)->operator -((wxSize const &)*arg2);
4790 wxPyEndAllowThreads(__tstate);
4791 if (PyErr_Occurred()) SWIG_fail;
4792 }
4793 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4794 return resultobj;
4795 fail:
4796 return NULL;
4797 }
4798
4799
4800 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4801 PyObject *resultobj = 0;
4802 wxSize *arg1 = (wxSize *) 0 ;
4803 wxSize *arg2 = 0 ;
4804 void *argp1 = 0 ;
4805 int res1 = 0 ;
4806 wxSize temp2 ;
4807 PyObject * obj0 = 0 ;
4808 PyObject * obj1 = 0 ;
4809 char * kwnames[] = {
4810 (char *) "self",(char *) "sz", NULL
4811 };
4812
4813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4815 if (!SWIG_IsOK(res1)) {
4816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4817 }
4818 arg1 = reinterpret_cast< wxSize * >(argp1);
4819 {
4820 arg2 = &temp2;
4821 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4822 }
4823 {
4824 PyThreadState* __tstate = wxPyBeginAllowThreads();
4825 (arg1)->IncTo((wxSize const &)*arg2);
4826 wxPyEndAllowThreads(__tstate);
4827 if (PyErr_Occurred()) SWIG_fail;
4828 }
4829 resultobj = SWIG_Py_Void();
4830 return resultobj;
4831 fail:
4832 return NULL;
4833 }
4834
4835
4836 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4837 PyObject *resultobj = 0;
4838 wxSize *arg1 = (wxSize *) 0 ;
4839 wxSize *arg2 = 0 ;
4840 void *argp1 = 0 ;
4841 int res1 = 0 ;
4842 wxSize temp2 ;
4843 PyObject * obj0 = 0 ;
4844 PyObject * obj1 = 0 ;
4845 char * kwnames[] = {
4846 (char *) "self",(char *) "sz", NULL
4847 };
4848
4849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4851 if (!SWIG_IsOK(res1)) {
4852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4853 }
4854 arg1 = reinterpret_cast< wxSize * >(argp1);
4855 {
4856 arg2 = &temp2;
4857 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4858 }
4859 {
4860 PyThreadState* __tstate = wxPyBeginAllowThreads();
4861 (arg1)->DecTo((wxSize const &)*arg2);
4862 wxPyEndAllowThreads(__tstate);
4863 if (PyErr_Occurred()) SWIG_fail;
4864 }
4865 resultobj = SWIG_Py_Void();
4866 return resultobj;
4867 fail:
4868 return NULL;
4869 }
4870
4871
4872 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4873 PyObject *resultobj = 0;
4874 wxSize *arg1 = (wxSize *) 0 ;
4875 int arg2 ;
4876 int arg3 ;
4877 void *argp1 = 0 ;
4878 int res1 = 0 ;
4879 int val2 ;
4880 int ecode2 = 0 ;
4881 int val3 ;
4882 int ecode3 = 0 ;
4883 PyObject * obj0 = 0 ;
4884 PyObject * obj1 = 0 ;
4885 PyObject * obj2 = 0 ;
4886 char * kwnames[] = {
4887 (char *) "self",(char *) "dx",(char *) "dy", NULL
4888 };
4889
4890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4892 if (!SWIG_IsOK(res1)) {
4893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4894 }
4895 arg1 = reinterpret_cast< wxSize * >(argp1);
4896 ecode2 = SWIG_AsVal_int(obj1, &val2);
4897 if (!SWIG_IsOK(ecode2)) {
4898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4899 }
4900 arg2 = static_cast< int >(val2);
4901 ecode3 = SWIG_AsVal_int(obj2, &val3);
4902 if (!SWIG_IsOK(ecode3)) {
4903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4904 }
4905 arg3 = static_cast< int >(val3);
4906 {
4907 PyThreadState* __tstate = wxPyBeginAllowThreads();
4908 (arg1)->IncBy(arg2,arg3);
4909 wxPyEndAllowThreads(__tstate);
4910 if (PyErr_Occurred()) SWIG_fail;
4911 }
4912 resultobj = SWIG_Py_Void();
4913 return resultobj;
4914 fail:
4915 return NULL;
4916 }
4917
4918
4919 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4920 PyObject *resultobj = 0;
4921 wxSize *arg1 = (wxSize *) 0 ;
4922 int arg2 ;
4923 int arg3 ;
4924 void *argp1 = 0 ;
4925 int res1 = 0 ;
4926 int val2 ;
4927 int ecode2 = 0 ;
4928 int val3 ;
4929 int ecode3 = 0 ;
4930 PyObject * obj0 = 0 ;
4931 PyObject * obj1 = 0 ;
4932 PyObject * obj2 = 0 ;
4933 char * kwnames[] = {
4934 (char *) "self",(char *) "dx",(char *) "dy", NULL
4935 };
4936
4937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4939 if (!SWIG_IsOK(res1)) {
4940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
4941 }
4942 arg1 = reinterpret_cast< wxSize * >(argp1);
4943 ecode2 = SWIG_AsVal_int(obj1, &val2);
4944 if (!SWIG_IsOK(ecode2)) {
4945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
4946 }
4947 arg2 = static_cast< int >(val2);
4948 ecode3 = SWIG_AsVal_int(obj2, &val3);
4949 if (!SWIG_IsOK(ecode3)) {
4950 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
4951 }
4952 arg3 = static_cast< int >(val3);
4953 {
4954 PyThreadState* __tstate = wxPyBeginAllowThreads();
4955 (arg1)->DecBy(arg2,arg3);
4956 wxPyEndAllowThreads(__tstate);
4957 if (PyErr_Occurred()) SWIG_fail;
4958 }
4959 resultobj = SWIG_Py_Void();
4960 return resultobj;
4961 fail:
4962 return NULL;
4963 }
4964
4965
4966 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4967 PyObject *resultobj = 0;
4968 wxSize *arg1 = (wxSize *) 0 ;
4969 float arg2 ;
4970 float arg3 ;
4971 void *argp1 = 0 ;
4972 int res1 = 0 ;
4973 float val2 ;
4974 int ecode2 = 0 ;
4975 float val3 ;
4976 int ecode3 = 0 ;
4977 PyObject * obj0 = 0 ;
4978 PyObject * obj1 = 0 ;
4979 PyObject * obj2 = 0 ;
4980 char * kwnames[] = {
4981 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4982 };
4983
4984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4986 if (!SWIG_IsOK(res1)) {
4987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4988 }
4989 arg1 = reinterpret_cast< wxSize * >(argp1);
4990 ecode2 = SWIG_AsVal_float(obj1, &val2);
4991 if (!SWIG_IsOK(ecode2)) {
4992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4993 }
4994 arg2 = static_cast< float >(val2);
4995 ecode3 = SWIG_AsVal_float(obj2, &val3);
4996 if (!SWIG_IsOK(ecode3)) {
4997 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4998 }
4999 arg3 = static_cast< float >(val3);
5000 {
5001 PyThreadState* __tstate = wxPyBeginAllowThreads();
5002 (arg1)->Scale(arg2,arg3);
5003 wxPyEndAllowThreads(__tstate);
5004 if (PyErr_Occurred()) SWIG_fail;
5005 }
5006 resultobj = SWIG_Py_Void();
5007 return resultobj;
5008 fail:
5009 return NULL;
5010 }
5011
5012
5013 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5014 PyObject *resultobj = 0;
5015 wxSize *arg1 = (wxSize *) 0 ;
5016 int arg2 ;
5017 int arg3 ;
5018 void *argp1 = 0 ;
5019 int res1 = 0 ;
5020 int val2 ;
5021 int ecode2 = 0 ;
5022 int val3 ;
5023 int ecode3 = 0 ;
5024 PyObject * obj0 = 0 ;
5025 PyObject * obj1 = 0 ;
5026 PyObject * obj2 = 0 ;
5027 char * kwnames[] = {
5028 (char *) "self",(char *) "w",(char *) "h", NULL
5029 };
5030
5031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5033 if (!SWIG_IsOK(res1)) {
5034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5035 }
5036 arg1 = reinterpret_cast< wxSize * >(argp1);
5037 ecode2 = SWIG_AsVal_int(obj1, &val2);
5038 if (!SWIG_IsOK(ecode2)) {
5039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5040 }
5041 arg2 = static_cast< int >(val2);
5042 ecode3 = SWIG_AsVal_int(obj2, &val3);
5043 if (!SWIG_IsOK(ecode3)) {
5044 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5045 }
5046 arg3 = static_cast< int >(val3);
5047 {
5048 PyThreadState* __tstate = wxPyBeginAllowThreads();
5049 (arg1)->Set(arg2,arg3);
5050 wxPyEndAllowThreads(__tstate);
5051 if (PyErr_Occurred()) SWIG_fail;
5052 }
5053 resultobj = SWIG_Py_Void();
5054 return resultobj;
5055 fail:
5056 return NULL;
5057 }
5058
5059
5060 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5061 PyObject *resultobj = 0;
5062 wxSize *arg1 = (wxSize *) 0 ;
5063 int arg2 ;
5064 void *argp1 = 0 ;
5065 int res1 = 0 ;
5066 int val2 ;
5067 int ecode2 = 0 ;
5068 PyObject * obj0 = 0 ;
5069 PyObject * obj1 = 0 ;
5070 char * kwnames[] = {
5071 (char *) "self",(char *) "w", NULL
5072 };
5073
5074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5076 if (!SWIG_IsOK(res1)) {
5077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5078 }
5079 arg1 = reinterpret_cast< wxSize * >(argp1);
5080 ecode2 = SWIG_AsVal_int(obj1, &val2);
5081 if (!SWIG_IsOK(ecode2)) {
5082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5083 }
5084 arg2 = static_cast< int >(val2);
5085 {
5086 PyThreadState* __tstate = wxPyBeginAllowThreads();
5087 (arg1)->SetWidth(arg2);
5088 wxPyEndAllowThreads(__tstate);
5089 if (PyErr_Occurred()) SWIG_fail;
5090 }
5091 resultobj = SWIG_Py_Void();
5092 return resultobj;
5093 fail:
5094 return NULL;
5095 }
5096
5097
5098 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5099 PyObject *resultobj = 0;
5100 wxSize *arg1 = (wxSize *) 0 ;
5101 int arg2 ;
5102 void *argp1 = 0 ;
5103 int res1 = 0 ;
5104 int val2 ;
5105 int ecode2 = 0 ;
5106 PyObject * obj0 = 0 ;
5107 PyObject * obj1 = 0 ;
5108 char * kwnames[] = {
5109 (char *) "self",(char *) "h", NULL
5110 };
5111
5112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5114 if (!SWIG_IsOK(res1)) {
5115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5116 }
5117 arg1 = reinterpret_cast< wxSize * >(argp1);
5118 ecode2 = SWIG_AsVal_int(obj1, &val2);
5119 if (!SWIG_IsOK(ecode2)) {
5120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5121 }
5122 arg2 = static_cast< int >(val2);
5123 {
5124 PyThreadState* __tstate = wxPyBeginAllowThreads();
5125 (arg1)->SetHeight(arg2);
5126 wxPyEndAllowThreads(__tstate);
5127 if (PyErr_Occurred()) SWIG_fail;
5128 }
5129 resultobj = SWIG_Py_Void();
5130 return resultobj;
5131 fail:
5132 return NULL;
5133 }
5134
5135
5136 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5137 PyObject *resultobj = 0;
5138 wxSize *arg1 = (wxSize *) 0 ;
5139 int result;
5140 void *argp1 = 0 ;
5141 int res1 = 0 ;
5142 PyObject *swig_obj[1] ;
5143
5144 if (!args) SWIG_fail;
5145 swig_obj[0] = args;
5146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5147 if (!SWIG_IsOK(res1)) {
5148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5149 }
5150 arg1 = reinterpret_cast< wxSize * >(argp1);
5151 {
5152 PyThreadState* __tstate = wxPyBeginAllowThreads();
5153 result = (int)((wxSize const *)arg1)->GetWidth();
5154 wxPyEndAllowThreads(__tstate);
5155 if (PyErr_Occurred()) SWIG_fail;
5156 }
5157 resultobj = SWIG_From_int(static_cast< int >(result));
5158 return resultobj;
5159 fail:
5160 return NULL;
5161 }
5162
5163
5164 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5165 PyObject *resultobj = 0;
5166 wxSize *arg1 = (wxSize *) 0 ;
5167 int result;
5168 void *argp1 = 0 ;
5169 int res1 = 0 ;
5170 PyObject *swig_obj[1] ;
5171
5172 if (!args) SWIG_fail;
5173 swig_obj[0] = args;
5174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5175 if (!SWIG_IsOK(res1)) {
5176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5177 }
5178 arg1 = reinterpret_cast< wxSize * >(argp1);
5179 {
5180 PyThreadState* __tstate = wxPyBeginAllowThreads();
5181 result = (int)((wxSize const *)arg1)->GetHeight();
5182 wxPyEndAllowThreads(__tstate);
5183 if (PyErr_Occurred()) SWIG_fail;
5184 }
5185 resultobj = SWIG_From_int(static_cast< int >(result));
5186 return resultobj;
5187 fail:
5188 return NULL;
5189 }
5190
5191
5192 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5193 PyObject *resultobj = 0;
5194 wxSize *arg1 = (wxSize *) 0 ;
5195 bool result;
5196 void *argp1 = 0 ;
5197 int res1 = 0 ;
5198 PyObject *swig_obj[1] ;
5199
5200 if (!args) SWIG_fail;
5201 swig_obj[0] = args;
5202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5203 if (!SWIG_IsOK(res1)) {
5204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5205 }
5206 arg1 = reinterpret_cast< wxSize * >(argp1);
5207 {
5208 PyThreadState* __tstate = wxPyBeginAllowThreads();
5209 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5210 wxPyEndAllowThreads(__tstate);
5211 if (PyErr_Occurred()) SWIG_fail;
5212 }
5213 {
5214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5215 }
5216 return resultobj;
5217 fail:
5218 return NULL;
5219 }
5220
5221
5222 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5223 PyObject *resultobj = 0;
5224 wxSize *arg1 = (wxSize *) 0 ;
5225 wxSize *arg2 = 0 ;
5226 void *argp1 = 0 ;
5227 int res1 = 0 ;
5228 wxSize temp2 ;
5229 PyObject * obj0 = 0 ;
5230 PyObject * obj1 = 0 ;
5231 char * kwnames[] = {
5232 (char *) "self",(char *) "size", NULL
5233 };
5234
5235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5237 if (!SWIG_IsOK(res1)) {
5238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5239 }
5240 arg1 = reinterpret_cast< wxSize * >(argp1);
5241 {
5242 arg2 = &temp2;
5243 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5244 }
5245 {
5246 PyThreadState* __tstate = wxPyBeginAllowThreads();
5247 (arg1)->SetDefaults((wxSize const &)*arg2);
5248 wxPyEndAllowThreads(__tstate);
5249 if (PyErr_Occurred()) SWIG_fail;
5250 }
5251 resultobj = SWIG_Py_Void();
5252 return resultobj;
5253 fail:
5254 return NULL;
5255 }
5256
5257
5258 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5259 PyObject *resultobj = 0;
5260 wxSize *arg1 = (wxSize *) 0 ;
5261 PyObject *result = 0 ;
5262 void *argp1 = 0 ;
5263 int res1 = 0 ;
5264 PyObject *swig_obj[1] ;
5265
5266 if (!args) SWIG_fail;
5267 swig_obj[0] = args;
5268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5269 if (!SWIG_IsOK(res1)) {
5270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5271 }
5272 arg1 = reinterpret_cast< wxSize * >(argp1);
5273 {
5274 PyThreadState* __tstate = wxPyBeginAllowThreads();
5275 result = (PyObject *)wxSize_Get(arg1);
5276 wxPyEndAllowThreads(__tstate);
5277 if (PyErr_Occurred()) SWIG_fail;
5278 }
5279 resultobj = result;
5280 return resultobj;
5281 fail:
5282 return NULL;
5283 }
5284
5285
5286 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5287 PyObject *obj;
5288 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5289 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5290 return SWIG_Py_Void();
5291 }
5292
5293 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5294 return SWIG_Python_InitShadowInstance(args);
5295 }
5296
5297 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5298 PyObject *resultobj = 0;
5299 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5300 double arg2 ;
5301 void *argp1 = 0 ;
5302 int res1 = 0 ;
5303 double val2 ;
5304 int ecode2 = 0 ;
5305 PyObject *swig_obj[2] ;
5306
5307 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5309 if (!SWIG_IsOK(res1)) {
5310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5311 }
5312 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5313 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5314 if (!SWIG_IsOK(ecode2)) {
5315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5316 }
5317 arg2 = static_cast< double >(val2);
5318 if (arg1) (arg1)->x = arg2;
5319
5320 resultobj = SWIG_Py_Void();
5321 return resultobj;
5322 fail:
5323 return NULL;
5324 }
5325
5326
5327 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5328 PyObject *resultobj = 0;
5329 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5330 double result;
5331 void *argp1 = 0 ;
5332 int res1 = 0 ;
5333 PyObject *swig_obj[1] ;
5334
5335 if (!args) SWIG_fail;
5336 swig_obj[0] = args;
5337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5338 if (!SWIG_IsOK(res1)) {
5339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5340 }
5341 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5342 result = (double) ((arg1)->x);
5343 resultobj = SWIG_From_double(static_cast< double >(result));
5344 return resultobj;
5345 fail:
5346 return NULL;
5347 }
5348
5349
5350 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5351 PyObject *resultobj = 0;
5352 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5353 double arg2 ;
5354 void *argp1 = 0 ;
5355 int res1 = 0 ;
5356 double val2 ;
5357 int ecode2 = 0 ;
5358 PyObject *swig_obj[2] ;
5359
5360 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5362 if (!SWIG_IsOK(res1)) {
5363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5364 }
5365 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5366 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5367 if (!SWIG_IsOK(ecode2)) {
5368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5369 }
5370 arg2 = static_cast< double >(val2);
5371 if (arg1) (arg1)->y = arg2;
5372
5373 resultobj = SWIG_Py_Void();
5374 return resultobj;
5375 fail:
5376 return NULL;
5377 }
5378
5379
5380 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5381 PyObject *resultobj = 0;
5382 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5383 double result;
5384 void *argp1 = 0 ;
5385 int res1 = 0 ;
5386 PyObject *swig_obj[1] ;
5387
5388 if (!args) SWIG_fail;
5389 swig_obj[0] = args;
5390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5391 if (!SWIG_IsOK(res1)) {
5392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5393 }
5394 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5395 result = (double) ((arg1)->y);
5396 resultobj = SWIG_From_double(static_cast< double >(result));
5397 return resultobj;
5398 fail:
5399 return NULL;
5400 }
5401
5402
5403 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5404 PyObject *resultobj = 0;
5405 double arg1 = (double) 0.0 ;
5406 double arg2 = (double) 0.0 ;
5407 wxRealPoint *result = 0 ;
5408 double val1 ;
5409 int ecode1 = 0 ;
5410 double val2 ;
5411 int ecode2 = 0 ;
5412 PyObject * obj0 = 0 ;
5413 PyObject * obj1 = 0 ;
5414 char * kwnames[] = {
5415 (char *) "x",(char *) "y", NULL
5416 };
5417
5418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5419 if (obj0) {
5420 ecode1 = SWIG_AsVal_double(obj0, &val1);
5421 if (!SWIG_IsOK(ecode1)) {
5422 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5423 }
5424 arg1 = static_cast< double >(val1);
5425 }
5426 if (obj1) {
5427 ecode2 = SWIG_AsVal_double(obj1, &val2);
5428 if (!SWIG_IsOK(ecode2)) {
5429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5430 }
5431 arg2 = static_cast< double >(val2);
5432 }
5433 {
5434 PyThreadState* __tstate = wxPyBeginAllowThreads();
5435 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5436 wxPyEndAllowThreads(__tstate);
5437 if (PyErr_Occurred()) SWIG_fail;
5438 }
5439 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5440 return resultobj;
5441 fail:
5442 return NULL;
5443 }
5444
5445
5446 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5447 PyObject *resultobj = 0;
5448 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5449 void *argp1 = 0 ;
5450 int res1 = 0 ;
5451 PyObject *swig_obj[1] ;
5452
5453 if (!args) SWIG_fail;
5454 swig_obj[0] = args;
5455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5456 if (!SWIG_IsOK(res1)) {
5457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5458 }
5459 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5460 {
5461 PyThreadState* __tstate = wxPyBeginAllowThreads();
5462 delete arg1;
5463
5464 wxPyEndAllowThreads(__tstate);
5465 if (PyErr_Occurred()) SWIG_fail;
5466 }
5467 resultobj = SWIG_Py_Void();
5468 return resultobj;
5469 fail:
5470 return NULL;
5471 }
5472
5473
5474 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5475 PyObject *resultobj = 0;
5476 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5477 PyObject *arg2 = (PyObject *) 0 ;
5478 bool result;
5479 void *argp1 = 0 ;
5480 int res1 = 0 ;
5481 PyObject * obj0 = 0 ;
5482 PyObject * obj1 = 0 ;
5483 char * kwnames[] = {
5484 (char *) "self",(char *) "other", NULL
5485 };
5486
5487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5489 if (!SWIG_IsOK(res1)) {
5490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5491 }
5492 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5493 arg2 = obj1;
5494 {
5495 result = (bool)wxRealPoint___eq__(arg1,arg2);
5496 if (PyErr_Occurred()) SWIG_fail;
5497 }
5498 {
5499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5500 }
5501 return resultobj;
5502 fail:
5503 return NULL;
5504 }
5505
5506
5507 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5508 PyObject *resultobj = 0;
5509 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5510 PyObject *arg2 = (PyObject *) 0 ;
5511 bool result;
5512 void *argp1 = 0 ;
5513 int res1 = 0 ;
5514 PyObject * obj0 = 0 ;
5515 PyObject * obj1 = 0 ;
5516 char * kwnames[] = {
5517 (char *) "self",(char *) "other", NULL
5518 };
5519
5520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5522 if (!SWIG_IsOK(res1)) {
5523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5524 }
5525 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5526 arg2 = obj1;
5527 {
5528 result = (bool)wxRealPoint___ne__(arg1,arg2);
5529 if (PyErr_Occurred()) SWIG_fail;
5530 }
5531 {
5532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5533 }
5534 return resultobj;
5535 fail:
5536 return NULL;
5537 }
5538
5539
5540 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5541 PyObject *resultobj = 0;
5542 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5543 wxRealPoint *arg2 = 0 ;
5544 wxRealPoint result;
5545 void *argp1 = 0 ;
5546 int res1 = 0 ;
5547 wxRealPoint temp2 ;
5548 PyObject * obj0 = 0 ;
5549 PyObject * obj1 = 0 ;
5550 char * kwnames[] = {
5551 (char *) "self",(char *) "pt", NULL
5552 };
5553
5554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5556 if (!SWIG_IsOK(res1)) {
5557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5558 }
5559 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5560 {
5561 arg2 = &temp2;
5562 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5563 }
5564 {
5565 PyThreadState* __tstate = wxPyBeginAllowThreads();
5566 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5567 wxPyEndAllowThreads(__tstate);
5568 if (PyErr_Occurred()) SWIG_fail;
5569 }
5570 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5571 return resultobj;
5572 fail:
5573 return NULL;
5574 }
5575
5576
5577 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5578 PyObject *resultobj = 0;
5579 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5580 wxRealPoint *arg2 = 0 ;
5581 wxRealPoint result;
5582 void *argp1 = 0 ;
5583 int res1 = 0 ;
5584 wxRealPoint temp2 ;
5585 PyObject * obj0 = 0 ;
5586 PyObject * obj1 = 0 ;
5587 char * kwnames[] = {
5588 (char *) "self",(char *) "pt", NULL
5589 };
5590
5591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5593 if (!SWIG_IsOK(res1)) {
5594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5595 }
5596 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5597 {
5598 arg2 = &temp2;
5599 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5600 }
5601 {
5602 PyThreadState* __tstate = wxPyBeginAllowThreads();
5603 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5604 wxPyEndAllowThreads(__tstate);
5605 if (PyErr_Occurred()) SWIG_fail;
5606 }
5607 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5608 return resultobj;
5609 fail:
5610 return NULL;
5611 }
5612
5613
5614 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5615 PyObject *resultobj = 0;
5616 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5617 double arg2 ;
5618 double arg3 ;
5619 void *argp1 = 0 ;
5620 int res1 = 0 ;
5621 double val2 ;
5622 int ecode2 = 0 ;
5623 double val3 ;
5624 int ecode3 = 0 ;
5625 PyObject * obj0 = 0 ;
5626 PyObject * obj1 = 0 ;
5627 PyObject * obj2 = 0 ;
5628 char * kwnames[] = {
5629 (char *) "self",(char *) "x",(char *) "y", NULL
5630 };
5631
5632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5634 if (!SWIG_IsOK(res1)) {
5635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5636 }
5637 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5638 ecode2 = SWIG_AsVal_double(obj1, &val2);
5639 if (!SWIG_IsOK(ecode2)) {
5640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5641 }
5642 arg2 = static_cast< double >(val2);
5643 ecode3 = SWIG_AsVal_double(obj2, &val3);
5644 if (!SWIG_IsOK(ecode3)) {
5645 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5646 }
5647 arg3 = static_cast< double >(val3);
5648 {
5649 PyThreadState* __tstate = wxPyBeginAllowThreads();
5650 wxRealPoint_Set(arg1,arg2,arg3);
5651 wxPyEndAllowThreads(__tstate);
5652 if (PyErr_Occurred()) SWIG_fail;
5653 }
5654 resultobj = SWIG_Py_Void();
5655 return resultobj;
5656 fail:
5657 return NULL;
5658 }
5659
5660
5661 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5662 PyObject *resultobj = 0;
5663 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5664 PyObject *result = 0 ;
5665 void *argp1 = 0 ;
5666 int res1 = 0 ;
5667 PyObject *swig_obj[1] ;
5668
5669 if (!args) SWIG_fail;
5670 swig_obj[0] = args;
5671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5672 if (!SWIG_IsOK(res1)) {
5673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5674 }
5675 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5676 {
5677 PyThreadState* __tstate = wxPyBeginAllowThreads();
5678 result = (PyObject *)wxRealPoint_Get(arg1);
5679 wxPyEndAllowThreads(__tstate);
5680 if (PyErr_Occurred()) SWIG_fail;
5681 }
5682 resultobj = result;
5683 return resultobj;
5684 fail:
5685 return NULL;
5686 }
5687
5688
5689 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5690 PyObject *obj;
5691 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5692 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5693 return SWIG_Py_Void();
5694 }
5695
5696 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5697 return SWIG_Python_InitShadowInstance(args);
5698 }
5699
5700 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5701 PyObject *resultobj = 0;
5702 wxPoint *arg1 = (wxPoint *) 0 ;
5703 int arg2 ;
5704 void *argp1 = 0 ;
5705 int res1 = 0 ;
5706 int val2 ;
5707 int ecode2 = 0 ;
5708 PyObject *swig_obj[2] ;
5709
5710 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5712 if (!SWIG_IsOK(res1)) {
5713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5714 }
5715 arg1 = reinterpret_cast< wxPoint * >(argp1);
5716 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5717 if (!SWIG_IsOK(ecode2)) {
5718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5719 }
5720 arg2 = static_cast< int >(val2);
5721 if (arg1) (arg1)->x = arg2;
5722
5723 resultobj = SWIG_Py_Void();
5724 return resultobj;
5725 fail:
5726 return NULL;
5727 }
5728
5729
5730 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5731 PyObject *resultobj = 0;
5732 wxPoint *arg1 = (wxPoint *) 0 ;
5733 int result;
5734 void *argp1 = 0 ;
5735 int res1 = 0 ;
5736 PyObject *swig_obj[1] ;
5737
5738 if (!args) SWIG_fail;
5739 swig_obj[0] = args;
5740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5741 if (!SWIG_IsOK(res1)) {
5742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5743 }
5744 arg1 = reinterpret_cast< wxPoint * >(argp1);
5745 result = (int) ((arg1)->x);
5746 resultobj = SWIG_From_int(static_cast< int >(result));
5747 return resultobj;
5748 fail:
5749 return NULL;
5750 }
5751
5752
5753 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5754 PyObject *resultobj = 0;
5755 wxPoint *arg1 = (wxPoint *) 0 ;
5756 int arg2 ;
5757 void *argp1 = 0 ;
5758 int res1 = 0 ;
5759 int val2 ;
5760 int ecode2 = 0 ;
5761 PyObject *swig_obj[2] ;
5762
5763 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5765 if (!SWIG_IsOK(res1)) {
5766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5767 }
5768 arg1 = reinterpret_cast< wxPoint * >(argp1);
5769 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5770 if (!SWIG_IsOK(ecode2)) {
5771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5772 }
5773 arg2 = static_cast< int >(val2);
5774 if (arg1) (arg1)->y = arg2;
5775
5776 resultobj = SWIG_Py_Void();
5777 return resultobj;
5778 fail:
5779 return NULL;
5780 }
5781
5782
5783 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5784 PyObject *resultobj = 0;
5785 wxPoint *arg1 = (wxPoint *) 0 ;
5786 int result;
5787 void *argp1 = 0 ;
5788 int res1 = 0 ;
5789 PyObject *swig_obj[1] ;
5790
5791 if (!args) SWIG_fail;
5792 swig_obj[0] = args;
5793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5794 if (!SWIG_IsOK(res1)) {
5795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5796 }
5797 arg1 = reinterpret_cast< wxPoint * >(argp1);
5798 result = (int) ((arg1)->y);
5799 resultobj = SWIG_From_int(static_cast< int >(result));
5800 return resultobj;
5801 fail:
5802 return NULL;
5803 }
5804
5805
5806 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5807 PyObject *resultobj = 0;
5808 int arg1 = (int) 0 ;
5809 int arg2 = (int) 0 ;
5810 wxPoint *result = 0 ;
5811 int val1 ;
5812 int ecode1 = 0 ;
5813 int val2 ;
5814 int ecode2 = 0 ;
5815 PyObject * obj0 = 0 ;
5816 PyObject * obj1 = 0 ;
5817 char * kwnames[] = {
5818 (char *) "x",(char *) "y", NULL
5819 };
5820
5821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5822 if (obj0) {
5823 ecode1 = SWIG_AsVal_int(obj0, &val1);
5824 if (!SWIG_IsOK(ecode1)) {
5825 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5826 }
5827 arg1 = static_cast< int >(val1);
5828 }
5829 if (obj1) {
5830 ecode2 = SWIG_AsVal_int(obj1, &val2);
5831 if (!SWIG_IsOK(ecode2)) {
5832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5833 }
5834 arg2 = static_cast< int >(val2);
5835 }
5836 {
5837 PyThreadState* __tstate = wxPyBeginAllowThreads();
5838 result = (wxPoint *)new wxPoint(arg1,arg2);
5839 wxPyEndAllowThreads(__tstate);
5840 if (PyErr_Occurred()) SWIG_fail;
5841 }
5842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5843 return resultobj;
5844 fail:
5845 return NULL;
5846 }
5847
5848
5849 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5850 PyObject *resultobj = 0;
5851 wxPoint *arg1 = (wxPoint *) 0 ;
5852 void *argp1 = 0 ;
5853 int res1 = 0 ;
5854 PyObject *swig_obj[1] ;
5855
5856 if (!args) SWIG_fail;
5857 swig_obj[0] = args;
5858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5859 if (!SWIG_IsOK(res1)) {
5860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5861 }
5862 arg1 = reinterpret_cast< wxPoint * >(argp1);
5863 {
5864 PyThreadState* __tstate = wxPyBeginAllowThreads();
5865 delete arg1;
5866
5867 wxPyEndAllowThreads(__tstate);
5868 if (PyErr_Occurred()) SWIG_fail;
5869 }
5870 resultobj = SWIG_Py_Void();
5871 return resultobj;
5872 fail:
5873 return NULL;
5874 }
5875
5876
5877 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5878 PyObject *resultobj = 0;
5879 wxPoint *arg1 = (wxPoint *) 0 ;
5880 PyObject *arg2 = (PyObject *) 0 ;
5881 bool result;
5882 void *argp1 = 0 ;
5883 int res1 = 0 ;
5884 PyObject * obj0 = 0 ;
5885 PyObject * obj1 = 0 ;
5886 char * kwnames[] = {
5887 (char *) "self",(char *) "other", NULL
5888 };
5889
5890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5892 if (!SWIG_IsOK(res1)) {
5893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5894 }
5895 arg1 = reinterpret_cast< wxPoint * >(argp1);
5896 arg2 = obj1;
5897 {
5898 result = (bool)wxPoint___eq__(arg1,arg2);
5899 if (PyErr_Occurred()) SWIG_fail;
5900 }
5901 {
5902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5903 }
5904 return resultobj;
5905 fail:
5906 return NULL;
5907 }
5908
5909
5910 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5911 PyObject *resultobj = 0;
5912 wxPoint *arg1 = (wxPoint *) 0 ;
5913 PyObject *arg2 = (PyObject *) 0 ;
5914 bool result;
5915 void *argp1 = 0 ;
5916 int res1 = 0 ;
5917 PyObject * obj0 = 0 ;
5918 PyObject * obj1 = 0 ;
5919 char * kwnames[] = {
5920 (char *) "self",(char *) "other", NULL
5921 };
5922
5923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5925 if (!SWIG_IsOK(res1)) {
5926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5927 }
5928 arg1 = reinterpret_cast< wxPoint * >(argp1);
5929 arg2 = obj1;
5930 {
5931 result = (bool)wxPoint___ne__(arg1,arg2);
5932 if (PyErr_Occurred()) SWIG_fail;
5933 }
5934 {
5935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5936 }
5937 return resultobj;
5938 fail:
5939 return NULL;
5940 }
5941
5942
5943 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5944 PyObject *resultobj = 0;
5945 wxPoint *arg1 = (wxPoint *) 0 ;
5946 wxPoint *arg2 = 0 ;
5947 wxPoint result;
5948 void *argp1 = 0 ;
5949 int res1 = 0 ;
5950 wxPoint temp2 ;
5951 PyObject * obj0 = 0 ;
5952 PyObject * obj1 = 0 ;
5953 char * kwnames[] = {
5954 (char *) "self",(char *) "pt", NULL
5955 };
5956
5957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5959 if (!SWIG_IsOK(res1)) {
5960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5961 }
5962 arg1 = reinterpret_cast< wxPoint * >(argp1);
5963 {
5964 arg2 = &temp2;
5965 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5966 }
5967 {
5968 PyThreadState* __tstate = wxPyBeginAllowThreads();
5969 result = (arg1)->operator +((wxPoint const &)*arg2);
5970 wxPyEndAllowThreads(__tstate);
5971 if (PyErr_Occurred()) SWIG_fail;
5972 }
5973 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5974 return resultobj;
5975 fail:
5976 return NULL;
5977 }
5978
5979
5980 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5981 PyObject *resultobj = 0;
5982 wxPoint *arg1 = (wxPoint *) 0 ;
5983 wxPoint *arg2 = 0 ;
5984 wxPoint result;
5985 void *argp1 = 0 ;
5986 int res1 = 0 ;
5987 wxPoint temp2 ;
5988 PyObject * obj0 = 0 ;
5989 PyObject * obj1 = 0 ;
5990 char * kwnames[] = {
5991 (char *) "self",(char *) "pt", NULL
5992 };
5993
5994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5996 if (!SWIG_IsOK(res1)) {
5997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5998 }
5999 arg1 = reinterpret_cast< wxPoint * >(argp1);
6000 {
6001 arg2 = &temp2;
6002 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6003 }
6004 {
6005 PyThreadState* __tstate = wxPyBeginAllowThreads();
6006 result = (arg1)->operator -((wxPoint const &)*arg2);
6007 wxPyEndAllowThreads(__tstate);
6008 if (PyErr_Occurred()) SWIG_fail;
6009 }
6010 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6011 return resultobj;
6012 fail:
6013 return NULL;
6014 }
6015
6016
6017 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6018 PyObject *resultobj = 0;
6019 wxPoint *arg1 = (wxPoint *) 0 ;
6020 wxPoint *arg2 = 0 ;
6021 wxPoint *result = 0 ;
6022 void *argp1 = 0 ;
6023 int res1 = 0 ;
6024 wxPoint temp2 ;
6025 PyObject * obj0 = 0 ;
6026 PyObject * obj1 = 0 ;
6027 char * kwnames[] = {
6028 (char *) "self",(char *) "pt", NULL
6029 };
6030
6031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6033 if (!SWIG_IsOK(res1)) {
6034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6035 }
6036 arg1 = reinterpret_cast< wxPoint * >(argp1);
6037 {
6038 arg2 = &temp2;
6039 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6040 }
6041 {
6042 PyThreadState* __tstate = wxPyBeginAllowThreads();
6043 {
6044 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6045 result = (wxPoint *) &_result_ref;
6046 }
6047 wxPyEndAllowThreads(__tstate);
6048 if (PyErr_Occurred()) SWIG_fail;
6049 }
6050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6051 return resultobj;
6052 fail:
6053 return NULL;
6054 }
6055
6056
6057 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6058 PyObject *resultobj = 0;
6059 wxPoint *arg1 = (wxPoint *) 0 ;
6060 wxPoint *arg2 = 0 ;
6061 wxPoint *result = 0 ;
6062 void *argp1 = 0 ;
6063 int res1 = 0 ;
6064 wxPoint temp2 ;
6065 PyObject * obj0 = 0 ;
6066 PyObject * obj1 = 0 ;
6067 char * kwnames[] = {
6068 (char *) "self",(char *) "pt", NULL
6069 };
6070
6071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6073 if (!SWIG_IsOK(res1)) {
6074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6075 }
6076 arg1 = reinterpret_cast< wxPoint * >(argp1);
6077 {
6078 arg2 = &temp2;
6079 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6080 }
6081 {
6082 PyThreadState* __tstate = wxPyBeginAllowThreads();
6083 {
6084 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6085 result = (wxPoint *) &_result_ref;
6086 }
6087 wxPyEndAllowThreads(__tstate);
6088 if (PyErr_Occurred()) SWIG_fail;
6089 }
6090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6091 return resultobj;
6092 fail:
6093 return NULL;
6094 }
6095
6096
6097 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6098 PyObject *resultobj = 0;
6099 wxPoint *arg1 = (wxPoint *) 0 ;
6100 long arg2 ;
6101 long arg3 ;
6102 void *argp1 = 0 ;
6103 int res1 = 0 ;
6104 long val2 ;
6105 int ecode2 = 0 ;
6106 long val3 ;
6107 int ecode3 = 0 ;
6108 PyObject * obj0 = 0 ;
6109 PyObject * obj1 = 0 ;
6110 PyObject * obj2 = 0 ;
6111 char * kwnames[] = {
6112 (char *) "self",(char *) "x",(char *) "y", NULL
6113 };
6114
6115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6117 if (!SWIG_IsOK(res1)) {
6118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6119 }
6120 arg1 = reinterpret_cast< wxPoint * >(argp1);
6121 ecode2 = SWIG_AsVal_long(obj1, &val2);
6122 if (!SWIG_IsOK(ecode2)) {
6123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6124 }
6125 arg2 = static_cast< long >(val2);
6126 ecode3 = SWIG_AsVal_long(obj2, &val3);
6127 if (!SWIG_IsOK(ecode3)) {
6128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6129 }
6130 arg3 = static_cast< long >(val3);
6131 {
6132 PyThreadState* __tstate = wxPyBeginAllowThreads();
6133 wxPoint_Set(arg1,arg2,arg3);
6134 wxPyEndAllowThreads(__tstate);
6135 if (PyErr_Occurred()) SWIG_fail;
6136 }
6137 resultobj = SWIG_Py_Void();
6138 return resultobj;
6139 fail:
6140 return NULL;
6141 }
6142
6143
6144 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6145 PyObject *resultobj = 0;
6146 wxPoint *arg1 = (wxPoint *) 0 ;
6147 PyObject *result = 0 ;
6148 void *argp1 = 0 ;
6149 int res1 = 0 ;
6150 PyObject *swig_obj[1] ;
6151
6152 if (!args) SWIG_fail;
6153 swig_obj[0] = args;
6154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6155 if (!SWIG_IsOK(res1)) {
6156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6157 }
6158 arg1 = reinterpret_cast< wxPoint * >(argp1);
6159 {
6160 PyThreadState* __tstate = wxPyBeginAllowThreads();
6161 result = (PyObject *)wxPoint_Get(arg1);
6162 wxPyEndAllowThreads(__tstate);
6163 if (PyErr_Occurred()) SWIG_fail;
6164 }
6165 resultobj = result;
6166 return resultobj;
6167 fail:
6168 return NULL;
6169 }
6170
6171
6172 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6173 PyObject *obj;
6174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6175 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6176 return SWIG_Py_Void();
6177 }
6178
6179 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6180 return SWIG_Python_InitShadowInstance(args);
6181 }
6182
6183 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6184 PyObject *resultobj = 0;
6185 int arg1 = (int) 0 ;
6186 int arg2 = (int) 0 ;
6187 int arg3 = (int) 0 ;
6188 int arg4 = (int) 0 ;
6189 wxRect *result = 0 ;
6190 int val1 ;
6191 int ecode1 = 0 ;
6192 int val2 ;
6193 int ecode2 = 0 ;
6194 int val3 ;
6195 int ecode3 = 0 ;
6196 int val4 ;
6197 int ecode4 = 0 ;
6198 PyObject * obj0 = 0 ;
6199 PyObject * obj1 = 0 ;
6200 PyObject * obj2 = 0 ;
6201 PyObject * obj3 = 0 ;
6202 char * kwnames[] = {
6203 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6204 };
6205
6206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6207 if (obj0) {
6208 ecode1 = SWIG_AsVal_int(obj0, &val1);
6209 if (!SWIG_IsOK(ecode1)) {
6210 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6211 }
6212 arg1 = static_cast< int >(val1);
6213 }
6214 if (obj1) {
6215 ecode2 = SWIG_AsVal_int(obj1, &val2);
6216 if (!SWIG_IsOK(ecode2)) {
6217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6218 }
6219 arg2 = static_cast< int >(val2);
6220 }
6221 if (obj2) {
6222 ecode3 = SWIG_AsVal_int(obj2, &val3);
6223 if (!SWIG_IsOK(ecode3)) {
6224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6225 }
6226 arg3 = static_cast< int >(val3);
6227 }
6228 if (obj3) {
6229 ecode4 = SWIG_AsVal_int(obj3, &val4);
6230 if (!SWIG_IsOK(ecode4)) {
6231 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6232 }
6233 arg4 = static_cast< int >(val4);
6234 }
6235 {
6236 PyThreadState* __tstate = wxPyBeginAllowThreads();
6237 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6238 wxPyEndAllowThreads(__tstate);
6239 if (PyErr_Occurred()) SWIG_fail;
6240 }
6241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6242 return resultobj;
6243 fail:
6244 return NULL;
6245 }
6246
6247
6248 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6249 PyObject *resultobj = 0;
6250 wxPoint *arg1 = 0 ;
6251 wxPoint *arg2 = 0 ;
6252 wxRect *result = 0 ;
6253 wxPoint temp1 ;
6254 wxPoint temp2 ;
6255 PyObject * obj0 = 0 ;
6256 PyObject * obj1 = 0 ;
6257 char * kwnames[] = {
6258 (char *) "topLeft",(char *) "bottomRight", NULL
6259 };
6260
6261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6262 {
6263 arg1 = &temp1;
6264 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6265 }
6266 {
6267 arg2 = &temp2;
6268 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6269 }
6270 {
6271 PyThreadState* __tstate = wxPyBeginAllowThreads();
6272 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6273 wxPyEndAllowThreads(__tstate);
6274 if (PyErr_Occurred()) SWIG_fail;
6275 }
6276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6277 return resultobj;
6278 fail:
6279 return NULL;
6280 }
6281
6282
6283 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6284 PyObject *resultobj = 0;
6285 wxPoint *arg1 = 0 ;
6286 wxSize *arg2 = 0 ;
6287 wxRect *result = 0 ;
6288 wxPoint temp1 ;
6289 wxSize temp2 ;
6290 PyObject * obj0 = 0 ;
6291 PyObject * obj1 = 0 ;
6292 char * kwnames[] = {
6293 (char *) "pos",(char *) "size", NULL
6294 };
6295
6296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6297 {
6298 arg1 = &temp1;
6299 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6300 }
6301 {
6302 arg2 = &temp2;
6303 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6304 }
6305 {
6306 PyThreadState* __tstate = wxPyBeginAllowThreads();
6307 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6308 wxPyEndAllowThreads(__tstate);
6309 if (PyErr_Occurred()) SWIG_fail;
6310 }
6311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6312 return resultobj;
6313 fail:
6314 return NULL;
6315 }
6316
6317
6318 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6319 PyObject *resultobj = 0;
6320 wxSize *arg1 = 0 ;
6321 wxRect *result = 0 ;
6322 wxSize temp1 ;
6323 PyObject * obj0 = 0 ;
6324 char * kwnames[] = {
6325 (char *) "size", NULL
6326 };
6327
6328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6329 {
6330 arg1 = &temp1;
6331 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6332 }
6333 {
6334 PyThreadState* __tstate = wxPyBeginAllowThreads();
6335 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6336 wxPyEndAllowThreads(__tstate);
6337 if (PyErr_Occurred()) SWIG_fail;
6338 }
6339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6340 return resultobj;
6341 fail:
6342 return NULL;
6343 }
6344
6345
6346 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6347 PyObject *resultobj = 0;
6348 wxRect *arg1 = (wxRect *) 0 ;
6349 void *argp1 = 0 ;
6350 int res1 = 0 ;
6351 PyObject *swig_obj[1] ;
6352
6353 if (!args) SWIG_fail;
6354 swig_obj[0] = args;
6355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6356 if (!SWIG_IsOK(res1)) {
6357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6358 }
6359 arg1 = reinterpret_cast< wxRect * >(argp1);
6360 {
6361 PyThreadState* __tstate = wxPyBeginAllowThreads();
6362 delete arg1;
6363
6364 wxPyEndAllowThreads(__tstate);
6365 if (PyErr_Occurred()) SWIG_fail;
6366 }
6367 resultobj = SWIG_Py_Void();
6368 return resultobj;
6369 fail:
6370 return NULL;
6371 }
6372
6373
6374 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6375 PyObject *resultobj = 0;
6376 wxRect *arg1 = (wxRect *) 0 ;
6377 int result;
6378 void *argp1 = 0 ;
6379 int res1 = 0 ;
6380 PyObject *swig_obj[1] ;
6381
6382 if (!args) SWIG_fail;
6383 swig_obj[0] = args;
6384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6385 if (!SWIG_IsOK(res1)) {
6386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6387 }
6388 arg1 = reinterpret_cast< wxRect * >(argp1);
6389 {
6390 PyThreadState* __tstate = wxPyBeginAllowThreads();
6391 result = (int)((wxRect const *)arg1)->GetX();
6392 wxPyEndAllowThreads(__tstate);
6393 if (PyErr_Occurred()) SWIG_fail;
6394 }
6395 resultobj = SWIG_From_int(static_cast< int >(result));
6396 return resultobj;
6397 fail:
6398 return NULL;
6399 }
6400
6401
6402 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6403 PyObject *resultobj = 0;
6404 wxRect *arg1 = (wxRect *) 0 ;
6405 int arg2 ;
6406 void *argp1 = 0 ;
6407 int res1 = 0 ;
6408 int val2 ;
6409 int ecode2 = 0 ;
6410 PyObject * obj0 = 0 ;
6411 PyObject * obj1 = 0 ;
6412 char * kwnames[] = {
6413 (char *) "self",(char *) "x", NULL
6414 };
6415
6416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6418 if (!SWIG_IsOK(res1)) {
6419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6420 }
6421 arg1 = reinterpret_cast< wxRect * >(argp1);
6422 ecode2 = SWIG_AsVal_int(obj1, &val2);
6423 if (!SWIG_IsOK(ecode2)) {
6424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6425 }
6426 arg2 = static_cast< int >(val2);
6427 {
6428 PyThreadState* __tstate = wxPyBeginAllowThreads();
6429 (arg1)->SetX(arg2);
6430 wxPyEndAllowThreads(__tstate);
6431 if (PyErr_Occurred()) SWIG_fail;
6432 }
6433 resultobj = SWIG_Py_Void();
6434 return resultobj;
6435 fail:
6436 return NULL;
6437 }
6438
6439
6440 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6441 PyObject *resultobj = 0;
6442 wxRect *arg1 = (wxRect *) 0 ;
6443 int result;
6444 void *argp1 = 0 ;
6445 int res1 = 0 ;
6446 PyObject *swig_obj[1] ;
6447
6448 if (!args) SWIG_fail;
6449 swig_obj[0] = args;
6450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6451 if (!SWIG_IsOK(res1)) {
6452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6453 }
6454 arg1 = reinterpret_cast< wxRect * >(argp1);
6455 {
6456 PyThreadState* __tstate = wxPyBeginAllowThreads();
6457 result = (int)(arg1)->GetY();
6458 wxPyEndAllowThreads(__tstate);
6459 if (PyErr_Occurred()) SWIG_fail;
6460 }
6461 resultobj = SWIG_From_int(static_cast< int >(result));
6462 return resultobj;
6463 fail:
6464 return NULL;
6465 }
6466
6467
6468 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6469 PyObject *resultobj = 0;
6470 wxRect *arg1 = (wxRect *) 0 ;
6471 int arg2 ;
6472 void *argp1 = 0 ;
6473 int res1 = 0 ;
6474 int val2 ;
6475 int ecode2 = 0 ;
6476 PyObject * obj0 = 0 ;
6477 PyObject * obj1 = 0 ;
6478 char * kwnames[] = {
6479 (char *) "self",(char *) "y", NULL
6480 };
6481
6482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6484 if (!SWIG_IsOK(res1)) {
6485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6486 }
6487 arg1 = reinterpret_cast< wxRect * >(argp1);
6488 ecode2 = SWIG_AsVal_int(obj1, &val2);
6489 if (!SWIG_IsOK(ecode2)) {
6490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6491 }
6492 arg2 = static_cast< int >(val2);
6493 {
6494 PyThreadState* __tstate = wxPyBeginAllowThreads();
6495 (arg1)->SetY(arg2);
6496 wxPyEndAllowThreads(__tstate);
6497 if (PyErr_Occurred()) SWIG_fail;
6498 }
6499 resultobj = SWIG_Py_Void();
6500 return resultobj;
6501 fail:
6502 return NULL;
6503 }
6504
6505
6506 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6507 PyObject *resultobj = 0;
6508 wxRect *arg1 = (wxRect *) 0 ;
6509 int result;
6510 void *argp1 = 0 ;
6511 int res1 = 0 ;
6512 PyObject *swig_obj[1] ;
6513
6514 if (!args) SWIG_fail;
6515 swig_obj[0] = args;
6516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6517 if (!SWIG_IsOK(res1)) {
6518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6519 }
6520 arg1 = reinterpret_cast< wxRect * >(argp1);
6521 {
6522 PyThreadState* __tstate = wxPyBeginAllowThreads();
6523 result = (int)((wxRect const *)arg1)->GetWidth();
6524 wxPyEndAllowThreads(__tstate);
6525 if (PyErr_Occurred()) SWIG_fail;
6526 }
6527 resultobj = SWIG_From_int(static_cast< int >(result));
6528 return resultobj;
6529 fail:
6530 return NULL;
6531 }
6532
6533
6534 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6535 PyObject *resultobj = 0;
6536 wxRect *arg1 = (wxRect *) 0 ;
6537 int arg2 ;
6538 void *argp1 = 0 ;
6539 int res1 = 0 ;
6540 int val2 ;
6541 int ecode2 = 0 ;
6542 PyObject * obj0 = 0 ;
6543 PyObject * obj1 = 0 ;
6544 char * kwnames[] = {
6545 (char *) "self",(char *) "w", NULL
6546 };
6547
6548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6550 if (!SWIG_IsOK(res1)) {
6551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6552 }
6553 arg1 = reinterpret_cast< wxRect * >(argp1);
6554 ecode2 = SWIG_AsVal_int(obj1, &val2);
6555 if (!SWIG_IsOK(ecode2)) {
6556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6557 }
6558 arg2 = static_cast< int >(val2);
6559 {
6560 PyThreadState* __tstate = wxPyBeginAllowThreads();
6561 (arg1)->SetWidth(arg2);
6562 wxPyEndAllowThreads(__tstate);
6563 if (PyErr_Occurred()) SWIG_fail;
6564 }
6565 resultobj = SWIG_Py_Void();
6566 return resultobj;
6567 fail:
6568 return NULL;
6569 }
6570
6571
6572 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6573 PyObject *resultobj = 0;
6574 wxRect *arg1 = (wxRect *) 0 ;
6575 int result;
6576 void *argp1 = 0 ;
6577 int res1 = 0 ;
6578 PyObject *swig_obj[1] ;
6579
6580 if (!args) SWIG_fail;
6581 swig_obj[0] = args;
6582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6583 if (!SWIG_IsOK(res1)) {
6584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6585 }
6586 arg1 = reinterpret_cast< wxRect * >(argp1);
6587 {
6588 PyThreadState* __tstate = wxPyBeginAllowThreads();
6589 result = (int)((wxRect const *)arg1)->GetHeight();
6590 wxPyEndAllowThreads(__tstate);
6591 if (PyErr_Occurred()) SWIG_fail;
6592 }
6593 resultobj = SWIG_From_int(static_cast< int >(result));
6594 return resultobj;
6595 fail:
6596 return NULL;
6597 }
6598
6599
6600 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6601 PyObject *resultobj = 0;
6602 wxRect *arg1 = (wxRect *) 0 ;
6603 int arg2 ;
6604 void *argp1 = 0 ;
6605 int res1 = 0 ;
6606 int val2 ;
6607 int ecode2 = 0 ;
6608 PyObject * obj0 = 0 ;
6609 PyObject * obj1 = 0 ;
6610 char * kwnames[] = {
6611 (char *) "self",(char *) "h", NULL
6612 };
6613
6614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6616 if (!SWIG_IsOK(res1)) {
6617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6618 }
6619 arg1 = reinterpret_cast< wxRect * >(argp1);
6620 ecode2 = SWIG_AsVal_int(obj1, &val2);
6621 if (!SWIG_IsOK(ecode2)) {
6622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6623 }
6624 arg2 = static_cast< int >(val2);
6625 {
6626 PyThreadState* __tstate = wxPyBeginAllowThreads();
6627 (arg1)->SetHeight(arg2);
6628 wxPyEndAllowThreads(__tstate);
6629 if (PyErr_Occurred()) SWIG_fail;
6630 }
6631 resultobj = SWIG_Py_Void();
6632 return resultobj;
6633 fail:
6634 return NULL;
6635 }
6636
6637
6638 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6639 PyObject *resultobj = 0;
6640 wxRect *arg1 = (wxRect *) 0 ;
6641 wxPoint result;
6642 void *argp1 = 0 ;
6643 int res1 = 0 ;
6644 PyObject *swig_obj[1] ;
6645
6646 if (!args) SWIG_fail;
6647 swig_obj[0] = args;
6648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6649 if (!SWIG_IsOK(res1)) {
6650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6651 }
6652 arg1 = reinterpret_cast< wxRect * >(argp1);
6653 {
6654 PyThreadState* __tstate = wxPyBeginAllowThreads();
6655 result = ((wxRect const *)arg1)->GetPosition();
6656 wxPyEndAllowThreads(__tstate);
6657 if (PyErr_Occurred()) SWIG_fail;
6658 }
6659 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6660 return resultobj;
6661 fail:
6662 return NULL;
6663 }
6664
6665
6666 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6667 PyObject *resultobj = 0;
6668 wxRect *arg1 = (wxRect *) 0 ;
6669 wxPoint *arg2 = 0 ;
6670 void *argp1 = 0 ;
6671 int res1 = 0 ;
6672 wxPoint temp2 ;
6673 PyObject * obj0 = 0 ;
6674 PyObject * obj1 = 0 ;
6675 char * kwnames[] = {
6676 (char *) "self",(char *) "p", NULL
6677 };
6678
6679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6681 if (!SWIG_IsOK(res1)) {
6682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6683 }
6684 arg1 = reinterpret_cast< wxRect * >(argp1);
6685 {
6686 arg2 = &temp2;
6687 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6688 }
6689 {
6690 PyThreadState* __tstate = wxPyBeginAllowThreads();
6691 (arg1)->SetPosition((wxPoint const &)*arg2);
6692 wxPyEndAllowThreads(__tstate);
6693 if (PyErr_Occurred()) SWIG_fail;
6694 }
6695 resultobj = SWIG_Py_Void();
6696 return resultobj;
6697 fail:
6698 return NULL;
6699 }
6700
6701
6702 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6703 PyObject *resultobj = 0;
6704 wxRect *arg1 = (wxRect *) 0 ;
6705 wxSize result;
6706 void *argp1 = 0 ;
6707 int res1 = 0 ;
6708 PyObject *swig_obj[1] ;
6709
6710 if (!args) SWIG_fail;
6711 swig_obj[0] = args;
6712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6713 if (!SWIG_IsOK(res1)) {
6714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6715 }
6716 arg1 = reinterpret_cast< wxRect * >(argp1);
6717 {
6718 PyThreadState* __tstate = wxPyBeginAllowThreads();
6719 result = ((wxRect const *)arg1)->GetSize();
6720 wxPyEndAllowThreads(__tstate);
6721 if (PyErr_Occurred()) SWIG_fail;
6722 }
6723 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6724 return resultobj;
6725 fail:
6726 return NULL;
6727 }
6728
6729
6730 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6731 PyObject *resultobj = 0;
6732 wxRect *arg1 = (wxRect *) 0 ;
6733 wxSize *arg2 = 0 ;
6734 void *argp1 = 0 ;
6735 int res1 = 0 ;
6736 wxSize temp2 ;
6737 PyObject * obj0 = 0 ;
6738 PyObject * obj1 = 0 ;
6739 char * kwnames[] = {
6740 (char *) "self",(char *) "s", NULL
6741 };
6742
6743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6745 if (!SWIG_IsOK(res1)) {
6746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6747 }
6748 arg1 = reinterpret_cast< wxRect * >(argp1);
6749 {
6750 arg2 = &temp2;
6751 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6752 }
6753 {
6754 PyThreadState* __tstate = wxPyBeginAllowThreads();
6755 (arg1)->SetSize((wxSize const &)*arg2);
6756 wxPyEndAllowThreads(__tstate);
6757 if (PyErr_Occurred()) SWIG_fail;
6758 }
6759 resultobj = SWIG_Py_Void();
6760 return resultobj;
6761 fail:
6762 return NULL;
6763 }
6764
6765
6766 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6767 PyObject *resultobj = 0;
6768 wxRect *arg1 = (wxRect *) 0 ;
6769 bool result;
6770 void *argp1 = 0 ;
6771 int res1 = 0 ;
6772 PyObject *swig_obj[1] ;
6773
6774 if (!args) SWIG_fail;
6775 swig_obj[0] = args;
6776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6777 if (!SWIG_IsOK(res1)) {
6778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6779 }
6780 arg1 = reinterpret_cast< wxRect * >(argp1);
6781 {
6782 PyThreadState* __tstate = wxPyBeginAllowThreads();
6783 result = (bool)((wxRect const *)arg1)->IsEmpty();
6784 wxPyEndAllowThreads(__tstate);
6785 if (PyErr_Occurred()) SWIG_fail;
6786 }
6787 {
6788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6789 }
6790 return resultobj;
6791 fail:
6792 return NULL;
6793 }
6794
6795
6796 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6797 PyObject *resultobj = 0;
6798 wxRect *arg1 = (wxRect *) 0 ;
6799 wxPoint result;
6800 void *argp1 = 0 ;
6801 int res1 = 0 ;
6802 PyObject *swig_obj[1] ;
6803
6804 if (!args) SWIG_fail;
6805 swig_obj[0] = args;
6806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6807 if (!SWIG_IsOK(res1)) {
6808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6809 }
6810 arg1 = reinterpret_cast< wxRect * >(argp1);
6811 {
6812 PyThreadState* __tstate = wxPyBeginAllowThreads();
6813 result = ((wxRect const *)arg1)->GetTopLeft();
6814 wxPyEndAllowThreads(__tstate);
6815 if (PyErr_Occurred()) SWIG_fail;
6816 }
6817 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6818 return resultobj;
6819 fail:
6820 return NULL;
6821 }
6822
6823
6824 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6825 PyObject *resultobj = 0;
6826 wxRect *arg1 = (wxRect *) 0 ;
6827 wxPoint *arg2 = 0 ;
6828 void *argp1 = 0 ;
6829 int res1 = 0 ;
6830 wxPoint temp2 ;
6831 PyObject * obj0 = 0 ;
6832 PyObject * obj1 = 0 ;
6833 char * kwnames[] = {
6834 (char *) "self",(char *) "p", NULL
6835 };
6836
6837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6839 if (!SWIG_IsOK(res1)) {
6840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6841 }
6842 arg1 = reinterpret_cast< wxRect * >(argp1);
6843 {
6844 arg2 = &temp2;
6845 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6846 }
6847 {
6848 PyThreadState* __tstate = wxPyBeginAllowThreads();
6849 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6850 wxPyEndAllowThreads(__tstate);
6851 if (PyErr_Occurred()) SWIG_fail;
6852 }
6853 resultobj = SWIG_Py_Void();
6854 return resultobj;
6855 fail:
6856 return NULL;
6857 }
6858
6859
6860 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6861 PyObject *resultobj = 0;
6862 wxRect *arg1 = (wxRect *) 0 ;
6863 wxPoint result;
6864 void *argp1 = 0 ;
6865 int res1 = 0 ;
6866 PyObject *swig_obj[1] ;
6867
6868 if (!args) SWIG_fail;
6869 swig_obj[0] = args;
6870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6871 if (!SWIG_IsOK(res1)) {
6872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6873 }
6874 arg1 = reinterpret_cast< wxRect * >(argp1);
6875 {
6876 PyThreadState* __tstate = wxPyBeginAllowThreads();
6877 result = ((wxRect const *)arg1)->GetBottomRight();
6878 wxPyEndAllowThreads(__tstate);
6879 if (PyErr_Occurred()) SWIG_fail;
6880 }
6881 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6882 return resultobj;
6883 fail:
6884 return NULL;
6885 }
6886
6887
6888 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6889 PyObject *resultobj = 0;
6890 wxRect *arg1 = (wxRect *) 0 ;
6891 wxPoint *arg2 = 0 ;
6892 void *argp1 = 0 ;
6893 int res1 = 0 ;
6894 wxPoint temp2 ;
6895 PyObject * obj0 = 0 ;
6896 PyObject * obj1 = 0 ;
6897 char * kwnames[] = {
6898 (char *) "self",(char *) "p", NULL
6899 };
6900
6901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6903 if (!SWIG_IsOK(res1)) {
6904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6905 }
6906 arg1 = reinterpret_cast< wxRect * >(argp1);
6907 {
6908 arg2 = &temp2;
6909 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6910 }
6911 {
6912 PyThreadState* __tstate = wxPyBeginAllowThreads();
6913 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6914 wxPyEndAllowThreads(__tstate);
6915 if (PyErr_Occurred()) SWIG_fail;
6916 }
6917 resultobj = SWIG_Py_Void();
6918 return resultobj;
6919 fail:
6920 return NULL;
6921 }
6922
6923
6924 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6925 PyObject *resultobj = 0;
6926 wxRect *arg1 = (wxRect *) 0 ;
6927 wxPoint result;
6928 void *argp1 = 0 ;
6929 int res1 = 0 ;
6930 PyObject *swig_obj[1] ;
6931
6932 if (!args) SWIG_fail;
6933 swig_obj[0] = args;
6934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6935 if (!SWIG_IsOK(res1)) {
6936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6937 }
6938 arg1 = reinterpret_cast< wxRect * >(argp1);
6939 {
6940 PyThreadState* __tstate = wxPyBeginAllowThreads();
6941 result = ((wxRect const *)arg1)->GetTopRight();
6942 wxPyEndAllowThreads(__tstate);
6943 if (PyErr_Occurred()) SWIG_fail;
6944 }
6945 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6946 return resultobj;
6947 fail:
6948 return NULL;
6949 }
6950
6951
6952 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6953 PyObject *resultobj = 0;
6954 wxRect *arg1 = (wxRect *) 0 ;
6955 wxPoint *arg2 = 0 ;
6956 void *argp1 = 0 ;
6957 int res1 = 0 ;
6958 wxPoint temp2 ;
6959 PyObject * obj0 = 0 ;
6960 PyObject * obj1 = 0 ;
6961 char * kwnames[] = {
6962 (char *) "self",(char *) "p", NULL
6963 };
6964
6965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6967 if (!SWIG_IsOK(res1)) {
6968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6969 }
6970 arg1 = reinterpret_cast< wxRect * >(argp1);
6971 {
6972 arg2 = &temp2;
6973 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6974 }
6975 {
6976 PyThreadState* __tstate = wxPyBeginAllowThreads();
6977 (arg1)->SetTopRight((wxPoint const &)*arg2);
6978 wxPyEndAllowThreads(__tstate);
6979 if (PyErr_Occurred()) SWIG_fail;
6980 }
6981 resultobj = SWIG_Py_Void();
6982 return resultobj;
6983 fail:
6984 return NULL;
6985 }
6986
6987
6988 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6989 PyObject *resultobj = 0;
6990 wxRect *arg1 = (wxRect *) 0 ;
6991 wxPoint result;
6992 void *argp1 = 0 ;
6993 int res1 = 0 ;
6994 PyObject *swig_obj[1] ;
6995
6996 if (!args) SWIG_fail;
6997 swig_obj[0] = args;
6998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6999 if (!SWIG_IsOK(res1)) {
7000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7001 }
7002 arg1 = reinterpret_cast< wxRect * >(argp1);
7003 {
7004 PyThreadState* __tstate = wxPyBeginAllowThreads();
7005 result = ((wxRect const *)arg1)->GetBottomLeft();
7006 wxPyEndAllowThreads(__tstate);
7007 if (PyErr_Occurred()) SWIG_fail;
7008 }
7009 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7010 return resultobj;
7011 fail:
7012 return NULL;
7013 }
7014
7015
7016 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7017 PyObject *resultobj = 0;
7018 wxRect *arg1 = (wxRect *) 0 ;
7019 wxPoint *arg2 = 0 ;
7020 void *argp1 = 0 ;
7021 int res1 = 0 ;
7022 wxPoint temp2 ;
7023 PyObject * obj0 = 0 ;
7024 PyObject * obj1 = 0 ;
7025 char * kwnames[] = {
7026 (char *) "self",(char *) "p", NULL
7027 };
7028
7029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7031 if (!SWIG_IsOK(res1)) {
7032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7033 }
7034 arg1 = reinterpret_cast< wxRect * >(argp1);
7035 {
7036 arg2 = &temp2;
7037 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7038 }
7039 {
7040 PyThreadState* __tstate = wxPyBeginAllowThreads();
7041 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7042 wxPyEndAllowThreads(__tstate);
7043 if (PyErr_Occurred()) SWIG_fail;
7044 }
7045 resultobj = SWIG_Py_Void();
7046 return resultobj;
7047 fail:
7048 return NULL;
7049 }
7050
7051
7052 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7053 PyObject *resultobj = 0;
7054 wxRect *arg1 = (wxRect *) 0 ;
7055 int result;
7056 void *argp1 = 0 ;
7057 int res1 = 0 ;
7058 PyObject *swig_obj[1] ;
7059
7060 if (!args) SWIG_fail;
7061 swig_obj[0] = args;
7062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7063 if (!SWIG_IsOK(res1)) {
7064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7065 }
7066 arg1 = reinterpret_cast< wxRect * >(argp1);
7067 {
7068 PyThreadState* __tstate = wxPyBeginAllowThreads();
7069 result = (int)((wxRect const *)arg1)->GetLeft();
7070 wxPyEndAllowThreads(__tstate);
7071 if (PyErr_Occurred()) SWIG_fail;
7072 }
7073 resultobj = SWIG_From_int(static_cast< int >(result));
7074 return resultobj;
7075 fail:
7076 return NULL;
7077 }
7078
7079
7080 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7081 PyObject *resultobj = 0;
7082 wxRect *arg1 = (wxRect *) 0 ;
7083 int result;
7084 void *argp1 = 0 ;
7085 int res1 = 0 ;
7086 PyObject *swig_obj[1] ;
7087
7088 if (!args) SWIG_fail;
7089 swig_obj[0] = args;
7090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7091 if (!SWIG_IsOK(res1)) {
7092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7093 }
7094 arg1 = reinterpret_cast< wxRect * >(argp1);
7095 {
7096 PyThreadState* __tstate = wxPyBeginAllowThreads();
7097 result = (int)((wxRect const *)arg1)->GetTop();
7098 wxPyEndAllowThreads(__tstate);
7099 if (PyErr_Occurred()) SWIG_fail;
7100 }
7101 resultobj = SWIG_From_int(static_cast< int >(result));
7102 return resultobj;
7103 fail:
7104 return NULL;
7105 }
7106
7107
7108 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7109 PyObject *resultobj = 0;
7110 wxRect *arg1 = (wxRect *) 0 ;
7111 int result;
7112 void *argp1 = 0 ;
7113 int res1 = 0 ;
7114 PyObject *swig_obj[1] ;
7115
7116 if (!args) SWIG_fail;
7117 swig_obj[0] = args;
7118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7119 if (!SWIG_IsOK(res1)) {
7120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7121 }
7122 arg1 = reinterpret_cast< wxRect * >(argp1);
7123 {
7124 PyThreadState* __tstate = wxPyBeginAllowThreads();
7125 result = (int)((wxRect const *)arg1)->GetBottom();
7126 wxPyEndAllowThreads(__tstate);
7127 if (PyErr_Occurred()) SWIG_fail;
7128 }
7129 resultobj = SWIG_From_int(static_cast< int >(result));
7130 return resultobj;
7131 fail:
7132 return NULL;
7133 }
7134
7135
7136 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7137 PyObject *resultobj = 0;
7138 wxRect *arg1 = (wxRect *) 0 ;
7139 int result;
7140 void *argp1 = 0 ;
7141 int res1 = 0 ;
7142 PyObject *swig_obj[1] ;
7143
7144 if (!args) SWIG_fail;
7145 swig_obj[0] = args;
7146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7147 if (!SWIG_IsOK(res1)) {
7148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7149 }
7150 arg1 = reinterpret_cast< wxRect * >(argp1);
7151 {
7152 PyThreadState* __tstate = wxPyBeginAllowThreads();
7153 result = (int)((wxRect const *)arg1)->GetRight();
7154 wxPyEndAllowThreads(__tstate);
7155 if (PyErr_Occurred()) SWIG_fail;
7156 }
7157 resultobj = SWIG_From_int(static_cast< int >(result));
7158 return resultobj;
7159 fail:
7160 return NULL;
7161 }
7162
7163
7164 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7165 PyObject *resultobj = 0;
7166 wxRect *arg1 = (wxRect *) 0 ;
7167 int arg2 ;
7168 void *argp1 = 0 ;
7169 int res1 = 0 ;
7170 int val2 ;
7171 int ecode2 = 0 ;
7172 PyObject * obj0 = 0 ;
7173 PyObject * obj1 = 0 ;
7174 char * kwnames[] = {
7175 (char *) "self",(char *) "left", NULL
7176 };
7177
7178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7180 if (!SWIG_IsOK(res1)) {
7181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7182 }
7183 arg1 = reinterpret_cast< wxRect * >(argp1);
7184 ecode2 = SWIG_AsVal_int(obj1, &val2);
7185 if (!SWIG_IsOK(ecode2)) {
7186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7187 }
7188 arg2 = static_cast< int >(val2);
7189 {
7190 PyThreadState* __tstate = wxPyBeginAllowThreads();
7191 (arg1)->SetLeft(arg2);
7192 wxPyEndAllowThreads(__tstate);
7193 if (PyErr_Occurred()) SWIG_fail;
7194 }
7195 resultobj = SWIG_Py_Void();
7196 return resultobj;
7197 fail:
7198 return NULL;
7199 }
7200
7201
7202 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7203 PyObject *resultobj = 0;
7204 wxRect *arg1 = (wxRect *) 0 ;
7205 int arg2 ;
7206 void *argp1 = 0 ;
7207 int res1 = 0 ;
7208 int val2 ;
7209 int ecode2 = 0 ;
7210 PyObject * obj0 = 0 ;
7211 PyObject * obj1 = 0 ;
7212 char * kwnames[] = {
7213 (char *) "self",(char *) "right", NULL
7214 };
7215
7216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7218 if (!SWIG_IsOK(res1)) {
7219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7220 }
7221 arg1 = reinterpret_cast< wxRect * >(argp1);
7222 ecode2 = SWIG_AsVal_int(obj1, &val2);
7223 if (!SWIG_IsOK(ecode2)) {
7224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7225 }
7226 arg2 = static_cast< int >(val2);
7227 {
7228 PyThreadState* __tstate = wxPyBeginAllowThreads();
7229 (arg1)->SetRight(arg2);
7230 wxPyEndAllowThreads(__tstate);
7231 if (PyErr_Occurred()) SWIG_fail;
7232 }
7233 resultobj = SWIG_Py_Void();
7234 return resultobj;
7235 fail:
7236 return NULL;
7237 }
7238
7239
7240 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7241 PyObject *resultobj = 0;
7242 wxRect *arg1 = (wxRect *) 0 ;
7243 int arg2 ;
7244 void *argp1 = 0 ;
7245 int res1 = 0 ;
7246 int val2 ;
7247 int ecode2 = 0 ;
7248 PyObject * obj0 = 0 ;
7249 PyObject * obj1 = 0 ;
7250 char * kwnames[] = {
7251 (char *) "self",(char *) "top", NULL
7252 };
7253
7254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7256 if (!SWIG_IsOK(res1)) {
7257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7258 }
7259 arg1 = reinterpret_cast< wxRect * >(argp1);
7260 ecode2 = SWIG_AsVal_int(obj1, &val2);
7261 if (!SWIG_IsOK(ecode2)) {
7262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7263 }
7264 arg2 = static_cast< int >(val2);
7265 {
7266 PyThreadState* __tstate = wxPyBeginAllowThreads();
7267 (arg1)->SetTop(arg2);
7268 wxPyEndAllowThreads(__tstate);
7269 if (PyErr_Occurred()) SWIG_fail;
7270 }
7271 resultobj = SWIG_Py_Void();
7272 return resultobj;
7273 fail:
7274 return NULL;
7275 }
7276
7277
7278 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7279 PyObject *resultobj = 0;
7280 wxRect *arg1 = (wxRect *) 0 ;
7281 int arg2 ;
7282 void *argp1 = 0 ;
7283 int res1 = 0 ;
7284 int val2 ;
7285 int ecode2 = 0 ;
7286 PyObject * obj0 = 0 ;
7287 PyObject * obj1 = 0 ;
7288 char * kwnames[] = {
7289 (char *) "self",(char *) "bottom", NULL
7290 };
7291
7292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7294 if (!SWIG_IsOK(res1)) {
7295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7296 }
7297 arg1 = reinterpret_cast< wxRect * >(argp1);
7298 ecode2 = SWIG_AsVal_int(obj1, &val2);
7299 if (!SWIG_IsOK(ecode2)) {
7300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7301 }
7302 arg2 = static_cast< int >(val2);
7303 {
7304 PyThreadState* __tstate = wxPyBeginAllowThreads();
7305 (arg1)->SetBottom(arg2);
7306 wxPyEndAllowThreads(__tstate);
7307 if (PyErr_Occurred()) SWIG_fail;
7308 }
7309 resultobj = SWIG_Py_Void();
7310 return resultobj;
7311 fail:
7312 return NULL;
7313 }
7314
7315
7316 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7317 PyObject *resultobj = 0;
7318 wxRect *arg1 = (wxRect *) 0 ;
7319 int arg2 ;
7320 int arg3 ;
7321 wxRect *result = 0 ;
7322 void *argp1 = 0 ;
7323 int res1 = 0 ;
7324 int val2 ;
7325 int ecode2 = 0 ;
7326 int val3 ;
7327 int ecode3 = 0 ;
7328 PyObject * obj0 = 0 ;
7329 PyObject * obj1 = 0 ;
7330 PyObject * obj2 = 0 ;
7331 char * kwnames[] = {
7332 (char *) "self",(char *) "dx",(char *) "dy", NULL
7333 };
7334
7335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7337 if (!SWIG_IsOK(res1)) {
7338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7339 }
7340 arg1 = reinterpret_cast< wxRect * >(argp1);
7341 ecode2 = SWIG_AsVal_int(obj1, &val2);
7342 if (!SWIG_IsOK(ecode2)) {
7343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7344 }
7345 arg2 = static_cast< int >(val2);
7346 ecode3 = SWIG_AsVal_int(obj2, &val3);
7347 if (!SWIG_IsOK(ecode3)) {
7348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7349 }
7350 arg3 = static_cast< int >(val3);
7351 {
7352 PyThreadState* __tstate = wxPyBeginAllowThreads();
7353 {
7354 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7355 result = (wxRect *) &_result_ref;
7356 }
7357 wxPyEndAllowThreads(__tstate);
7358 if (PyErr_Occurred()) SWIG_fail;
7359 }
7360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7361 return resultobj;
7362 fail:
7363 return NULL;
7364 }
7365
7366
7367 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7368 PyObject *resultobj = 0;
7369 wxRect *arg1 = (wxRect *) 0 ;
7370 int arg2 ;
7371 int arg3 ;
7372 wxRect *result = 0 ;
7373 void *argp1 = 0 ;
7374 int res1 = 0 ;
7375 int val2 ;
7376 int ecode2 = 0 ;
7377 int val3 ;
7378 int ecode3 = 0 ;
7379 PyObject * obj0 = 0 ;
7380 PyObject * obj1 = 0 ;
7381 PyObject * obj2 = 0 ;
7382 char * kwnames[] = {
7383 (char *) "self",(char *) "dx",(char *) "dy", NULL
7384 };
7385
7386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7388 if (!SWIG_IsOK(res1)) {
7389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7390 }
7391 arg1 = reinterpret_cast< wxRect * >(argp1);
7392 ecode2 = SWIG_AsVal_int(obj1, &val2);
7393 if (!SWIG_IsOK(ecode2)) {
7394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7395 }
7396 arg2 = static_cast< int >(val2);
7397 ecode3 = SWIG_AsVal_int(obj2, &val3);
7398 if (!SWIG_IsOK(ecode3)) {
7399 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7400 }
7401 arg3 = static_cast< int >(val3);
7402 {
7403 PyThreadState* __tstate = wxPyBeginAllowThreads();
7404 {
7405 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7406 result = (wxRect *) &_result_ref;
7407 }
7408 wxPyEndAllowThreads(__tstate);
7409 if (PyErr_Occurred()) SWIG_fail;
7410 }
7411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7412 return resultobj;
7413 fail:
7414 return NULL;
7415 }
7416
7417
7418 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7419 PyObject *resultobj = 0;
7420 wxRect *arg1 = (wxRect *) 0 ;
7421 int arg2 ;
7422 int arg3 ;
7423 void *argp1 = 0 ;
7424 int res1 = 0 ;
7425 int val2 ;
7426 int ecode2 = 0 ;
7427 int val3 ;
7428 int ecode3 = 0 ;
7429 PyObject * obj0 = 0 ;
7430 PyObject * obj1 = 0 ;
7431 PyObject * obj2 = 0 ;
7432 char * kwnames[] = {
7433 (char *) "self",(char *) "dx",(char *) "dy", NULL
7434 };
7435
7436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7438 if (!SWIG_IsOK(res1)) {
7439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7440 }
7441 arg1 = reinterpret_cast< wxRect * >(argp1);
7442 ecode2 = SWIG_AsVal_int(obj1, &val2);
7443 if (!SWIG_IsOK(ecode2)) {
7444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7445 }
7446 arg2 = static_cast< int >(val2);
7447 ecode3 = SWIG_AsVal_int(obj2, &val3);
7448 if (!SWIG_IsOK(ecode3)) {
7449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7450 }
7451 arg3 = static_cast< int >(val3);
7452 {
7453 PyThreadState* __tstate = wxPyBeginAllowThreads();
7454 (arg1)->Offset(arg2,arg3);
7455 wxPyEndAllowThreads(__tstate);
7456 if (PyErr_Occurred()) SWIG_fail;
7457 }
7458 resultobj = SWIG_Py_Void();
7459 return resultobj;
7460 fail:
7461 return NULL;
7462 }
7463
7464
7465 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7466 PyObject *resultobj = 0;
7467 wxRect *arg1 = (wxRect *) 0 ;
7468 wxPoint *arg2 = 0 ;
7469 void *argp1 = 0 ;
7470 int res1 = 0 ;
7471 wxPoint temp2 ;
7472 PyObject * obj0 = 0 ;
7473 PyObject * obj1 = 0 ;
7474 char * kwnames[] = {
7475 (char *) "self",(char *) "pt", NULL
7476 };
7477
7478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7480 if (!SWIG_IsOK(res1)) {
7481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7482 }
7483 arg1 = reinterpret_cast< wxRect * >(argp1);
7484 {
7485 arg2 = &temp2;
7486 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7487 }
7488 {
7489 PyThreadState* __tstate = wxPyBeginAllowThreads();
7490 (arg1)->Offset((wxPoint const &)*arg2);
7491 wxPyEndAllowThreads(__tstate);
7492 if (PyErr_Occurred()) SWIG_fail;
7493 }
7494 resultobj = SWIG_Py_Void();
7495 return resultobj;
7496 fail:
7497 return NULL;
7498 }
7499
7500
7501 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7502 PyObject *resultobj = 0;
7503 wxRect *arg1 = (wxRect *) 0 ;
7504 wxRect *arg2 = 0 ;
7505 wxRect result;
7506 void *argp1 = 0 ;
7507 int res1 = 0 ;
7508 wxRect temp2 ;
7509 PyObject * obj0 = 0 ;
7510 PyObject * obj1 = 0 ;
7511 char * kwnames[] = {
7512 (char *) "self",(char *) "rect", NULL
7513 };
7514
7515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7517 if (!SWIG_IsOK(res1)) {
7518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7519 }
7520 arg1 = reinterpret_cast< wxRect * >(argp1);
7521 {
7522 arg2 = &temp2;
7523 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7524 }
7525 {
7526 PyThreadState* __tstate = wxPyBeginAllowThreads();
7527 result = (arg1)->Intersect((wxRect const &)*arg2);
7528 wxPyEndAllowThreads(__tstate);
7529 if (PyErr_Occurred()) SWIG_fail;
7530 }
7531 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7532 return resultobj;
7533 fail:
7534 return NULL;
7535 }
7536
7537
7538 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7539 PyObject *resultobj = 0;
7540 wxRect *arg1 = (wxRect *) 0 ;
7541 wxRect *arg2 = 0 ;
7542 wxRect result;
7543 void *argp1 = 0 ;
7544 int res1 = 0 ;
7545 wxRect temp2 ;
7546 PyObject * obj0 = 0 ;
7547 PyObject * obj1 = 0 ;
7548 char * kwnames[] = {
7549 (char *) "self",(char *) "rect", NULL
7550 };
7551
7552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7554 if (!SWIG_IsOK(res1)) {
7555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7556 }
7557 arg1 = reinterpret_cast< wxRect * >(argp1);
7558 {
7559 arg2 = &temp2;
7560 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7561 }
7562 {
7563 PyThreadState* __tstate = wxPyBeginAllowThreads();
7564 result = (arg1)->Union((wxRect const &)*arg2);
7565 wxPyEndAllowThreads(__tstate);
7566 if (PyErr_Occurred()) SWIG_fail;
7567 }
7568 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7569 return resultobj;
7570 fail:
7571 return NULL;
7572 }
7573
7574
7575 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7576 PyObject *resultobj = 0;
7577 wxRect *arg1 = (wxRect *) 0 ;
7578 wxRect *arg2 = 0 ;
7579 wxRect result;
7580 void *argp1 = 0 ;
7581 int res1 = 0 ;
7582 wxRect temp2 ;
7583 PyObject * obj0 = 0 ;
7584 PyObject * obj1 = 0 ;
7585 char * kwnames[] = {
7586 (char *) "self",(char *) "rect", NULL
7587 };
7588
7589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7591 if (!SWIG_IsOK(res1)) {
7592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7593 }
7594 arg1 = reinterpret_cast< wxRect * >(argp1);
7595 {
7596 arg2 = &temp2;
7597 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7598 }
7599 {
7600 PyThreadState* __tstate = wxPyBeginAllowThreads();
7601 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7602 wxPyEndAllowThreads(__tstate);
7603 if (PyErr_Occurred()) SWIG_fail;
7604 }
7605 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7606 return resultobj;
7607 fail:
7608 return NULL;
7609 }
7610
7611
7612 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7613 PyObject *resultobj = 0;
7614 wxRect *arg1 = (wxRect *) 0 ;
7615 wxRect *arg2 = 0 ;
7616 wxRect *result = 0 ;
7617 void *argp1 = 0 ;
7618 int res1 = 0 ;
7619 wxRect temp2 ;
7620 PyObject * obj0 = 0 ;
7621 PyObject * obj1 = 0 ;
7622 char * kwnames[] = {
7623 (char *) "self",(char *) "rect", NULL
7624 };
7625
7626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7628 if (!SWIG_IsOK(res1)) {
7629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7630 }
7631 arg1 = reinterpret_cast< wxRect * >(argp1);
7632 {
7633 arg2 = &temp2;
7634 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7635 }
7636 {
7637 PyThreadState* __tstate = wxPyBeginAllowThreads();
7638 {
7639 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7640 result = (wxRect *) &_result_ref;
7641 }
7642 wxPyEndAllowThreads(__tstate);
7643 if (PyErr_Occurred()) SWIG_fail;
7644 }
7645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7646 return resultobj;
7647 fail:
7648 return NULL;
7649 }
7650
7651
7652 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7653 PyObject *resultobj = 0;
7654 wxRect *arg1 = (wxRect *) 0 ;
7655 PyObject *arg2 = (PyObject *) 0 ;
7656 bool result;
7657 void *argp1 = 0 ;
7658 int res1 = 0 ;
7659 PyObject * obj0 = 0 ;
7660 PyObject * obj1 = 0 ;
7661 char * kwnames[] = {
7662 (char *) "self",(char *) "other", NULL
7663 };
7664
7665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7667 if (!SWIG_IsOK(res1)) {
7668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7669 }
7670 arg1 = reinterpret_cast< wxRect * >(argp1);
7671 arg2 = obj1;
7672 {
7673 result = (bool)wxRect___eq__(arg1,arg2);
7674 if (PyErr_Occurred()) SWIG_fail;
7675 }
7676 {
7677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7678 }
7679 return resultobj;
7680 fail:
7681 return NULL;
7682 }
7683
7684
7685 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7686 PyObject *resultobj = 0;
7687 wxRect *arg1 = (wxRect *) 0 ;
7688 PyObject *arg2 = (PyObject *) 0 ;
7689 bool result;
7690 void *argp1 = 0 ;
7691 int res1 = 0 ;
7692 PyObject * obj0 = 0 ;
7693 PyObject * obj1 = 0 ;
7694 char * kwnames[] = {
7695 (char *) "self",(char *) "other", NULL
7696 };
7697
7698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7700 if (!SWIG_IsOK(res1)) {
7701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7702 }
7703 arg1 = reinterpret_cast< wxRect * >(argp1);
7704 arg2 = obj1;
7705 {
7706 result = (bool)wxRect___ne__(arg1,arg2);
7707 if (PyErr_Occurred()) SWIG_fail;
7708 }
7709 {
7710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7711 }
7712 return resultobj;
7713 fail:
7714 return NULL;
7715 }
7716
7717
7718 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7719 PyObject *resultobj = 0;
7720 wxRect *arg1 = (wxRect *) 0 ;
7721 int arg2 ;
7722 int arg3 ;
7723 bool result;
7724 void *argp1 = 0 ;
7725 int res1 = 0 ;
7726 int val2 ;
7727 int ecode2 = 0 ;
7728 int val3 ;
7729 int ecode3 = 0 ;
7730 PyObject * obj0 = 0 ;
7731 PyObject * obj1 = 0 ;
7732 PyObject * obj2 = 0 ;
7733 char * kwnames[] = {
7734 (char *) "self",(char *) "x",(char *) "y", NULL
7735 };
7736
7737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7739 if (!SWIG_IsOK(res1)) {
7740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7741 }
7742 arg1 = reinterpret_cast< wxRect * >(argp1);
7743 ecode2 = SWIG_AsVal_int(obj1, &val2);
7744 if (!SWIG_IsOK(ecode2)) {
7745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7746 }
7747 arg2 = static_cast< int >(val2);
7748 ecode3 = SWIG_AsVal_int(obj2, &val3);
7749 if (!SWIG_IsOK(ecode3)) {
7750 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7751 }
7752 arg3 = static_cast< int >(val3);
7753 {
7754 PyThreadState* __tstate = wxPyBeginAllowThreads();
7755 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7756 wxPyEndAllowThreads(__tstate);
7757 if (PyErr_Occurred()) SWIG_fail;
7758 }
7759 {
7760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7761 }
7762 return resultobj;
7763 fail:
7764 return NULL;
7765 }
7766
7767
7768 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7769 PyObject *resultobj = 0;
7770 wxRect *arg1 = (wxRect *) 0 ;
7771 wxPoint *arg2 = 0 ;
7772 bool result;
7773 void *argp1 = 0 ;
7774 int res1 = 0 ;
7775 wxPoint temp2 ;
7776 PyObject * obj0 = 0 ;
7777 PyObject * obj1 = 0 ;
7778 char * kwnames[] = {
7779 (char *) "self",(char *) "pt", NULL
7780 };
7781
7782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7784 if (!SWIG_IsOK(res1)) {
7785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7786 }
7787 arg1 = reinterpret_cast< wxRect * >(argp1);
7788 {
7789 arg2 = &temp2;
7790 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7791 }
7792 {
7793 PyThreadState* __tstate = wxPyBeginAllowThreads();
7794 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7795 wxPyEndAllowThreads(__tstate);
7796 if (PyErr_Occurred()) SWIG_fail;
7797 }
7798 {
7799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7800 }
7801 return resultobj;
7802 fail:
7803 return NULL;
7804 }
7805
7806
7807 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7808 PyObject *resultobj = 0;
7809 wxRect *arg1 = (wxRect *) 0 ;
7810 wxRect *arg2 = 0 ;
7811 bool result;
7812 void *argp1 = 0 ;
7813 int res1 = 0 ;
7814 wxRect temp2 ;
7815 PyObject * obj0 = 0 ;
7816 PyObject * obj1 = 0 ;
7817 char * kwnames[] = {
7818 (char *) "self",(char *) "rect", NULL
7819 };
7820
7821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7823 if (!SWIG_IsOK(res1)) {
7824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7825 }
7826 arg1 = reinterpret_cast< wxRect * >(argp1);
7827 {
7828 arg2 = &temp2;
7829 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7830 }
7831 {
7832 PyThreadState* __tstate = wxPyBeginAllowThreads();
7833 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7834 wxPyEndAllowThreads(__tstate);
7835 if (PyErr_Occurred()) SWIG_fail;
7836 }
7837 {
7838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7839 }
7840 return resultobj;
7841 fail:
7842 return NULL;
7843 }
7844
7845
7846 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7847 PyObject *resultobj = 0;
7848 wxRect *arg1 = (wxRect *) 0 ;
7849 wxRect *arg2 = 0 ;
7850 bool result;
7851 void *argp1 = 0 ;
7852 int res1 = 0 ;
7853 wxRect temp2 ;
7854 PyObject * obj0 = 0 ;
7855 PyObject * obj1 = 0 ;
7856 char * kwnames[] = {
7857 (char *) "self",(char *) "rect", NULL
7858 };
7859
7860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7862 if (!SWIG_IsOK(res1)) {
7863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7864 }
7865 arg1 = reinterpret_cast< wxRect * >(argp1);
7866 {
7867 arg2 = &temp2;
7868 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7869 }
7870 {
7871 PyThreadState* __tstate = wxPyBeginAllowThreads();
7872 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7873 wxPyEndAllowThreads(__tstate);
7874 if (PyErr_Occurred()) SWIG_fail;
7875 }
7876 {
7877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7878 }
7879 return resultobj;
7880 fail:
7881 return NULL;
7882 }
7883
7884
7885 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7886 PyObject *resultobj = 0;
7887 wxRect *arg1 = (wxRect *) 0 ;
7888 wxRect *arg2 = 0 ;
7889 int arg3 = (int) wxBOTH ;
7890 wxRect result;
7891 void *argp1 = 0 ;
7892 int res1 = 0 ;
7893 wxRect temp2 ;
7894 int val3 ;
7895 int ecode3 = 0 ;
7896 PyObject * obj0 = 0 ;
7897 PyObject * obj1 = 0 ;
7898 PyObject * obj2 = 0 ;
7899 char * kwnames[] = {
7900 (char *) "self",(char *) "r",(char *) "dir", NULL
7901 };
7902
7903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7905 if (!SWIG_IsOK(res1)) {
7906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7907 }
7908 arg1 = reinterpret_cast< wxRect * >(argp1);
7909 {
7910 arg2 = &temp2;
7911 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7912 }
7913 if (obj2) {
7914 ecode3 = SWIG_AsVal_int(obj2, &val3);
7915 if (!SWIG_IsOK(ecode3)) {
7916 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7917 }
7918 arg3 = static_cast< int >(val3);
7919 }
7920 {
7921 PyThreadState* __tstate = wxPyBeginAllowThreads();
7922 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7923 wxPyEndAllowThreads(__tstate);
7924 if (PyErr_Occurred()) SWIG_fail;
7925 }
7926 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7927 return resultobj;
7928 fail:
7929 return NULL;
7930 }
7931
7932
7933 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7934 PyObject *resultobj = 0;
7935 wxRect *arg1 = (wxRect *) 0 ;
7936 int arg2 ;
7937 void *argp1 = 0 ;
7938 int res1 = 0 ;
7939 int val2 ;
7940 int ecode2 = 0 ;
7941 PyObject *swig_obj[2] ;
7942
7943 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7945 if (!SWIG_IsOK(res1)) {
7946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7947 }
7948 arg1 = reinterpret_cast< wxRect * >(argp1);
7949 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7950 if (!SWIG_IsOK(ecode2)) {
7951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7952 }
7953 arg2 = static_cast< int >(val2);
7954 if (arg1) (arg1)->x = arg2;
7955
7956 resultobj = SWIG_Py_Void();
7957 return resultobj;
7958 fail:
7959 return NULL;
7960 }
7961
7962
7963 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7964 PyObject *resultobj = 0;
7965 wxRect *arg1 = (wxRect *) 0 ;
7966 int result;
7967 void *argp1 = 0 ;
7968 int res1 = 0 ;
7969 PyObject *swig_obj[1] ;
7970
7971 if (!args) SWIG_fail;
7972 swig_obj[0] = args;
7973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7974 if (!SWIG_IsOK(res1)) {
7975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7976 }
7977 arg1 = reinterpret_cast< wxRect * >(argp1);
7978 result = (int) ((arg1)->x);
7979 resultobj = SWIG_From_int(static_cast< int >(result));
7980 return resultobj;
7981 fail:
7982 return NULL;
7983 }
7984
7985
7986 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7987 PyObject *resultobj = 0;
7988 wxRect *arg1 = (wxRect *) 0 ;
7989 int arg2 ;
7990 void *argp1 = 0 ;
7991 int res1 = 0 ;
7992 int val2 ;
7993 int ecode2 = 0 ;
7994 PyObject *swig_obj[2] ;
7995
7996 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7998 if (!SWIG_IsOK(res1)) {
7999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
8000 }
8001 arg1 = reinterpret_cast< wxRect * >(argp1);
8002 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8003 if (!SWIG_IsOK(ecode2)) {
8004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
8005 }
8006 arg2 = static_cast< int >(val2);
8007 if (arg1) (arg1)->y = arg2;
8008
8009 resultobj = SWIG_Py_Void();
8010 return resultobj;
8011 fail:
8012 return NULL;
8013 }
8014
8015
8016 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8017 PyObject *resultobj = 0;
8018 wxRect *arg1 = (wxRect *) 0 ;
8019 int result;
8020 void *argp1 = 0 ;
8021 int res1 = 0 ;
8022 PyObject *swig_obj[1] ;
8023
8024 if (!args) SWIG_fail;
8025 swig_obj[0] = args;
8026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8027 if (!SWIG_IsOK(res1)) {
8028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
8029 }
8030 arg1 = reinterpret_cast< wxRect * >(argp1);
8031 result = (int) ((arg1)->y);
8032 resultobj = SWIG_From_int(static_cast< int >(result));
8033 return resultobj;
8034 fail:
8035 return NULL;
8036 }
8037
8038
8039 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8040 PyObject *resultobj = 0;
8041 wxRect *arg1 = (wxRect *) 0 ;
8042 int arg2 ;
8043 void *argp1 = 0 ;
8044 int res1 = 0 ;
8045 int val2 ;
8046 int ecode2 = 0 ;
8047 PyObject *swig_obj[2] ;
8048
8049 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
8050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8051 if (!SWIG_IsOK(res1)) {
8052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
8053 }
8054 arg1 = reinterpret_cast< wxRect * >(argp1);
8055 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8056 if (!SWIG_IsOK(ecode2)) {
8057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
8058 }
8059 arg2 = static_cast< int >(val2);
8060 if (arg1) (arg1)->width = arg2;
8061
8062 resultobj = SWIG_Py_Void();
8063 return resultobj;
8064 fail:
8065 return NULL;
8066 }
8067
8068
8069 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8070 PyObject *resultobj = 0;
8071 wxRect *arg1 = (wxRect *) 0 ;
8072 int result;
8073 void *argp1 = 0 ;
8074 int res1 = 0 ;
8075 PyObject *swig_obj[1] ;
8076
8077 if (!args) SWIG_fail;
8078 swig_obj[0] = args;
8079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8080 if (!SWIG_IsOK(res1)) {
8081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8082 }
8083 arg1 = reinterpret_cast< wxRect * >(argp1);
8084 result = (int) ((arg1)->width);
8085 resultobj = SWIG_From_int(static_cast< int >(result));
8086 return resultobj;
8087 fail:
8088 return NULL;
8089 }
8090
8091
8092 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8093 PyObject *resultobj = 0;
8094 wxRect *arg1 = (wxRect *) 0 ;
8095 int arg2 ;
8096 void *argp1 = 0 ;
8097 int res1 = 0 ;
8098 int val2 ;
8099 int ecode2 = 0 ;
8100 PyObject *swig_obj[2] ;
8101
8102 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8104 if (!SWIG_IsOK(res1)) {
8105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8106 }
8107 arg1 = reinterpret_cast< wxRect * >(argp1);
8108 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8109 if (!SWIG_IsOK(ecode2)) {
8110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8111 }
8112 arg2 = static_cast< int >(val2);
8113 if (arg1) (arg1)->height = arg2;
8114
8115 resultobj = SWIG_Py_Void();
8116 return resultobj;
8117 fail:
8118 return NULL;
8119 }
8120
8121
8122 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8123 PyObject *resultobj = 0;
8124 wxRect *arg1 = (wxRect *) 0 ;
8125 int result;
8126 void *argp1 = 0 ;
8127 int res1 = 0 ;
8128 PyObject *swig_obj[1] ;
8129
8130 if (!args) SWIG_fail;
8131 swig_obj[0] = args;
8132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8133 if (!SWIG_IsOK(res1)) {
8134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8135 }
8136 arg1 = reinterpret_cast< wxRect * >(argp1);
8137 result = (int) ((arg1)->height);
8138 resultobj = SWIG_From_int(static_cast< int >(result));
8139 return resultobj;
8140 fail:
8141 return NULL;
8142 }
8143
8144
8145 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8146 PyObject *resultobj = 0;
8147 wxRect *arg1 = (wxRect *) 0 ;
8148 int arg2 = (int) 0 ;
8149 int arg3 = (int) 0 ;
8150 int arg4 = (int) 0 ;
8151 int arg5 = (int) 0 ;
8152 void *argp1 = 0 ;
8153 int res1 = 0 ;
8154 int val2 ;
8155 int ecode2 = 0 ;
8156 int val3 ;
8157 int ecode3 = 0 ;
8158 int val4 ;
8159 int ecode4 = 0 ;
8160 int val5 ;
8161 int ecode5 = 0 ;
8162 PyObject * obj0 = 0 ;
8163 PyObject * obj1 = 0 ;
8164 PyObject * obj2 = 0 ;
8165 PyObject * obj3 = 0 ;
8166 PyObject * obj4 = 0 ;
8167 char * kwnames[] = {
8168 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8169 };
8170
8171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8173 if (!SWIG_IsOK(res1)) {
8174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8175 }
8176 arg1 = reinterpret_cast< wxRect * >(argp1);
8177 if (obj1) {
8178 ecode2 = SWIG_AsVal_int(obj1, &val2);
8179 if (!SWIG_IsOK(ecode2)) {
8180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8181 }
8182 arg2 = static_cast< int >(val2);
8183 }
8184 if (obj2) {
8185 ecode3 = SWIG_AsVal_int(obj2, &val3);
8186 if (!SWIG_IsOK(ecode3)) {
8187 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8188 }
8189 arg3 = static_cast< int >(val3);
8190 }
8191 if (obj3) {
8192 ecode4 = SWIG_AsVal_int(obj3, &val4);
8193 if (!SWIG_IsOK(ecode4)) {
8194 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8195 }
8196 arg4 = static_cast< int >(val4);
8197 }
8198 if (obj4) {
8199 ecode5 = SWIG_AsVal_int(obj4, &val5);
8200 if (!SWIG_IsOK(ecode5)) {
8201 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8202 }
8203 arg5 = static_cast< int >(val5);
8204 }
8205 {
8206 PyThreadState* __tstate = wxPyBeginAllowThreads();
8207 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8208 wxPyEndAllowThreads(__tstate);
8209 if (PyErr_Occurred()) SWIG_fail;
8210 }
8211 resultobj = SWIG_Py_Void();
8212 return resultobj;
8213 fail:
8214 return NULL;
8215 }
8216
8217
8218 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8219 PyObject *resultobj = 0;
8220 wxRect *arg1 = (wxRect *) 0 ;
8221 PyObject *result = 0 ;
8222 void *argp1 = 0 ;
8223 int res1 = 0 ;
8224 PyObject *swig_obj[1] ;
8225
8226 if (!args) SWIG_fail;
8227 swig_obj[0] = args;
8228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8229 if (!SWIG_IsOK(res1)) {
8230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8231 }
8232 arg1 = reinterpret_cast< wxRect * >(argp1);
8233 {
8234 PyThreadState* __tstate = wxPyBeginAllowThreads();
8235 result = (PyObject *)wxRect_Get(arg1);
8236 wxPyEndAllowThreads(__tstate);
8237 if (PyErr_Occurred()) SWIG_fail;
8238 }
8239 resultobj = result;
8240 return resultobj;
8241 fail:
8242 return NULL;
8243 }
8244
8245
8246 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8247 PyObject *obj;
8248 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8249 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8250 return SWIG_Py_Void();
8251 }
8252
8253 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8254 return SWIG_Python_InitShadowInstance(args);
8255 }
8256
8257 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8258 PyObject *resultobj = 0;
8259 wxRect *arg1 = (wxRect *) 0 ;
8260 wxRect *arg2 = (wxRect *) 0 ;
8261 PyObject *result = 0 ;
8262 void *argp1 = 0 ;
8263 int res1 = 0 ;
8264 void *argp2 = 0 ;
8265 int res2 = 0 ;
8266 PyObject * obj0 = 0 ;
8267 PyObject * obj1 = 0 ;
8268 char * kwnames[] = {
8269 (char *) "r1",(char *) "r2", NULL
8270 };
8271
8272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8274 if (!SWIG_IsOK(res1)) {
8275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8276 }
8277 arg1 = reinterpret_cast< wxRect * >(argp1);
8278 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8279 if (!SWIG_IsOK(res2)) {
8280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8281 }
8282 arg2 = reinterpret_cast< wxRect * >(argp2);
8283 {
8284 if (!wxPyCheckForApp()) SWIG_fail;
8285 PyThreadState* __tstate = wxPyBeginAllowThreads();
8286 result = (PyObject *)wxIntersectRect(arg1,arg2);
8287 wxPyEndAllowThreads(__tstate);
8288 if (PyErr_Occurred()) SWIG_fail;
8289 }
8290 resultobj = result;
8291 return resultobj;
8292 fail:
8293 return NULL;
8294 }
8295
8296
8297 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8298 PyObject *resultobj = 0;
8299 double arg1 = (double) 0.0 ;
8300 double arg2 = (double) 0.0 ;
8301 wxPoint2D *result = 0 ;
8302 double val1 ;
8303 int ecode1 = 0 ;
8304 double val2 ;
8305 int ecode2 = 0 ;
8306 PyObject * obj0 = 0 ;
8307 PyObject * obj1 = 0 ;
8308 char * kwnames[] = {
8309 (char *) "x",(char *) "y", NULL
8310 };
8311
8312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8313 if (obj0) {
8314 ecode1 = SWIG_AsVal_double(obj0, &val1);
8315 if (!SWIG_IsOK(ecode1)) {
8316 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8317 }
8318 arg1 = static_cast< double >(val1);
8319 }
8320 if (obj1) {
8321 ecode2 = SWIG_AsVal_double(obj1, &val2);
8322 if (!SWIG_IsOK(ecode2)) {
8323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8324 }
8325 arg2 = static_cast< double >(val2);
8326 }
8327 {
8328 PyThreadState* __tstate = wxPyBeginAllowThreads();
8329 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8330 wxPyEndAllowThreads(__tstate);
8331 if (PyErr_Occurred()) SWIG_fail;
8332 }
8333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8334 return resultobj;
8335 fail:
8336 return NULL;
8337 }
8338
8339
8340 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8341 PyObject *resultobj = 0;
8342 wxPoint2D *arg1 = 0 ;
8343 wxPoint2D *result = 0 ;
8344 wxPoint2D temp1 ;
8345 PyObject * obj0 = 0 ;
8346 char * kwnames[] = {
8347 (char *) "pt", NULL
8348 };
8349
8350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8351 {
8352 arg1 = &temp1;
8353 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8354 }
8355 {
8356 PyThreadState* __tstate = wxPyBeginAllowThreads();
8357 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8358 wxPyEndAllowThreads(__tstate);
8359 if (PyErr_Occurred()) SWIG_fail;
8360 }
8361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8362 return resultobj;
8363 fail:
8364 return NULL;
8365 }
8366
8367
8368 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8369 PyObject *resultobj = 0;
8370 wxPoint *arg1 = 0 ;
8371 wxPoint2D *result = 0 ;
8372 wxPoint temp1 ;
8373 PyObject * obj0 = 0 ;
8374 char * kwnames[] = {
8375 (char *) "pt", NULL
8376 };
8377
8378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8379 {
8380 arg1 = &temp1;
8381 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8382 }
8383 {
8384 PyThreadState* __tstate = wxPyBeginAllowThreads();
8385 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8386 wxPyEndAllowThreads(__tstate);
8387 if (PyErr_Occurred()) SWIG_fail;
8388 }
8389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8390 return resultobj;
8391 fail:
8392 return NULL;
8393 }
8394
8395
8396 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8397 PyObject *resultobj = 0;
8398 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8399 void *argp1 = 0 ;
8400 int res1 = 0 ;
8401 PyObject *swig_obj[1] ;
8402
8403 if (!args) SWIG_fail;
8404 swig_obj[0] = args;
8405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8406 if (!SWIG_IsOK(res1)) {
8407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8408 }
8409 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8410 {
8411 PyThreadState* __tstate = wxPyBeginAllowThreads();
8412 delete arg1;
8413
8414 wxPyEndAllowThreads(__tstate);
8415 if (PyErr_Occurred()) SWIG_fail;
8416 }
8417 resultobj = SWIG_Py_Void();
8418 return resultobj;
8419 fail:
8420 return NULL;
8421 }
8422
8423
8424 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8425 PyObject *resultobj = 0;
8426 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8427 int *arg2 = (int *) 0 ;
8428 int *arg3 = (int *) 0 ;
8429 void *argp1 = 0 ;
8430 int res1 = 0 ;
8431 int temp2 ;
8432 int res2 = SWIG_TMPOBJ ;
8433 int temp3 ;
8434 int res3 = SWIG_TMPOBJ ;
8435 PyObject *swig_obj[1] ;
8436
8437 arg2 = &temp2;
8438 arg3 = &temp3;
8439 if (!args) SWIG_fail;
8440 swig_obj[0] = args;
8441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8442 if (!SWIG_IsOK(res1)) {
8443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8444 }
8445 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8446 {
8447 PyThreadState* __tstate = wxPyBeginAllowThreads();
8448 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8449 wxPyEndAllowThreads(__tstate);
8450 if (PyErr_Occurred()) SWIG_fail;
8451 }
8452 resultobj = SWIG_Py_Void();
8453 if (SWIG_IsTmpObj(res2)) {
8454 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8455 } else {
8456 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8457 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8458 }
8459 if (SWIG_IsTmpObj(res3)) {
8460 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8461 } else {
8462 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8463 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8464 }
8465 return resultobj;
8466 fail:
8467 return NULL;
8468 }
8469
8470
8471 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8472 PyObject *resultobj = 0;
8473 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8474 int *arg2 = (int *) 0 ;
8475 int *arg3 = (int *) 0 ;
8476 void *argp1 = 0 ;
8477 int res1 = 0 ;
8478 int temp2 ;
8479 int res2 = SWIG_TMPOBJ ;
8480 int temp3 ;
8481 int res3 = SWIG_TMPOBJ ;
8482 PyObject *swig_obj[1] ;
8483
8484 arg2 = &temp2;
8485 arg3 = &temp3;
8486 if (!args) SWIG_fail;
8487 swig_obj[0] = args;
8488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8489 if (!SWIG_IsOK(res1)) {
8490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8491 }
8492 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8493 {
8494 PyThreadState* __tstate = wxPyBeginAllowThreads();
8495 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8496 wxPyEndAllowThreads(__tstate);
8497 if (PyErr_Occurred()) SWIG_fail;
8498 }
8499 resultobj = SWIG_Py_Void();
8500 if (SWIG_IsTmpObj(res2)) {
8501 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8502 } else {
8503 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8504 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8505 }
8506 if (SWIG_IsTmpObj(res3)) {
8507 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8508 } else {
8509 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8510 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8511 }
8512 return resultobj;
8513 fail:
8514 return NULL;
8515 }
8516
8517
8518 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8519 PyObject *resultobj = 0;
8520 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8521 double result;
8522 void *argp1 = 0 ;
8523 int res1 = 0 ;
8524 PyObject *swig_obj[1] ;
8525
8526 if (!args) SWIG_fail;
8527 swig_obj[0] = args;
8528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8529 if (!SWIG_IsOK(res1)) {
8530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8531 }
8532 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8533 {
8534 PyThreadState* __tstate = wxPyBeginAllowThreads();
8535 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8536 wxPyEndAllowThreads(__tstate);
8537 if (PyErr_Occurred()) SWIG_fail;
8538 }
8539 resultobj = SWIG_From_double(static_cast< double >(result));
8540 return resultobj;
8541 fail:
8542 return NULL;
8543 }
8544
8545
8546 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8547 PyObject *resultobj = 0;
8548 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8549 double result;
8550 void *argp1 = 0 ;
8551 int res1 = 0 ;
8552 PyObject *swig_obj[1] ;
8553
8554 if (!args) SWIG_fail;
8555 swig_obj[0] = args;
8556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8557 if (!SWIG_IsOK(res1)) {
8558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8559 }
8560 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8561 {
8562 PyThreadState* __tstate = wxPyBeginAllowThreads();
8563 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8564 wxPyEndAllowThreads(__tstate);
8565 if (PyErr_Occurred()) SWIG_fail;
8566 }
8567 resultobj = SWIG_From_double(static_cast< double >(result));
8568 return resultobj;
8569 fail:
8570 return NULL;
8571 }
8572
8573
8574 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8575 PyObject *resultobj = 0;
8576 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8577 double arg2 ;
8578 void *argp1 = 0 ;
8579 int res1 = 0 ;
8580 double val2 ;
8581 int ecode2 = 0 ;
8582 PyObject * obj0 = 0 ;
8583 PyObject * obj1 = 0 ;
8584 char * kwnames[] = {
8585 (char *) "self",(char *) "length", NULL
8586 };
8587
8588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8590 if (!SWIG_IsOK(res1)) {
8591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8592 }
8593 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8594 ecode2 = SWIG_AsVal_double(obj1, &val2);
8595 if (!SWIG_IsOK(ecode2)) {
8596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8597 }
8598 arg2 = static_cast< double >(val2);
8599 {
8600 PyThreadState* __tstate = wxPyBeginAllowThreads();
8601 (arg1)->SetVectorLength(arg2);
8602 wxPyEndAllowThreads(__tstate);
8603 if (PyErr_Occurred()) SWIG_fail;
8604 }
8605 resultobj = SWIG_Py_Void();
8606 return resultobj;
8607 fail:
8608 return NULL;
8609 }
8610
8611
8612 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8613 PyObject *resultobj = 0;
8614 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8615 double arg2 ;
8616 void *argp1 = 0 ;
8617 int res1 = 0 ;
8618 double val2 ;
8619 int ecode2 = 0 ;
8620 PyObject * obj0 = 0 ;
8621 PyObject * obj1 = 0 ;
8622 char * kwnames[] = {
8623 (char *) "self",(char *) "degrees", NULL
8624 };
8625
8626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8628 if (!SWIG_IsOK(res1)) {
8629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8630 }
8631 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8632 ecode2 = SWIG_AsVal_double(obj1, &val2);
8633 if (!SWIG_IsOK(ecode2)) {
8634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8635 }
8636 arg2 = static_cast< double >(val2);
8637 {
8638 PyThreadState* __tstate = wxPyBeginAllowThreads();
8639 (arg1)->SetVectorAngle(arg2);
8640 wxPyEndAllowThreads(__tstate);
8641 if (PyErr_Occurred()) SWIG_fail;
8642 }
8643 resultobj = SWIG_Py_Void();
8644 return resultobj;
8645 fail:
8646 return NULL;
8647 }
8648
8649
8650 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8651 PyObject *resultobj = 0;
8652 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8653 wxPoint2D *arg2 = 0 ;
8654 double result;
8655 void *argp1 = 0 ;
8656 int res1 = 0 ;
8657 wxPoint2D temp2 ;
8658 PyObject * obj0 = 0 ;
8659 PyObject * obj1 = 0 ;
8660 char * kwnames[] = {
8661 (char *) "self",(char *) "pt", NULL
8662 };
8663
8664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8666 if (!SWIG_IsOK(res1)) {
8667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8668 }
8669 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8670 {
8671 arg2 = &temp2;
8672 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8673 }
8674 {
8675 PyThreadState* __tstate = wxPyBeginAllowThreads();
8676 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8677 wxPyEndAllowThreads(__tstate);
8678 if (PyErr_Occurred()) SWIG_fail;
8679 }
8680 resultobj = SWIG_From_double(static_cast< double >(result));
8681 return resultobj;
8682 fail:
8683 return NULL;
8684 }
8685
8686
8687 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8688 PyObject *resultobj = 0;
8689 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8690 wxPoint2D *arg2 = 0 ;
8691 double result;
8692 void *argp1 = 0 ;
8693 int res1 = 0 ;
8694 wxPoint2D temp2 ;
8695 PyObject * obj0 = 0 ;
8696 PyObject * obj1 = 0 ;
8697 char * kwnames[] = {
8698 (char *) "self",(char *) "pt", NULL
8699 };
8700
8701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8703 if (!SWIG_IsOK(res1)) {
8704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8705 }
8706 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8707 {
8708 arg2 = &temp2;
8709 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8710 }
8711 {
8712 PyThreadState* __tstate = wxPyBeginAllowThreads();
8713 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8714 wxPyEndAllowThreads(__tstate);
8715 if (PyErr_Occurred()) SWIG_fail;
8716 }
8717 resultobj = SWIG_From_double(static_cast< double >(result));
8718 return resultobj;
8719 fail:
8720 return NULL;
8721 }
8722
8723
8724 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8725 PyObject *resultobj = 0;
8726 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8727 wxPoint2D *arg2 = 0 ;
8728 double result;
8729 void *argp1 = 0 ;
8730 int res1 = 0 ;
8731 wxPoint2D temp2 ;
8732 PyObject * obj0 = 0 ;
8733 PyObject * obj1 = 0 ;
8734 char * kwnames[] = {
8735 (char *) "self",(char *) "vec", NULL
8736 };
8737
8738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8740 if (!SWIG_IsOK(res1)) {
8741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8742 }
8743 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8744 {
8745 arg2 = &temp2;
8746 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8747 }
8748 {
8749 PyThreadState* __tstate = wxPyBeginAllowThreads();
8750 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8751 wxPyEndAllowThreads(__tstate);
8752 if (PyErr_Occurred()) SWIG_fail;
8753 }
8754 resultobj = SWIG_From_double(static_cast< double >(result));
8755 return resultobj;
8756 fail:
8757 return NULL;
8758 }
8759
8760
8761 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8762 PyObject *resultobj = 0;
8763 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8764 wxPoint2D *arg2 = 0 ;
8765 double result;
8766 void *argp1 = 0 ;
8767 int res1 = 0 ;
8768 wxPoint2D temp2 ;
8769 PyObject * obj0 = 0 ;
8770 PyObject * obj1 = 0 ;
8771 char * kwnames[] = {
8772 (char *) "self",(char *) "vec", NULL
8773 };
8774
8775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8777 if (!SWIG_IsOK(res1)) {
8778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8779 }
8780 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8781 {
8782 arg2 = &temp2;
8783 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8784 }
8785 {
8786 PyThreadState* __tstate = wxPyBeginAllowThreads();
8787 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8788 wxPyEndAllowThreads(__tstate);
8789 if (PyErr_Occurred()) SWIG_fail;
8790 }
8791 resultobj = SWIG_From_double(static_cast< double >(result));
8792 return resultobj;
8793 fail:
8794 return NULL;
8795 }
8796
8797
8798 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8799 PyObject *resultobj = 0;
8800 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8801 wxPoint2D result;
8802 void *argp1 = 0 ;
8803 int res1 = 0 ;
8804 PyObject *swig_obj[1] ;
8805
8806 if (!args) SWIG_fail;
8807 swig_obj[0] = args;
8808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8809 if (!SWIG_IsOK(res1)) {
8810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8811 }
8812 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8813 {
8814 PyThreadState* __tstate = wxPyBeginAllowThreads();
8815 result = (arg1)->operator -();
8816 wxPyEndAllowThreads(__tstate);
8817 if (PyErr_Occurred()) SWIG_fail;
8818 }
8819 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8820 return resultobj;
8821 fail:
8822 return NULL;
8823 }
8824
8825
8826 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8827 PyObject *resultobj = 0;
8828 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8829 wxPoint2D *arg2 = 0 ;
8830 wxPoint2D *result = 0 ;
8831 void *argp1 = 0 ;
8832 int res1 = 0 ;
8833 wxPoint2D temp2 ;
8834 PyObject * obj0 = 0 ;
8835 PyObject * obj1 = 0 ;
8836 char * kwnames[] = {
8837 (char *) "self",(char *) "pt", NULL
8838 };
8839
8840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8842 if (!SWIG_IsOK(res1)) {
8843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8844 }
8845 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8846 {
8847 arg2 = &temp2;
8848 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8849 }
8850 {
8851 PyThreadState* __tstate = wxPyBeginAllowThreads();
8852 {
8853 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8854 result = (wxPoint2D *) &_result_ref;
8855 }
8856 wxPyEndAllowThreads(__tstate);
8857 if (PyErr_Occurred()) SWIG_fail;
8858 }
8859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8860 return resultobj;
8861 fail:
8862 return NULL;
8863 }
8864
8865
8866 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8867 PyObject *resultobj = 0;
8868 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8869 wxPoint2D *arg2 = 0 ;
8870 wxPoint2D *result = 0 ;
8871 void *argp1 = 0 ;
8872 int res1 = 0 ;
8873 wxPoint2D temp2 ;
8874 PyObject * obj0 = 0 ;
8875 PyObject * obj1 = 0 ;
8876 char * kwnames[] = {
8877 (char *) "self",(char *) "pt", NULL
8878 };
8879
8880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8882 if (!SWIG_IsOK(res1)) {
8883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8884 }
8885 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8886 {
8887 arg2 = &temp2;
8888 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8889 }
8890 {
8891 PyThreadState* __tstate = wxPyBeginAllowThreads();
8892 {
8893 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8894 result = (wxPoint2D *) &_result_ref;
8895 }
8896 wxPyEndAllowThreads(__tstate);
8897 if (PyErr_Occurred()) SWIG_fail;
8898 }
8899 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8900 return resultobj;
8901 fail:
8902 return NULL;
8903 }
8904
8905
8906 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj = 0;
8908 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8909 wxPoint2D *arg2 = 0 ;
8910 wxPoint2D *result = 0 ;
8911 void *argp1 = 0 ;
8912 int res1 = 0 ;
8913 wxPoint2D temp2 ;
8914 PyObject * obj0 = 0 ;
8915 PyObject * obj1 = 0 ;
8916 char * kwnames[] = {
8917 (char *) "self",(char *) "pt", NULL
8918 };
8919
8920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8922 if (!SWIG_IsOK(res1)) {
8923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8924 }
8925 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8926 {
8927 arg2 = &temp2;
8928 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8929 }
8930 {
8931 PyThreadState* __tstate = wxPyBeginAllowThreads();
8932 {
8933 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8934 result = (wxPoint2D *) &_result_ref;
8935 }
8936 wxPyEndAllowThreads(__tstate);
8937 if (PyErr_Occurred()) SWIG_fail;
8938 }
8939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8940 return resultobj;
8941 fail:
8942 return NULL;
8943 }
8944
8945
8946 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8947 PyObject *resultobj = 0;
8948 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8949 wxPoint2D *arg2 = 0 ;
8950 wxPoint2D *result = 0 ;
8951 void *argp1 = 0 ;
8952 int res1 = 0 ;
8953 wxPoint2D temp2 ;
8954 PyObject * obj0 = 0 ;
8955 PyObject * obj1 = 0 ;
8956 char * kwnames[] = {
8957 (char *) "self",(char *) "pt", NULL
8958 };
8959
8960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8962 if (!SWIG_IsOK(res1)) {
8963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8964 }
8965 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8966 {
8967 arg2 = &temp2;
8968 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8969 }
8970 {
8971 PyThreadState* __tstate = wxPyBeginAllowThreads();
8972 {
8973 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8974 result = (wxPoint2D *) &_result_ref;
8975 }
8976 wxPyEndAllowThreads(__tstate);
8977 if (PyErr_Occurred()) SWIG_fail;
8978 }
8979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8980 return resultobj;
8981 fail:
8982 return NULL;
8983 }
8984
8985
8986 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8987 PyObject *resultobj = 0;
8988 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8989 PyObject *arg2 = (PyObject *) 0 ;
8990 bool result;
8991 void *argp1 = 0 ;
8992 int res1 = 0 ;
8993 PyObject * obj0 = 0 ;
8994 PyObject * obj1 = 0 ;
8995 char * kwnames[] = {
8996 (char *) "self",(char *) "other", NULL
8997 };
8998
8999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
9000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9001 if (!SWIG_IsOK(res1)) {
9002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9003 }
9004 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9005 arg2 = obj1;
9006 {
9007 result = (bool)wxPoint2D___eq__(arg1,arg2);
9008 if (PyErr_Occurred()) SWIG_fail;
9009 }
9010 {
9011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9012 }
9013 return resultobj;
9014 fail:
9015 return NULL;
9016 }
9017
9018
9019 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9020 PyObject *resultobj = 0;
9021 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9022 PyObject *arg2 = (PyObject *) 0 ;
9023 bool result;
9024 void *argp1 = 0 ;
9025 int res1 = 0 ;
9026 PyObject * obj0 = 0 ;
9027 PyObject * obj1 = 0 ;
9028 char * kwnames[] = {
9029 (char *) "self",(char *) "other", NULL
9030 };
9031
9032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
9033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9034 if (!SWIG_IsOK(res1)) {
9035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9036 }
9037 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9038 arg2 = obj1;
9039 {
9040 result = (bool)wxPoint2D___ne__(arg1,arg2);
9041 if (PyErr_Occurred()) SWIG_fail;
9042 }
9043 {
9044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9045 }
9046 return resultobj;
9047 fail:
9048 return NULL;
9049 }
9050
9051
9052 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9053 PyObject *resultobj = 0;
9054 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9055 double arg2 ;
9056 void *argp1 = 0 ;
9057 int res1 = 0 ;
9058 double val2 ;
9059 int ecode2 = 0 ;
9060 PyObject *swig_obj[2] ;
9061
9062 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
9063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9064 if (!SWIG_IsOK(res1)) {
9065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9066 }
9067 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9068 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9069 if (!SWIG_IsOK(ecode2)) {
9070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
9071 }
9072 arg2 = static_cast< double >(val2);
9073 if (arg1) (arg1)->m_x = arg2;
9074
9075 resultobj = SWIG_Py_Void();
9076 return resultobj;
9077 fail:
9078 return NULL;
9079 }
9080
9081
9082 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9083 PyObject *resultobj = 0;
9084 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9085 double result;
9086 void *argp1 = 0 ;
9087 int res1 = 0 ;
9088 PyObject *swig_obj[1] ;
9089
9090 if (!args) SWIG_fail;
9091 swig_obj[0] = args;
9092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9093 if (!SWIG_IsOK(res1)) {
9094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9095 }
9096 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9097 result = (double) ((arg1)->m_x);
9098 resultobj = SWIG_From_double(static_cast< double >(result));
9099 return resultobj;
9100 fail:
9101 return NULL;
9102 }
9103
9104
9105 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9106 PyObject *resultobj = 0;
9107 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9108 double arg2 ;
9109 void *argp1 = 0 ;
9110 int res1 = 0 ;
9111 double val2 ;
9112 int ecode2 = 0 ;
9113 PyObject *swig_obj[2] ;
9114
9115 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9117 if (!SWIG_IsOK(res1)) {
9118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9119 }
9120 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9121 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9122 if (!SWIG_IsOK(ecode2)) {
9123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9124 }
9125 arg2 = static_cast< double >(val2);
9126 if (arg1) (arg1)->m_y = arg2;
9127
9128 resultobj = SWIG_Py_Void();
9129 return resultobj;
9130 fail:
9131 return NULL;
9132 }
9133
9134
9135 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9136 PyObject *resultobj = 0;
9137 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9138 double result;
9139 void *argp1 = 0 ;
9140 int res1 = 0 ;
9141 PyObject *swig_obj[1] ;
9142
9143 if (!args) SWIG_fail;
9144 swig_obj[0] = args;
9145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9146 if (!SWIG_IsOK(res1)) {
9147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9148 }
9149 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9150 result = (double) ((arg1)->m_y);
9151 resultobj = SWIG_From_double(static_cast< double >(result));
9152 return resultobj;
9153 fail:
9154 return NULL;
9155 }
9156
9157
9158 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9159 PyObject *resultobj = 0;
9160 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9161 double arg2 = (double) 0 ;
9162 double arg3 = (double) 0 ;
9163 void *argp1 = 0 ;
9164 int res1 = 0 ;
9165 double val2 ;
9166 int ecode2 = 0 ;
9167 double val3 ;
9168 int ecode3 = 0 ;
9169 PyObject * obj0 = 0 ;
9170 PyObject * obj1 = 0 ;
9171 PyObject * obj2 = 0 ;
9172 char * kwnames[] = {
9173 (char *) "self",(char *) "x",(char *) "y", NULL
9174 };
9175
9176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9178 if (!SWIG_IsOK(res1)) {
9179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9180 }
9181 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9182 if (obj1) {
9183 ecode2 = SWIG_AsVal_double(obj1, &val2);
9184 if (!SWIG_IsOK(ecode2)) {
9185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9186 }
9187 arg2 = static_cast< double >(val2);
9188 }
9189 if (obj2) {
9190 ecode3 = SWIG_AsVal_double(obj2, &val3);
9191 if (!SWIG_IsOK(ecode3)) {
9192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9193 }
9194 arg3 = static_cast< double >(val3);
9195 }
9196 {
9197 PyThreadState* __tstate = wxPyBeginAllowThreads();
9198 wxPoint2D_Set(arg1,arg2,arg3);
9199 wxPyEndAllowThreads(__tstate);
9200 if (PyErr_Occurred()) SWIG_fail;
9201 }
9202 resultobj = SWIG_Py_Void();
9203 return resultobj;
9204 fail:
9205 return NULL;
9206 }
9207
9208
9209 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9210 PyObject *resultobj = 0;
9211 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9212 PyObject *result = 0 ;
9213 void *argp1 = 0 ;
9214 int res1 = 0 ;
9215 PyObject *swig_obj[1] ;
9216
9217 if (!args) SWIG_fail;
9218 swig_obj[0] = args;
9219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9220 if (!SWIG_IsOK(res1)) {
9221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9222 }
9223 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9224 {
9225 PyThreadState* __tstate = wxPyBeginAllowThreads();
9226 result = (PyObject *)wxPoint2D_Get(arg1);
9227 wxPyEndAllowThreads(__tstate);
9228 if (PyErr_Occurred()) SWIG_fail;
9229 }
9230 resultobj = result;
9231 return resultobj;
9232 fail:
9233 return NULL;
9234 }
9235
9236
9237 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9238 PyObject *obj;
9239 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9240 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9241 return SWIG_Py_Void();
9242 }
9243
9244 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9245 return SWIG_Python_InitShadowInstance(args);
9246 }
9247
9248 SWIGINTERN int DefaultPosition_set(PyObject *) {
9249 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
9250 return 1;
9251 }
9252
9253
9254 SWIGINTERN PyObject *DefaultPosition_get(void) {
9255 PyObject *pyobj = 0;
9256
9257 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9258 return pyobj;
9259 }
9260
9261
9262 SWIGINTERN int DefaultSize_set(PyObject *) {
9263 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9264 return 1;
9265 }
9266
9267
9268 SWIGINTERN PyObject *DefaultSize_get(void) {
9269 PyObject *pyobj = 0;
9270
9271 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9272 return pyobj;
9273 }
9274
9275
9276 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9277 PyObject *resultobj = 0;
9278 PyObject *arg1 = (PyObject *) 0 ;
9279 wxPyInputStream *result = 0 ;
9280 PyObject * obj0 = 0 ;
9281 char * kwnames[] = {
9282 (char *) "p", NULL
9283 };
9284
9285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9286 arg1 = obj0;
9287 {
9288 PyThreadState* __tstate = wxPyBeginAllowThreads();
9289 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9290 wxPyEndAllowThreads(__tstate);
9291 if (PyErr_Occurred()) SWIG_fail;
9292 }
9293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9294 return resultobj;
9295 fail:
9296 return NULL;
9297 }
9298
9299
9300 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9301 PyObject *resultobj = 0;
9302 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9303 void *argp1 = 0 ;
9304 int res1 = 0 ;
9305 PyObject *swig_obj[1] ;
9306
9307 if (!args) SWIG_fail;
9308 swig_obj[0] = args;
9309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9310 if (!SWIG_IsOK(res1)) {
9311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9312 }
9313 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9314 {
9315 PyThreadState* __tstate = wxPyBeginAllowThreads();
9316 delete arg1;
9317
9318 wxPyEndAllowThreads(__tstate);
9319 if (PyErr_Occurred()) SWIG_fail;
9320 }
9321 resultobj = SWIG_Py_Void();
9322 return resultobj;
9323 fail:
9324 return NULL;
9325 }
9326
9327
9328 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9329 PyObject *resultobj = 0;
9330 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9331 void *argp1 = 0 ;
9332 int res1 = 0 ;
9333 PyObject *swig_obj[1] ;
9334
9335 if (!args) SWIG_fail;
9336 swig_obj[0] = args;
9337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9338 if (!SWIG_IsOK(res1)) {
9339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9340 }
9341 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9342 {
9343 PyThreadState* __tstate = wxPyBeginAllowThreads();
9344 (arg1)->close();
9345 wxPyEndAllowThreads(__tstate);
9346 if (PyErr_Occurred()) SWIG_fail;
9347 }
9348 resultobj = SWIG_Py_Void();
9349 return resultobj;
9350 fail:
9351 return NULL;
9352 }
9353
9354
9355 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9356 PyObject *resultobj = 0;
9357 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9358 void *argp1 = 0 ;
9359 int res1 = 0 ;
9360 PyObject *swig_obj[1] ;
9361
9362 if (!args) SWIG_fail;
9363 swig_obj[0] = args;
9364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9365 if (!SWIG_IsOK(res1)) {
9366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9367 }
9368 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9369 {
9370 PyThreadState* __tstate = wxPyBeginAllowThreads();
9371 (arg1)->flush();
9372 wxPyEndAllowThreads(__tstate);
9373 if (PyErr_Occurred()) SWIG_fail;
9374 }
9375 resultobj = SWIG_Py_Void();
9376 return resultobj;
9377 fail:
9378 return NULL;
9379 }
9380
9381
9382 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9383 PyObject *resultobj = 0;
9384 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9385 bool result;
9386 void *argp1 = 0 ;
9387 int res1 = 0 ;
9388 PyObject *swig_obj[1] ;
9389
9390 if (!args) SWIG_fail;
9391 swig_obj[0] = args;
9392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9393 if (!SWIG_IsOK(res1)) {
9394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9395 }
9396 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9397 {
9398 PyThreadState* __tstate = wxPyBeginAllowThreads();
9399 result = (bool)(arg1)->eof();
9400 wxPyEndAllowThreads(__tstate);
9401 if (PyErr_Occurred()) SWIG_fail;
9402 }
9403 {
9404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9405 }
9406 return resultobj;
9407 fail:
9408 return NULL;
9409 }
9410
9411
9412 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9413 PyObject *resultobj = 0;
9414 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9415 int arg2 = (int) -1 ;
9416 PyObject *result = 0 ;
9417 void *argp1 = 0 ;
9418 int res1 = 0 ;
9419 int val2 ;
9420 int ecode2 = 0 ;
9421 PyObject * obj0 = 0 ;
9422 PyObject * obj1 = 0 ;
9423 char * kwnames[] = {
9424 (char *) "self",(char *) "size", NULL
9425 };
9426
9427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9429 if (!SWIG_IsOK(res1)) {
9430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9431 }
9432 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9433 if (obj1) {
9434 ecode2 = SWIG_AsVal_int(obj1, &val2);
9435 if (!SWIG_IsOK(ecode2)) {
9436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9437 }
9438 arg2 = static_cast< int >(val2);
9439 }
9440 {
9441 PyThreadState* __tstate = wxPyBeginAllowThreads();
9442 result = (PyObject *)(arg1)->read(arg2);
9443 wxPyEndAllowThreads(__tstate);
9444 if (PyErr_Occurred()) SWIG_fail;
9445 }
9446 resultobj = result;
9447 return resultobj;
9448 fail:
9449 return NULL;
9450 }
9451
9452
9453 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9454 PyObject *resultobj = 0;
9455 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9456 int arg2 = (int) -1 ;
9457 PyObject *result = 0 ;
9458 void *argp1 = 0 ;
9459 int res1 = 0 ;
9460 int val2 ;
9461 int ecode2 = 0 ;
9462 PyObject * obj0 = 0 ;
9463 PyObject * obj1 = 0 ;
9464 char * kwnames[] = {
9465 (char *) "self",(char *) "size", NULL
9466 };
9467
9468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9470 if (!SWIG_IsOK(res1)) {
9471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9472 }
9473 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9474 if (obj1) {
9475 ecode2 = SWIG_AsVal_int(obj1, &val2);
9476 if (!SWIG_IsOK(ecode2)) {
9477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9478 }
9479 arg2 = static_cast< int >(val2);
9480 }
9481 {
9482 PyThreadState* __tstate = wxPyBeginAllowThreads();
9483 result = (PyObject *)(arg1)->readline(arg2);
9484 wxPyEndAllowThreads(__tstate);
9485 if (PyErr_Occurred()) SWIG_fail;
9486 }
9487 resultobj = result;
9488 return resultobj;
9489 fail:
9490 return NULL;
9491 }
9492
9493
9494 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9495 PyObject *resultobj = 0;
9496 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9497 int arg2 = (int) -1 ;
9498 PyObject *result = 0 ;
9499 void *argp1 = 0 ;
9500 int res1 = 0 ;
9501 int val2 ;
9502 int ecode2 = 0 ;
9503 PyObject * obj0 = 0 ;
9504 PyObject * obj1 = 0 ;
9505 char * kwnames[] = {
9506 (char *) "self",(char *) "sizehint", NULL
9507 };
9508
9509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9511 if (!SWIG_IsOK(res1)) {
9512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9513 }
9514 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9515 if (obj1) {
9516 ecode2 = SWIG_AsVal_int(obj1, &val2);
9517 if (!SWIG_IsOK(ecode2)) {
9518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9519 }
9520 arg2 = static_cast< int >(val2);
9521 }
9522 {
9523 PyThreadState* __tstate = wxPyBeginAllowThreads();
9524 result = (PyObject *)(arg1)->readlines(arg2);
9525 wxPyEndAllowThreads(__tstate);
9526 if (PyErr_Occurred()) SWIG_fail;
9527 }
9528 resultobj = result;
9529 return resultobj;
9530 fail:
9531 return NULL;
9532 }
9533
9534
9535 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9536 PyObject *resultobj = 0;
9537 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9538 int arg2 ;
9539 int arg3 = (int) 0 ;
9540 void *argp1 = 0 ;
9541 int res1 = 0 ;
9542 int val2 ;
9543 int ecode2 = 0 ;
9544 int val3 ;
9545 int ecode3 = 0 ;
9546 PyObject * obj0 = 0 ;
9547 PyObject * obj1 = 0 ;
9548 PyObject * obj2 = 0 ;
9549 char * kwnames[] = {
9550 (char *) "self",(char *) "offset",(char *) "whence", NULL
9551 };
9552
9553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9555 if (!SWIG_IsOK(res1)) {
9556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9557 }
9558 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9559 ecode2 = SWIG_AsVal_int(obj1, &val2);
9560 if (!SWIG_IsOK(ecode2)) {
9561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9562 }
9563 arg2 = static_cast< int >(val2);
9564 if (obj2) {
9565 ecode3 = SWIG_AsVal_int(obj2, &val3);
9566 if (!SWIG_IsOK(ecode3)) {
9567 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9568 }
9569 arg3 = static_cast< int >(val3);
9570 }
9571 {
9572 PyThreadState* __tstate = wxPyBeginAllowThreads();
9573 (arg1)->seek(arg2,arg3);
9574 wxPyEndAllowThreads(__tstate);
9575 if (PyErr_Occurred()) SWIG_fail;
9576 }
9577 resultobj = SWIG_Py_Void();
9578 return resultobj;
9579 fail:
9580 return NULL;
9581 }
9582
9583
9584 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9585 PyObject *resultobj = 0;
9586 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9587 int result;
9588 void *argp1 = 0 ;
9589 int res1 = 0 ;
9590 PyObject *swig_obj[1] ;
9591
9592 if (!args) SWIG_fail;
9593 swig_obj[0] = args;
9594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9595 if (!SWIG_IsOK(res1)) {
9596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9597 }
9598 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9599 {
9600 PyThreadState* __tstate = wxPyBeginAllowThreads();
9601 result = (int)(arg1)->tell();
9602 wxPyEndAllowThreads(__tstate);
9603 if (PyErr_Occurred()) SWIG_fail;
9604 }
9605 resultobj = SWIG_From_int(static_cast< int >(result));
9606 return resultobj;
9607 fail:
9608 return NULL;
9609 }
9610
9611
9612 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9613 PyObject *resultobj = 0;
9614 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9615 char result;
9616 void *argp1 = 0 ;
9617 int res1 = 0 ;
9618 PyObject *swig_obj[1] ;
9619
9620 if (!args) SWIG_fail;
9621 swig_obj[0] = args;
9622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9623 if (!SWIG_IsOK(res1)) {
9624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9625 }
9626 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9627 {
9628 PyThreadState* __tstate = wxPyBeginAllowThreads();
9629 result = (char)(arg1)->Peek();
9630 wxPyEndAllowThreads(__tstate);
9631 if (PyErr_Occurred()) SWIG_fail;
9632 }
9633 resultobj = SWIG_From_char(static_cast< char >(result));
9634 return resultobj;
9635 fail:
9636 return NULL;
9637 }
9638
9639
9640 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9641 PyObject *resultobj = 0;
9642 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9643 char result;
9644 void *argp1 = 0 ;
9645 int res1 = 0 ;
9646 PyObject *swig_obj[1] ;
9647
9648 if (!args) SWIG_fail;
9649 swig_obj[0] = args;
9650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9651 if (!SWIG_IsOK(res1)) {
9652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9653 }
9654 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9655 {
9656 PyThreadState* __tstate = wxPyBeginAllowThreads();
9657 result = (char)(arg1)->GetC();
9658 wxPyEndAllowThreads(__tstate);
9659 if (PyErr_Occurred()) SWIG_fail;
9660 }
9661 resultobj = SWIG_From_char(static_cast< char >(result));
9662 return resultobj;
9663 fail:
9664 return NULL;
9665 }
9666
9667
9668 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9669 PyObject *resultobj = 0;
9670 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9671 size_t result;
9672 void *argp1 = 0 ;
9673 int res1 = 0 ;
9674 PyObject *swig_obj[1] ;
9675
9676 if (!args) SWIG_fail;
9677 swig_obj[0] = args;
9678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9679 if (!SWIG_IsOK(res1)) {
9680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9681 }
9682 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9683 {
9684 PyThreadState* __tstate = wxPyBeginAllowThreads();
9685 result = (size_t)(arg1)->LastRead();
9686 wxPyEndAllowThreads(__tstate);
9687 if (PyErr_Occurred()) SWIG_fail;
9688 }
9689 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9690 return resultobj;
9691 fail:
9692 return NULL;
9693 }
9694
9695
9696 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9697 PyObject *resultobj = 0;
9698 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9699 bool result;
9700 void *argp1 = 0 ;
9701 int res1 = 0 ;
9702 PyObject *swig_obj[1] ;
9703
9704 if (!args) SWIG_fail;
9705 swig_obj[0] = args;
9706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9707 if (!SWIG_IsOK(res1)) {
9708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9709 }
9710 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9711 {
9712 PyThreadState* __tstate = wxPyBeginAllowThreads();
9713 result = (bool)(arg1)->CanRead();
9714 wxPyEndAllowThreads(__tstate);
9715 if (PyErr_Occurred()) SWIG_fail;
9716 }
9717 {
9718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9719 }
9720 return resultobj;
9721 fail:
9722 return NULL;
9723 }
9724
9725
9726 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9727 PyObject *resultobj = 0;
9728 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9729 bool result;
9730 void *argp1 = 0 ;
9731 int res1 = 0 ;
9732 PyObject *swig_obj[1] ;
9733
9734 if (!args) SWIG_fail;
9735 swig_obj[0] = args;
9736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9737 if (!SWIG_IsOK(res1)) {
9738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9739 }
9740 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9741 {
9742 PyThreadState* __tstate = wxPyBeginAllowThreads();
9743 result = (bool)(arg1)->Eof();
9744 wxPyEndAllowThreads(__tstate);
9745 if (PyErr_Occurred()) SWIG_fail;
9746 }
9747 {
9748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9749 }
9750 return resultobj;
9751 fail:
9752 return NULL;
9753 }
9754
9755
9756 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9757 PyObject *resultobj = 0;
9758 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9759 char arg2 ;
9760 bool result;
9761 void *argp1 = 0 ;
9762 int res1 = 0 ;
9763 char val2 ;
9764 int ecode2 = 0 ;
9765 PyObject * obj0 = 0 ;
9766 PyObject * obj1 = 0 ;
9767 char * kwnames[] = {
9768 (char *) "self",(char *) "c", NULL
9769 };
9770
9771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9773 if (!SWIG_IsOK(res1)) {
9774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9775 }
9776 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9777 ecode2 = SWIG_AsVal_char(obj1, &val2);
9778 if (!SWIG_IsOK(ecode2)) {
9779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9780 }
9781 arg2 = static_cast< char >(val2);
9782 {
9783 PyThreadState* __tstate = wxPyBeginAllowThreads();
9784 result = (bool)(arg1)->Ungetch(arg2);
9785 wxPyEndAllowThreads(__tstate);
9786 if (PyErr_Occurred()) SWIG_fail;
9787 }
9788 {
9789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9790 }
9791 return resultobj;
9792 fail:
9793 return NULL;
9794 }
9795
9796
9797 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9798 PyObject *resultobj = 0;
9799 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9800 long arg2 ;
9801 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9802 long result;
9803 void *argp1 = 0 ;
9804 int res1 = 0 ;
9805 long val2 ;
9806 int ecode2 = 0 ;
9807 int val3 ;
9808 int ecode3 = 0 ;
9809 PyObject * obj0 = 0 ;
9810 PyObject * obj1 = 0 ;
9811 PyObject * obj2 = 0 ;
9812 char * kwnames[] = {
9813 (char *) "self",(char *) "pos",(char *) "mode", NULL
9814 };
9815
9816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9818 if (!SWIG_IsOK(res1)) {
9819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9820 }
9821 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9822 ecode2 = SWIG_AsVal_long(obj1, &val2);
9823 if (!SWIG_IsOK(ecode2)) {
9824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9825 }
9826 arg2 = static_cast< long >(val2);
9827 if (obj2) {
9828 ecode3 = SWIG_AsVal_int(obj2, &val3);
9829 if (!SWIG_IsOK(ecode3)) {
9830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9831 }
9832 arg3 = static_cast< wxSeekMode >(val3);
9833 }
9834 {
9835 PyThreadState* __tstate = wxPyBeginAllowThreads();
9836 result = (long)(arg1)->SeekI(arg2,arg3);
9837 wxPyEndAllowThreads(__tstate);
9838 if (PyErr_Occurred()) SWIG_fail;
9839 }
9840 resultobj = SWIG_From_long(static_cast< long >(result));
9841 return resultobj;
9842 fail:
9843 return NULL;
9844 }
9845
9846
9847 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9848 PyObject *resultobj = 0;
9849 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9850 long result;
9851 void *argp1 = 0 ;
9852 int res1 = 0 ;
9853 PyObject *swig_obj[1] ;
9854
9855 if (!args) SWIG_fail;
9856 swig_obj[0] = args;
9857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9858 if (!SWIG_IsOK(res1)) {
9859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9860 }
9861 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9862 {
9863 PyThreadState* __tstate = wxPyBeginAllowThreads();
9864 result = (long)(arg1)->TellI();
9865 wxPyEndAllowThreads(__tstate);
9866 if (PyErr_Occurred()) SWIG_fail;
9867 }
9868 resultobj = SWIG_From_long(static_cast< long >(result));
9869 return resultobj;
9870 fail:
9871 return NULL;
9872 }
9873
9874
9875 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9876 PyObject *obj;
9877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9878 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9879 return SWIG_Py_Void();
9880 }
9881
9882 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9883 return SWIG_Python_InitShadowInstance(args);
9884 }
9885
9886 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9887 PyObject *resultobj = 0;
9888 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9889 PyObject *arg2 = (PyObject *) 0 ;
9890 void *argp1 = 0 ;
9891 int res1 = 0 ;
9892 PyObject * obj0 = 0 ;
9893 PyObject * obj1 = 0 ;
9894 char * kwnames[] = {
9895 (char *) "self",(char *) "obj", NULL
9896 };
9897
9898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9900 if (!SWIG_IsOK(res1)) {
9901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9902 }
9903 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9904 arg2 = obj1;
9905 {
9906 PyThreadState* __tstate = wxPyBeginAllowThreads();
9907 wxOutputStream_write(arg1,arg2);
9908 wxPyEndAllowThreads(__tstate);
9909 if (PyErr_Occurred()) SWIG_fail;
9910 }
9911 resultobj = SWIG_Py_Void();
9912 return resultobj;
9913 fail:
9914 return NULL;
9915 }
9916
9917
9918 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9919 PyObject *resultobj = 0;
9920 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9921 size_t result;
9922 void *argp1 = 0 ;
9923 int res1 = 0 ;
9924 PyObject *swig_obj[1] ;
9925
9926 if (!args) SWIG_fail;
9927 swig_obj[0] = args;
9928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9929 if (!SWIG_IsOK(res1)) {
9930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9931 }
9932 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9933 {
9934 PyThreadState* __tstate = wxPyBeginAllowThreads();
9935 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9936 wxPyEndAllowThreads(__tstate);
9937 if (PyErr_Occurred()) SWIG_fail;
9938 }
9939 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9940 return resultobj;
9941 fail:
9942 return NULL;
9943 }
9944
9945
9946 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9947 PyObject *obj;
9948 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9949 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9950 return SWIG_Py_Void();
9951 }
9952
9953 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9954 PyObject *resultobj = 0;
9955 wxInputStream *arg1 = (wxInputStream *) 0 ;
9956 wxString *arg2 = 0 ;
9957 wxString *arg3 = 0 ;
9958 wxString *arg4 = 0 ;
9959 wxDateTime arg5 ;
9960 wxFSFile *result = 0 ;
9961 wxPyInputStream *temp1 ;
9962 bool temp2 = false ;
9963 bool temp3 = false ;
9964 bool temp4 = false ;
9965 void *argp5 ;
9966 int res5 = 0 ;
9967 PyObject * obj0 = 0 ;
9968 PyObject * obj1 = 0 ;
9969 PyObject * obj2 = 0 ;
9970 PyObject * obj3 = 0 ;
9971 PyObject * obj4 = 0 ;
9972 char * kwnames[] = {
9973 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9974 };
9975
9976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9977 {
9978 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9979 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9980 } else {
9981 PyErr_Clear(); // clear the failure of the wxPyConvert above
9982 arg1 = wxPyCBInputStream_create(obj0, true);
9983 if (arg1 == NULL) {
9984 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9985 SWIG_fail;
9986 }
9987 }
9988 }
9989 {
9990 arg2 = wxString_in_helper(obj1);
9991 if (arg2 == NULL) SWIG_fail;
9992 temp2 = true;
9993 }
9994 {
9995 arg3 = wxString_in_helper(obj2);
9996 if (arg3 == NULL) SWIG_fail;
9997 temp3 = true;
9998 }
9999 {
10000 arg4 = wxString_in_helper(obj3);
10001 if (arg4 == NULL) SWIG_fail;
10002 temp4 = true;
10003 }
10004 {
10005 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
10006 if (!SWIG_IsOK(res5)) {
10007 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
10008 }
10009 if (!argp5) {
10010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
10011 } else {
10012 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
10013 arg5 = *temp;
10014 if (SWIG_IsNewObj(res5)) delete temp;
10015 }
10016 }
10017 {
10018 PyThreadState* __tstate = wxPyBeginAllowThreads();
10019 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
10020 wxPyEndAllowThreads(__tstate);
10021 if (PyErr_Occurred()) SWIG_fail;
10022 }
10023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
10024 {
10025 if (temp2)
10026 delete arg2;
10027 }
10028 {
10029 if (temp3)
10030 delete arg3;
10031 }
10032 {
10033 if (temp4)
10034 delete arg4;
10035 }
10036 return resultobj;
10037 fail:
10038 {
10039 if (temp2)
10040 delete arg2;
10041 }
10042 {
10043 if (temp3)
10044 delete arg3;
10045 }
10046 {
10047 if (temp4)
10048 delete arg4;
10049 }
10050 return NULL;
10051 }
10052
10053
10054 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10055 PyObject *resultobj = 0;
10056 wxFSFile *arg1 = (wxFSFile *) 0 ;
10057 void *argp1 = 0 ;
10058 int res1 = 0 ;
10059 PyObject *swig_obj[1] ;
10060
10061 if (!args) SWIG_fail;
10062 swig_obj[0] = args;
10063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
10064 if (!SWIG_IsOK(res1)) {
10065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
10066 }
10067 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10068 {
10069 PyThreadState* __tstate = wxPyBeginAllowThreads();
10070 delete arg1;
10071
10072 wxPyEndAllowThreads(__tstate);
10073 if (PyErr_Occurred()) SWIG_fail;
10074 }
10075 resultobj = SWIG_Py_Void();
10076 return resultobj;
10077 fail:
10078 return NULL;
10079 }
10080
10081
10082 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10083 PyObject *resultobj = 0;
10084 wxFSFile *arg1 = (wxFSFile *) 0 ;
10085 wxInputStream *result = 0 ;
10086 void *argp1 = 0 ;
10087 int res1 = 0 ;
10088 PyObject *swig_obj[1] ;
10089
10090 if (!args) SWIG_fail;
10091 swig_obj[0] = args;
10092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10093 if (!SWIG_IsOK(res1)) {
10094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10095 }
10096 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10097 {
10098 PyThreadState* __tstate = wxPyBeginAllowThreads();
10099 result = (wxInputStream *)(arg1)->GetStream();
10100 wxPyEndAllowThreads(__tstate);
10101 if (PyErr_Occurred()) SWIG_fail;
10102 }
10103 {
10104 wxPyInputStream * _ptr = NULL;
10105
10106 if (result) {
10107 _ptr = new wxPyInputStream(result);
10108 }
10109 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10110 }
10111 return resultobj;
10112 fail:
10113 return NULL;
10114 }
10115
10116
10117 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10118 PyObject *resultobj = 0;
10119 wxFSFile *arg1 = (wxFSFile *) 0 ;
10120 void *argp1 = 0 ;
10121 int res1 = 0 ;
10122 PyObject *swig_obj[1] ;
10123
10124 if (!args) SWIG_fail;
10125 swig_obj[0] = args;
10126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10127 if (!SWIG_IsOK(res1)) {
10128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10129 }
10130 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10131 {
10132 PyThreadState* __tstate = wxPyBeginAllowThreads();
10133 (arg1)->DetachStream();
10134 wxPyEndAllowThreads(__tstate);
10135 if (PyErr_Occurred()) SWIG_fail;
10136 }
10137 resultobj = SWIG_Py_Void();
10138 return resultobj;
10139 fail:
10140 return NULL;
10141 }
10142
10143
10144 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10145 PyObject *resultobj = 0;
10146 wxFSFile *arg1 = (wxFSFile *) 0 ;
10147 wxString *result = 0 ;
10148 void *argp1 = 0 ;
10149 int res1 = 0 ;
10150 PyObject *swig_obj[1] ;
10151
10152 if (!args) SWIG_fail;
10153 swig_obj[0] = args;
10154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10155 if (!SWIG_IsOK(res1)) {
10156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
10157 }
10158 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10159 {
10160 PyThreadState* __tstate = wxPyBeginAllowThreads();
10161 {
10162 wxString const &_result_ref = (arg1)->GetMimeType();
10163 result = (wxString *) &_result_ref;
10164 }
10165 wxPyEndAllowThreads(__tstate);
10166 if (PyErr_Occurred()) SWIG_fail;
10167 }
10168 {
10169 #if wxUSE_UNICODE
10170 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10171 #else
10172 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10173 #endif
10174 }
10175 return resultobj;
10176 fail:
10177 return NULL;
10178 }
10179
10180
10181 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10182 PyObject *resultobj = 0;
10183 wxFSFile *arg1 = (wxFSFile *) 0 ;
10184 wxString *result = 0 ;
10185 void *argp1 = 0 ;
10186 int res1 = 0 ;
10187 PyObject *swig_obj[1] ;
10188
10189 if (!args) SWIG_fail;
10190 swig_obj[0] = args;
10191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10192 if (!SWIG_IsOK(res1)) {
10193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
10194 }
10195 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10196 {
10197 PyThreadState* __tstate = wxPyBeginAllowThreads();
10198 {
10199 wxString const &_result_ref = (arg1)->GetLocation();
10200 result = (wxString *) &_result_ref;
10201 }
10202 wxPyEndAllowThreads(__tstate);
10203 if (PyErr_Occurred()) SWIG_fail;
10204 }
10205 {
10206 #if wxUSE_UNICODE
10207 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10208 #else
10209 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10210 #endif
10211 }
10212 return resultobj;
10213 fail:
10214 return NULL;
10215 }
10216
10217
10218 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10219 PyObject *resultobj = 0;
10220 wxFSFile *arg1 = (wxFSFile *) 0 ;
10221 wxString *result = 0 ;
10222 void *argp1 = 0 ;
10223 int res1 = 0 ;
10224 PyObject *swig_obj[1] ;
10225
10226 if (!args) SWIG_fail;
10227 swig_obj[0] = args;
10228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10229 if (!SWIG_IsOK(res1)) {
10230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
10231 }
10232 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10233 {
10234 PyThreadState* __tstate = wxPyBeginAllowThreads();
10235 {
10236 wxString const &_result_ref = (arg1)->GetAnchor();
10237 result = (wxString *) &_result_ref;
10238 }
10239 wxPyEndAllowThreads(__tstate);
10240 if (PyErr_Occurred()) SWIG_fail;
10241 }
10242 {
10243 #if wxUSE_UNICODE
10244 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10245 #else
10246 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10247 #endif
10248 }
10249 return resultobj;
10250 fail:
10251 return NULL;
10252 }
10253
10254
10255 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10256 PyObject *resultobj = 0;
10257 wxFSFile *arg1 = (wxFSFile *) 0 ;
10258 wxDateTime result;
10259 void *argp1 = 0 ;
10260 int res1 = 0 ;
10261 PyObject *swig_obj[1] ;
10262
10263 if (!args) SWIG_fail;
10264 swig_obj[0] = args;
10265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10266 if (!SWIG_IsOK(res1)) {
10267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
10268 }
10269 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10270 {
10271 PyThreadState* __tstate = wxPyBeginAllowThreads();
10272 result = (arg1)->GetModificationTime();
10273 wxPyEndAllowThreads(__tstate);
10274 if (PyErr_Occurred()) SWIG_fail;
10275 }
10276 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
10277 return resultobj;
10278 fail:
10279 return NULL;
10280 }
10281
10282
10283 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10284 PyObject *obj;
10285 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10286 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10287 return SWIG_Py_Void();
10288 }
10289
10290 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10291 return SWIG_Python_InitShadowInstance(args);
10292 }
10293
10294 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10295 PyObject *resultobj = 0;
10296 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10297 void *argp1 = 0 ;
10298 int res1 = 0 ;
10299 PyObject *swig_obj[1] ;
10300
10301 if (!args) SWIG_fail;
10302 swig_obj[0] = args;
10303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10304 if (!SWIG_IsOK(res1)) {
10305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10306 }
10307 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10308 {
10309 PyThreadState* __tstate = wxPyBeginAllowThreads();
10310 delete arg1;
10311
10312 wxPyEndAllowThreads(__tstate);
10313 if (PyErr_Occurred()) SWIG_fail;
10314 }
10315 resultobj = SWIG_Py_Void();
10316 return resultobj;
10317 fail:
10318 return NULL;
10319 }
10320
10321
10322 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10323 PyObject *obj;
10324 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10325 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10326 return SWIG_Py_Void();
10327 }
10328
10329 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10330 PyObject *resultobj = 0;
10331 wxPyFileSystemHandler *result = 0 ;
10332
10333 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10334 {
10335 PyThreadState* __tstate = wxPyBeginAllowThreads();
10336 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10337 wxPyEndAllowThreads(__tstate);
10338 if (PyErr_Occurred()) SWIG_fail;
10339 }
10340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10341 return resultobj;
10342 fail:
10343 return NULL;
10344 }
10345
10346
10347 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10348 PyObject *resultobj = 0;
10349 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10350 PyObject *arg2 = (PyObject *) 0 ;
10351 PyObject *arg3 = (PyObject *) 0 ;
10352 void *argp1 = 0 ;
10353 int res1 = 0 ;
10354 PyObject * obj0 = 0 ;
10355 PyObject * obj1 = 0 ;
10356 PyObject * obj2 = 0 ;
10357 char * kwnames[] = {
10358 (char *) "self",(char *) "self",(char *) "_class", NULL
10359 };
10360
10361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10363 if (!SWIG_IsOK(res1)) {
10364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10365 }
10366 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10367 arg2 = obj1;
10368 arg3 = obj2;
10369 {
10370 PyThreadState* __tstate = wxPyBeginAllowThreads();
10371 (arg1)->_setCallbackInfo(arg2,arg3);
10372 wxPyEndAllowThreads(__tstate);
10373 if (PyErr_Occurred()) SWIG_fail;
10374 }
10375 resultobj = SWIG_Py_Void();
10376 return resultobj;
10377 fail:
10378 return NULL;
10379 }
10380
10381
10382 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10383 PyObject *resultobj = 0;
10384 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10385 wxString *arg2 = 0 ;
10386 bool result;
10387 void *argp1 = 0 ;
10388 int res1 = 0 ;
10389 bool temp2 = false ;
10390 PyObject * obj0 = 0 ;
10391 PyObject * obj1 = 0 ;
10392 char * kwnames[] = {
10393 (char *) "self",(char *) "location", NULL
10394 };
10395
10396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10398 if (!SWIG_IsOK(res1)) {
10399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10400 }
10401 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10402 {
10403 arg2 = wxString_in_helper(obj1);
10404 if (arg2 == NULL) SWIG_fail;
10405 temp2 = true;
10406 }
10407 {
10408 PyThreadState* __tstate = wxPyBeginAllowThreads();
10409 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10410 wxPyEndAllowThreads(__tstate);
10411 if (PyErr_Occurred()) SWIG_fail;
10412 }
10413 {
10414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10415 }
10416 {
10417 if (temp2)
10418 delete arg2;
10419 }
10420 return resultobj;
10421 fail:
10422 {
10423 if (temp2)
10424 delete arg2;
10425 }
10426 return NULL;
10427 }
10428
10429
10430 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10431 PyObject *resultobj = 0;
10432 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10433 wxFileSystem *arg2 = 0 ;
10434 wxString *arg3 = 0 ;
10435 wxFSFile *result = 0 ;
10436 void *argp1 = 0 ;
10437 int res1 = 0 ;
10438 void *argp2 = 0 ;
10439 int res2 = 0 ;
10440 bool temp3 = false ;
10441 PyObject * obj0 = 0 ;
10442 PyObject * obj1 = 0 ;
10443 PyObject * obj2 = 0 ;
10444 char * kwnames[] = {
10445 (char *) "self",(char *) "fs",(char *) "location", NULL
10446 };
10447
10448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10450 if (!SWIG_IsOK(res1)) {
10451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10452 }
10453 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10454 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10455 if (!SWIG_IsOK(res2)) {
10456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10457 }
10458 if (!argp2) {
10459 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10460 }
10461 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10462 {
10463 arg3 = wxString_in_helper(obj2);
10464 if (arg3 == NULL) SWIG_fail;
10465 temp3 = true;
10466 }
10467 {
10468 PyThreadState* __tstate = wxPyBeginAllowThreads();
10469 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10470 wxPyEndAllowThreads(__tstate);
10471 if (PyErr_Occurred()) SWIG_fail;
10472 }
10473 {
10474 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10475 }
10476 {
10477 if (temp3)
10478 delete arg3;
10479 }
10480 return resultobj;
10481 fail:
10482 {
10483 if (temp3)
10484 delete arg3;
10485 }
10486 return NULL;
10487 }
10488
10489
10490 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10491 PyObject *resultobj = 0;
10492 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10493 wxString *arg2 = 0 ;
10494 int arg3 = (int) 0 ;
10495 wxString result;
10496 void *argp1 = 0 ;
10497 int res1 = 0 ;
10498 bool temp2 = false ;
10499 int val3 ;
10500 int ecode3 = 0 ;
10501 PyObject * obj0 = 0 ;
10502 PyObject * obj1 = 0 ;
10503 PyObject * obj2 = 0 ;
10504 char * kwnames[] = {
10505 (char *) "self",(char *) "spec",(char *) "flags", NULL
10506 };
10507
10508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10510 if (!SWIG_IsOK(res1)) {
10511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10512 }
10513 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10514 {
10515 arg2 = wxString_in_helper(obj1);
10516 if (arg2 == NULL) SWIG_fail;
10517 temp2 = true;
10518 }
10519 if (obj2) {
10520 ecode3 = SWIG_AsVal_int(obj2, &val3);
10521 if (!SWIG_IsOK(ecode3)) {
10522 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10523 }
10524 arg3 = static_cast< int >(val3);
10525 }
10526 {
10527 PyThreadState* __tstate = wxPyBeginAllowThreads();
10528 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10529 wxPyEndAllowThreads(__tstate);
10530 if (PyErr_Occurred()) SWIG_fail;
10531 }
10532 {
10533 #if wxUSE_UNICODE
10534 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10535 #else
10536 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10537 #endif
10538 }
10539 {
10540 if (temp2)
10541 delete arg2;
10542 }
10543 return resultobj;
10544 fail:
10545 {
10546 if (temp2)
10547 delete arg2;
10548 }
10549 return NULL;
10550 }
10551
10552
10553 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10554 PyObject *resultobj = 0;
10555 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10556 wxString result;
10557 void *argp1 = 0 ;
10558 int res1 = 0 ;
10559 PyObject *swig_obj[1] ;
10560
10561 if (!args) SWIG_fail;
10562 swig_obj[0] = args;
10563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10564 if (!SWIG_IsOK(res1)) {
10565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10566 }
10567 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10568 {
10569 PyThreadState* __tstate = wxPyBeginAllowThreads();
10570 result = (arg1)->FindNext();
10571 wxPyEndAllowThreads(__tstate);
10572 if (PyErr_Occurred()) SWIG_fail;
10573 }
10574 {
10575 #if wxUSE_UNICODE
10576 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10577 #else
10578 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10579 #endif
10580 }
10581 return resultobj;
10582 fail:
10583 return NULL;
10584 }
10585
10586
10587 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10588 PyObject *resultobj = 0;
10589 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10590 wxString *arg2 = 0 ;
10591 wxString result;
10592 void *argp1 = 0 ;
10593 int res1 = 0 ;
10594 bool temp2 = false ;
10595 PyObject * obj0 = 0 ;
10596 PyObject * obj1 = 0 ;
10597 char * kwnames[] = {
10598 (char *) "self",(char *) "location", NULL
10599 };
10600
10601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10603 if (!SWIG_IsOK(res1)) {
10604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10605 }
10606 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10607 {
10608 arg2 = wxString_in_helper(obj1);
10609 if (arg2 == NULL) SWIG_fail;
10610 temp2 = true;
10611 }
10612 {
10613 PyThreadState* __tstate = wxPyBeginAllowThreads();
10614 result = (arg1)->GetProtocol((wxString const &)*arg2);
10615 wxPyEndAllowThreads(__tstate);
10616 if (PyErr_Occurred()) SWIG_fail;
10617 }
10618 {
10619 #if wxUSE_UNICODE
10620 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10621 #else
10622 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10623 #endif
10624 }
10625 {
10626 if (temp2)
10627 delete arg2;
10628 }
10629 return resultobj;
10630 fail:
10631 {
10632 if (temp2)
10633 delete arg2;
10634 }
10635 return NULL;
10636 }
10637
10638
10639 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10640 PyObject *resultobj = 0;
10641 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10642 wxString *arg2 = 0 ;
10643 wxString result;
10644 void *argp1 = 0 ;
10645 int res1 = 0 ;
10646 bool temp2 = false ;
10647 PyObject * obj0 = 0 ;
10648 PyObject * obj1 = 0 ;
10649 char * kwnames[] = {
10650 (char *) "self",(char *) "location", NULL
10651 };
10652
10653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10655 if (!SWIG_IsOK(res1)) {
10656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10657 }
10658 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10659 {
10660 arg2 = wxString_in_helper(obj1);
10661 if (arg2 == NULL) SWIG_fail;
10662 temp2 = true;
10663 }
10664 {
10665 PyThreadState* __tstate = wxPyBeginAllowThreads();
10666 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10667 wxPyEndAllowThreads(__tstate);
10668 if (PyErr_Occurred()) SWIG_fail;
10669 }
10670 {
10671 #if wxUSE_UNICODE
10672 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10673 #else
10674 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10675 #endif
10676 }
10677 {
10678 if (temp2)
10679 delete arg2;
10680 }
10681 return resultobj;
10682 fail:
10683 {
10684 if (temp2)
10685 delete arg2;
10686 }
10687 return NULL;
10688 }
10689
10690
10691 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10692 PyObject *resultobj = 0;
10693 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10694 wxString *arg2 = 0 ;
10695 wxString result;
10696 void *argp1 = 0 ;
10697 int res1 = 0 ;
10698 bool temp2 = false ;
10699 PyObject * obj0 = 0 ;
10700 PyObject * obj1 = 0 ;
10701 char * kwnames[] = {
10702 (char *) "self",(char *) "location", NULL
10703 };
10704
10705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10707 if (!SWIG_IsOK(res1)) {
10708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10709 }
10710 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10711 {
10712 arg2 = wxString_in_helper(obj1);
10713 if (arg2 == NULL) SWIG_fail;
10714 temp2 = true;
10715 }
10716 {
10717 PyThreadState* __tstate = wxPyBeginAllowThreads();
10718 result = (arg1)->GetAnchor((wxString const &)*arg2);
10719 wxPyEndAllowThreads(__tstate);
10720 if (PyErr_Occurred()) SWIG_fail;
10721 }
10722 {
10723 #if wxUSE_UNICODE
10724 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10725 #else
10726 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10727 #endif
10728 }
10729 {
10730 if (temp2)
10731 delete arg2;
10732 }
10733 return resultobj;
10734 fail:
10735 {
10736 if (temp2)
10737 delete arg2;
10738 }
10739 return NULL;
10740 }
10741
10742
10743 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10744 PyObject *resultobj = 0;
10745 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10746 wxString *arg2 = 0 ;
10747 wxString result;
10748 void *argp1 = 0 ;
10749 int res1 = 0 ;
10750 bool temp2 = false ;
10751 PyObject * obj0 = 0 ;
10752 PyObject * obj1 = 0 ;
10753 char * kwnames[] = {
10754 (char *) "self",(char *) "location", NULL
10755 };
10756
10757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10759 if (!SWIG_IsOK(res1)) {
10760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10761 }
10762 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10763 {
10764 arg2 = wxString_in_helper(obj1);
10765 if (arg2 == NULL) SWIG_fail;
10766 temp2 = true;
10767 }
10768 {
10769 PyThreadState* __tstate = wxPyBeginAllowThreads();
10770 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10771 wxPyEndAllowThreads(__tstate);
10772 if (PyErr_Occurred()) SWIG_fail;
10773 }
10774 {
10775 #if wxUSE_UNICODE
10776 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10777 #else
10778 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10779 #endif
10780 }
10781 {
10782 if (temp2)
10783 delete arg2;
10784 }
10785 return resultobj;
10786 fail:
10787 {
10788 if (temp2)
10789 delete arg2;
10790 }
10791 return NULL;
10792 }
10793
10794
10795 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10796 PyObject *resultobj = 0;
10797 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10798 wxString *arg2 = 0 ;
10799 wxString result;
10800 void *argp1 = 0 ;
10801 int res1 = 0 ;
10802 bool temp2 = false ;
10803 PyObject * obj0 = 0 ;
10804 PyObject * obj1 = 0 ;
10805 char * kwnames[] = {
10806 (char *) "self",(char *) "location", NULL
10807 };
10808
10809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10811 if (!SWIG_IsOK(res1)) {
10812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10813 }
10814 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10815 {
10816 arg2 = wxString_in_helper(obj1);
10817 if (arg2 == NULL) SWIG_fail;
10818 temp2 = true;
10819 }
10820 {
10821 PyThreadState* __tstate = wxPyBeginAllowThreads();
10822 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10823 wxPyEndAllowThreads(__tstate);
10824 if (PyErr_Occurred()) SWIG_fail;
10825 }
10826 {
10827 #if wxUSE_UNICODE
10828 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10829 #else
10830 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10831 #endif
10832 }
10833 {
10834 if (temp2)
10835 delete arg2;
10836 }
10837 return resultobj;
10838 fail:
10839 {
10840 if (temp2)
10841 delete arg2;
10842 }
10843 return NULL;
10844 }
10845
10846
10847 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10848 PyObject *obj;
10849 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10850 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10851 return SWIG_Py_Void();
10852 }
10853
10854 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10855 return SWIG_Python_InitShadowInstance(args);
10856 }
10857
10858 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10859 PyObject *resultobj = 0;
10860 wxFileSystem *result = 0 ;
10861
10862 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10863 {
10864 PyThreadState* __tstate = wxPyBeginAllowThreads();
10865 result = (wxFileSystem *)new wxFileSystem();
10866 wxPyEndAllowThreads(__tstate);
10867 if (PyErr_Occurred()) SWIG_fail;
10868 }
10869 {
10870 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10871 }
10872 return resultobj;
10873 fail:
10874 return NULL;
10875 }
10876
10877
10878 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10879 PyObject *resultobj = 0;
10880 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10881 void *argp1 = 0 ;
10882 int res1 = 0 ;
10883 PyObject *swig_obj[1] ;
10884
10885 if (!args) SWIG_fail;
10886 swig_obj[0] = args;
10887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10888 if (!SWIG_IsOK(res1)) {
10889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10890 }
10891 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10892 {
10893 PyThreadState* __tstate = wxPyBeginAllowThreads();
10894 delete arg1;
10895
10896 wxPyEndAllowThreads(__tstate);
10897 if (PyErr_Occurred()) SWIG_fail;
10898 }
10899 resultobj = SWIG_Py_Void();
10900 return resultobj;
10901 fail:
10902 return NULL;
10903 }
10904
10905
10906 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10907 PyObject *resultobj = 0;
10908 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10909 wxString *arg2 = 0 ;
10910 bool arg3 = (bool) false ;
10911 void *argp1 = 0 ;
10912 int res1 = 0 ;
10913 bool temp2 = false ;
10914 bool val3 ;
10915 int ecode3 = 0 ;
10916 PyObject * obj0 = 0 ;
10917 PyObject * obj1 = 0 ;
10918 PyObject * obj2 = 0 ;
10919 char * kwnames[] = {
10920 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10921 };
10922
10923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10925 if (!SWIG_IsOK(res1)) {
10926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10927 }
10928 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10929 {
10930 arg2 = wxString_in_helper(obj1);
10931 if (arg2 == NULL) SWIG_fail;
10932 temp2 = true;
10933 }
10934 if (obj2) {
10935 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10936 if (!SWIG_IsOK(ecode3)) {
10937 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10938 }
10939 arg3 = static_cast< bool >(val3);
10940 }
10941 {
10942 PyThreadState* __tstate = wxPyBeginAllowThreads();
10943 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10944 wxPyEndAllowThreads(__tstate);
10945 if (PyErr_Occurred()) SWIG_fail;
10946 }
10947 resultobj = SWIG_Py_Void();
10948 {
10949 if (temp2)
10950 delete arg2;
10951 }
10952 return resultobj;
10953 fail:
10954 {
10955 if (temp2)
10956 delete arg2;
10957 }
10958 return NULL;
10959 }
10960
10961
10962 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10963 PyObject *resultobj = 0;
10964 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10965 wxString result;
10966 void *argp1 = 0 ;
10967 int res1 = 0 ;
10968 PyObject *swig_obj[1] ;
10969
10970 if (!args) SWIG_fail;
10971 swig_obj[0] = args;
10972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10973 if (!SWIG_IsOK(res1)) {
10974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10975 }
10976 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10977 {
10978 PyThreadState* __tstate = wxPyBeginAllowThreads();
10979 result = (arg1)->GetPath();
10980 wxPyEndAllowThreads(__tstate);
10981 if (PyErr_Occurred()) SWIG_fail;
10982 }
10983 {
10984 #if wxUSE_UNICODE
10985 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10986 #else
10987 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10988 #endif
10989 }
10990 return resultobj;
10991 fail:
10992 return NULL;
10993 }
10994
10995
10996 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10997 PyObject *resultobj = 0;
10998 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10999 wxString *arg2 = 0 ;
11000 wxFSFile *result = 0 ;
11001 void *argp1 = 0 ;
11002 int res1 = 0 ;
11003 bool temp2 = false ;
11004 PyObject * obj0 = 0 ;
11005 PyObject * obj1 = 0 ;
11006 char * kwnames[] = {
11007 (char *) "self",(char *) "location", NULL
11008 };
11009
11010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
11011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11012 if (!SWIG_IsOK(res1)) {
11013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11014 }
11015 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11016 {
11017 arg2 = wxString_in_helper(obj1);
11018 if (arg2 == NULL) SWIG_fail;
11019 temp2 = true;
11020 }
11021 {
11022 PyThreadState* __tstate = wxPyBeginAllowThreads();
11023 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
11024 wxPyEndAllowThreads(__tstate);
11025 if (PyErr_Occurred()) SWIG_fail;
11026 }
11027 {
11028 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11029 }
11030 {
11031 if (temp2)
11032 delete arg2;
11033 }
11034 return resultobj;
11035 fail:
11036 {
11037 if (temp2)
11038 delete arg2;
11039 }
11040 return NULL;
11041 }
11042
11043
11044 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11045 PyObject *resultobj = 0;
11046 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
11047 wxString *arg2 = 0 ;
11048 int arg3 = (int) 0 ;
11049 wxString result;
11050 void *argp1 = 0 ;
11051 int res1 = 0 ;
11052 bool temp2 = false ;
11053 int val3 ;
11054 int ecode3 = 0 ;
11055 PyObject * obj0 = 0 ;
11056 PyObject * obj1 = 0 ;
11057 PyObject * obj2 = 0 ;
11058 char * kwnames[] = {
11059 (char *) "self",(char *) "spec",(char *) "flags", NULL
11060 };
11061
11062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11064 if (!SWIG_IsOK(res1)) {
11065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11066 }
11067 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11068 {
11069 arg2 = wxString_in_helper(obj1);
11070 if (arg2 == NULL) SWIG_fail;
11071 temp2 = true;
11072 }
11073 if (obj2) {
11074 ecode3 = SWIG_AsVal_int(obj2, &val3);
11075 if (!SWIG_IsOK(ecode3)) {
11076 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
11077 }
11078 arg3 = static_cast< int >(val3);
11079 }
11080 {
11081 PyThreadState* __tstate = wxPyBeginAllowThreads();
11082 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11083 wxPyEndAllowThreads(__tstate);
11084 if (PyErr_Occurred()) SWIG_fail;
11085 }
11086 {
11087 #if wxUSE_UNICODE
11088 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11089 #else
11090 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11091 #endif
11092 }
11093 {
11094 if (temp2)
11095 delete arg2;
11096 }
11097 return resultobj;
11098 fail:
11099 {
11100 if (temp2)
11101 delete arg2;
11102 }
11103 return NULL;
11104 }
11105
11106
11107 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11108 PyObject *resultobj = 0;
11109 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
11110 wxString result;
11111 void *argp1 = 0 ;
11112 int res1 = 0 ;
11113 PyObject *swig_obj[1] ;
11114
11115 if (!args) SWIG_fail;
11116 swig_obj[0] = args;
11117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11118 if (!SWIG_IsOK(res1)) {
11119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11120 }
11121 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11122 {
11123 PyThreadState* __tstate = wxPyBeginAllowThreads();
11124 result = (arg1)->FindNext();
11125 wxPyEndAllowThreads(__tstate);
11126 if (PyErr_Occurred()) SWIG_fail;
11127 }
11128 {
11129 #if wxUSE_UNICODE
11130 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11131 #else
11132 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11133 #endif
11134 }
11135 return resultobj;
11136 fail:
11137 return NULL;
11138 }
11139
11140
11141 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11142 PyObject *resultobj = 0;
11143 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11144 int res1 = 0 ;
11145 PyObject * obj0 = 0 ;
11146 char * kwnames[] = {
11147 (char *) "handler", NULL
11148 };
11149
11150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
11151 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
11152 if (!SWIG_IsOK(res1)) {
11153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11154 }
11155 {
11156 PyThreadState* __tstate = wxPyBeginAllowThreads();
11157 wxFileSystem::AddHandler(arg1);
11158 wxPyEndAllowThreads(__tstate);
11159 if (PyErr_Occurred()) SWIG_fail;
11160 }
11161 resultobj = SWIG_Py_Void();
11162 return resultobj;
11163 fail:
11164 return NULL;
11165 }
11166
11167
11168 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11169 PyObject *resultobj = 0;
11170 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11171 wxFileSystemHandler *result = 0 ;
11172 void *argp1 = 0 ;
11173 int res1 = 0 ;
11174 PyObject * obj0 = 0 ;
11175 char * kwnames[] = {
11176 (char *) "handler", NULL
11177 };
11178
11179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
11180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
11181 if (!SWIG_IsOK(res1)) {
11182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11183 }
11184 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
11185 {
11186 PyThreadState* __tstate = wxPyBeginAllowThreads();
11187 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
11188 wxPyEndAllowThreads(__tstate);
11189 if (PyErr_Occurred()) SWIG_fail;
11190 }
11191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
11192 return resultobj;
11193 fail:
11194 return NULL;
11195 }
11196
11197
11198 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11199 PyObject *resultobj = 0;
11200
11201 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
11202 {
11203 PyThreadState* __tstate = wxPyBeginAllowThreads();
11204 wxFileSystem::CleanUpHandlers();
11205 wxPyEndAllowThreads(__tstate);
11206 if (PyErr_Occurred()) SWIG_fail;
11207 }
11208 resultobj = SWIG_Py_Void();
11209 return resultobj;
11210 fail:
11211 return NULL;
11212 }
11213
11214
11215 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11216 PyObject *resultobj = 0;
11217 wxString *arg1 = 0 ;
11218 wxString result;
11219 bool temp1 = false ;
11220 PyObject * obj0 = 0 ;
11221 char * kwnames[] = {
11222 (char *) "filename", NULL
11223 };
11224
11225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
11226 {
11227 arg1 = wxString_in_helper(obj0);
11228 if (arg1 == NULL) SWIG_fail;
11229 temp1 = true;
11230 }
11231 {
11232 PyThreadState* __tstate = wxPyBeginAllowThreads();
11233 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
11234 wxPyEndAllowThreads(__tstate);
11235 if (PyErr_Occurred()) SWIG_fail;
11236 }
11237 {
11238 #if wxUSE_UNICODE
11239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11240 #else
11241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11242 #endif
11243 }
11244 {
11245 if (temp1)
11246 delete arg1;
11247 }
11248 return resultobj;
11249 fail:
11250 {
11251 if (temp1)
11252 delete arg1;
11253 }
11254 return NULL;
11255 }
11256
11257
11258 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11259 PyObject *resultobj = 0;
11260 wxString *arg1 = 0 ;
11261 wxString result;
11262 bool temp1 = false ;
11263 PyObject * obj0 = 0 ;
11264 char * kwnames[] = {
11265 (char *) "url", NULL
11266 };
11267
11268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
11269 {
11270 arg1 = wxString_in_helper(obj0);
11271 if (arg1 == NULL) SWIG_fail;
11272 temp1 = true;
11273 }
11274 {
11275 PyThreadState* __tstate = wxPyBeginAllowThreads();
11276 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
11277 wxPyEndAllowThreads(__tstate);
11278 if (PyErr_Occurred()) SWIG_fail;
11279 }
11280 {
11281 #if wxUSE_UNICODE
11282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11283 #else
11284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11285 #endif
11286 }
11287 {
11288 if (temp1)
11289 delete arg1;
11290 }
11291 return resultobj;
11292 fail:
11293 {
11294 if (temp1)
11295 delete arg1;
11296 }
11297 return NULL;
11298 }
11299
11300
11301 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11302 PyObject *obj;
11303 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11304 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
11305 return SWIG_Py_Void();
11306 }
11307
11308 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11309 return SWIG_Python_InitShadowInstance(args);
11310 }
11311
11312 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11313 PyObject *resultobj = 0;
11314 wxInternetFSHandler *result = 0 ;
11315
11316 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11317 {
11318 PyThreadState* __tstate = wxPyBeginAllowThreads();
11319 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11320 wxPyEndAllowThreads(__tstate);
11321 if (PyErr_Occurred()) SWIG_fail;
11322 }
11323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11324 return resultobj;
11325 fail:
11326 return NULL;
11327 }
11328
11329
11330 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11331 PyObject *resultobj = 0;
11332 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11333 wxString *arg2 = 0 ;
11334 bool result;
11335 void *argp1 = 0 ;
11336 int res1 = 0 ;
11337 bool temp2 = false ;
11338 PyObject * obj0 = 0 ;
11339 PyObject * obj1 = 0 ;
11340 char * kwnames[] = {
11341 (char *) "self",(char *) "location", NULL
11342 };
11343
11344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11346 if (!SWIG_IsOK(res1)) {
11347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11348 }
11349 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11350 {
11351 arg2 = wxString_in_helper(obj1);
11352 if (arg2 == NULL) SWIG_fail;
11353 temp2 = true;
11354 }
11355 {
11356 PyThreadState* __tstate = wxPyBeginAllowThreads();
11357 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11358 wxPyEndAllowThreads(__tstate);
11359 if (PyErr_Occurred()) SWIG_fail;
11360 }
11361 {
11362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11363 }
11364 {
11365 if (temp2)
11366 delete arg2;
11367 }
11368 return resultobj;
11369 fail:
11370 {
11371 if (temp2)
11372 delete arg2;
11373 }
11374 return NULL;
11375 }
11376
11377
11378 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11379 PyObject *resultobj = 0;
11380 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11381 wxFileSystem *arg2 = 0 ;
11382 wxString *arg3 = 0 ;
11383 wxFSFile *result = 0 ;
11384 void *argp1 = 0 ;
11385 int res1 = 0 ;
11386 void *argp2 = 0 ;
11387 int res2 = 0 ;
11388 bool temp3 = false ;
11389 PyObject * obj0 = 0 ;
11390 PyObject * obj1 = 0 ;
11391 PyObject * obj2 = 0 ;
11392 char * kwnames[] = {
11393 (char *) "self",(char *) "fs",(char *) "location", NULL
11394 };
11395
11396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11398 if (!SWIG_IsOK(res1)) {
11399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11400 }
11401 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11402 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11403 if (!SWIG_IsOK(res2)) {
11404 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11405 }
11406 if (!argp2) {
11407 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11408 }
11409 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11410 {
11411 arg3 = wxString_in_helper(obj2);
11412 if (arg3 == NULL) SWIG_fail;
11413 temp3 = true;
11414 }
11415 {
11416 PyThreadState* __tstate = wxPyBeginAllowThreads();
11417 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11418 wxPyEndAllowThreads(__tstate);
11419 if (PyErr_Occurred()) SWIG_fail;
11420 }
11421 {
11422 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11423 }
11424 {
11425 if (temp3)
11426 delete arg3;
11427 }
11428 return resultobj;
11429 fail:
11430 {
11431 if (temp3)
11432 delete arg3;
11433 }
11434 return NULL;
11435 }
11436
11437
11438 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11439 PyObject *obj;
11440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11441 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11442 return SWIG_Py_Void();
11443 }
11444
11445 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11446 return SWIG_Python_InitShadowInstance(args);
11447 }
11448
11449 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11450 PyObject *resultobj = 0;
11451 wxZipFSHandler *result = 0 ;
11452
11453 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11454 {
11455 PyThreadState* __tstate = wxPyBeginAllowThreads();
11456 result = (wxZipFSHandler *)new wxZipFSHandler();
11457 wxPyEndAllowThreads(__tstate);
11458 if (PyErr_Occurred()) SWIG_fail;
11459 }
11460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11461 return resultobj;
11462 fail:
11463 return NULL;
11464 }
11465
11466
11467 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11468 PyObject *resultobj = 0;
11469 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11470 wxString *arg2 = 0 ;
11471 bool result;
11472 void *argp1 = 0 ;
11473 int res1 = 0 ;
11474 bool temp2 = false ;
11475 PyObject * obj0 = 0 ;
11476 PyObject * obj1 = 0 ;
11477 char * kwnames[] = {
11478 (char *) "self",(char *) "location", NULL
11479 };
11480
11481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11483 if (!SWIG_IsOK(res1)) {
11484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11485 }
11486 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11487 {
11488 arg2 = wxString_in_helper(obj1);
11489 if (arg2 == NULL) SWIG_fail;
11490 temp2 = true;
11491 }
11492 {
11493 PyThreadState* __tstate = wxPyBeginAllowThreads();
11494 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11495 wxPyEndAllowThreads(__tstate);
11496 if (PyErr_Occurred()) SWIG_fail;
11497 }
11498 {
11499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11500 }
11501 {
11502 if (temp2)
11503 delete arg2;
11504 }
11505 return resultobj;
11506 fail:
11507 {
11508 if (temp2)
11509 delete arg2;
11510 }
11511 return NULL;
11512 }
11513
11514
11515 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11516 PyObject *resultobj = 0;
11517 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11518 wxFileSystem *arg2 = 0 ;
11519 wxString *arg3 = 0 ;
11520 wxFSFile *result = 0 ;
11521 void *argp1 = 0 ;
11522 int res1 = 0 ;
11523 void *argp2 = 0 ;
11524 int res2 = 0 ;
11525 bool temp3 = false ;
11526 PyObject * obj0 = 0 ;
11527 PyObject * obj1 = 0 ;
11528 PyObject * obj2 = 0 ;
11529 char * kwnames[] = {
11530 (char *) "self",(char *) "fs",(char *) "location", NULL
11531 };
11532
11533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11535 if (!SWIG_IsOK(res1)) {
11536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11537 }
11538 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11539 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11540 if (!SWIG_IsOK(res2)) {
11541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11542 }
11543 if (!argp2) {
11544 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11545 }
11546 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11547 {
11548 arg3 = wxString_in_helper(obj2);
11549 if (arg3 == NULL) SWIG_fail;
11550 temp3 = true;
11551 }
11552 {
11553 PyThreadState* __tstate = wxPyBeginAllowThreads();
11554 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11555 wxPyEndAllowThreads(__tstate);
11556 if (PyErr_Occurred()) SWIG_fail;
11557 }
11558 {
11559 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11560 }
11561 {
11562 if (temp3)
11563 delete arg3;
11564 }
11565 return resultobj;
11566 fail:
11567 {
11568 if (temp3)
11569 delete arg3;
11570 }
11571 return NULL;
11572 }
11573
11574
11575 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11576 PyObject *resultobj = 0;
11577 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11578 wxString *arg2 = 0 ;
11579 int arg3 = (int) 0 ;
11580 wxString result;
11581 void *argp1 = 0 ;
11582 int res1 = 0 ;
11583 bool temp2 = false ;
11584 int val3 ;
11585 int ecode3 = 0 ;
11586 PyObject * obj0 = 0 ;
11587 PyObject * obj1 = 0 ;
11588 PyObject * obj2 = 0 ;
11589 char * kwnames[] = {
11590 (char *) "self",(char *) "spec",(char *) "flags", NULL
11591 };
11592
11593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11595 if (!SWIG_IsOK(res1)) {
11596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11597 }
11598 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11599 {
11600 arg2 = wxString_in_helper(obj1);
11601 if (arg2 == NULL) SWIG_fail;
11602 temp2 = true;
11603 }
11604 if (obj2) {
11605 ecode3 = SWIG_AsVal_int(obj2, &val3);
11606 if (!SWIG_IsOK(ecode3)) {
11607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11608 }
11609 arg3 = static_cast< int >(val3);
11610 }
11611 {
11612 PyThreadState* __tstate = wxPyBeginAllowThreads();
11613 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11614 wxPyEndAllowThreads(__tstate);
11615 if (PyErr_Occurred()) SWIG_fail;
11616 }
11617 {
11618 #if wxUSE_UNICODE
11619 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11620 #else
11621 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11622 #endif
11623 }
11624 {
11625 if (temp2)
11626 delete arg2;
11627 }
11628 return resultobj;
11629 fail:
11630 {
11631 if (temp2)
11632 delete arg2;
11633 }
11634 return NULL;
11635 }
11636
11637
11638 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11639 PyObject *resultobj = 0;
11640 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11641 wxString result;
11642 void *argp1 = 0 ;
11643 int res1 = 0 ;
11644 PyObject *swig_obj[1] ;
11645
11646 if (!args) SWIG_fail;
11647 swig_obj[0] = args;
11648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11649 if (!SWIG_IsOK(res1)) {
11650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11651 }
11652 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11653 {
11654 PyThreadState* __tstate = wxPyBeginAllowThreads();
11655 result = (arg1)->FindNext();
11656 wxPyEndAllowThreads(__tstate);
11657 if (PyErr_Occurred()) SWIG_fail;
11658 }
11659 {
11660 #if wxUSE_UNICODE
11661 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11662 #else
11663 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11664 #endif
11665 }
11666 return resultobj;
11667 fail:
11668 return NULL;
11669 }
11670
11671
11672 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11673 PyObject *obj;
11674 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11675 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11676 return SWIG_Py_Void();
11677 }
11678
11679 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11680 return SWIG_Python_InitShadowInstance(args);
11681 }
11682
11683 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11684 PyObject *resultobj = 0;
11685 wxString *arg1 = 0 ;
11686 wxImage *arg2 = 0 ;
11687 long arg3 ;
11688 bool temp1 = false ;
11689 void *argp2 = 0 ;
11690 int res2 = 0 ;
11691 long val3 ;
11692 int ecode3 = 0 ;
11693 PyObject * obj0 = 0 ;
11694 PyObject * obj1 = 0 ;
11695 PyObject * obj2 = 0 ;
11696 char * kwnames[] = {
11697 (char *) "filename",(char *) "image",(char *) "type", NULL
11698 };
11699
11700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11701 {
11702 arg1 = wxString_in_helper(obj0);
11703 if (arg1 == NULL) SWIG_fail;
11704 temp1 = true;
11705 }
11706 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11707 if (!SWIG_IsOK(res2)) {
11708 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11709 }
11710 if (!argp2) {
11711 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11712 }
11713 arg2 = reinterpret_cast< wxImage * >(argp2);
11714 ecode3 = SWIG_AsVal_long(obj2, &val3);
11715 if (!SWIG_IsOK(ecode3)) {
11716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11717 }
11718 arg3 = static_cast< long >(val3);
11719 {
11720 PyThreadState* __tstate = wxPyBeginAllowThreads();
11721 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11722 wxPyEndAllowThreads(__tstate);
11723 if (PyErr_Occurred()) SWIG_fail;
11724 }
11725 resultobj = SWIG_Py_Void();
11726 {
11727 if (temp1)
11728 delete arg1;
11729 }
11730 return resultobj;
11731 fail:
11732 {
11733 if (temp1)
11734 delete arg1;
11735 }
11736 return NULL;
11737 }
11738
11739
11740 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11741 PyObject *resultobj = 0;
11742 wxString *arg1 = 0 ;
11743 wxBitmap *arg2 = 0 ;
11744 long arg3 ;
11745 bool temp1 = false ;
11746 void *argp2 = 0 ;
11747 int res2 = 0 ;
11748 long val3 ;
11749 int ecode3 = 0 ;
11750 PyObject * obj0 = 0 ;
11751 PyObject * obj1 = 0 ;
11752 PyObject * obj2 = 0 ;
11753 char * kwnames[] = {
11754 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11755 };
11756
11757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11758 {
11759 arg1 = wxString_in_helper(obj0);
11760 if (arg1 == NULL) SWIG_fail;
11761 temp1 = true;
11762 }
11763 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11764 if (!SWIG_IsOK(res2)) {
11765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11766 }
11767 if (!argp2) {
11768 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11769 }
11770 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11771 ecode3 = SWIG_AsVal_long(obj2, &val3);
11772 if (!SWIG_IsOK(ecode3)) {
11773 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11774 }
11775 arg3 = static_cast< long >(val3);
11776 {
11777 PyThreadState* __tstate = wxPyBeginAllowThreads();
11778 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11779 wxPyEndAllowThreads(__tstate);
11780 if (PyErr_Occurred()) SWIG_fail;
11781 }
11782 resultobj = SWIG_Py_Void();
11783 {
11784 if (temp1)
11785 delete arg1;
11786 }
11787 return resultobj;
11788 fail:
11789 {
11790 if (temp1)
11791 delete arg1;
11792 }
11793 return NULL;
11794 }
11795
11796
11797 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11798 PyObject *resultobj = 0;
11799 wxString *arg1 = 0 ;
11800 PyObject *arg2 = (PyObject *) 0 ;
11801 bool temp1 = false ;
11802 PyObject * obj0 = 0 ;
11803 PyObject * obj1 = 0 ;
11804 char * kwnames[] = {
11805 (char *) "filename",(char *) "data", NULL
11806 };
11807
11808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11809 {
11810 arg1 = wxString_in_helper(obj0);
11811 if (arg1 == NULL) SWIG_fail;
11812 temp1 = true;
11813 }
11814 arg2 = obj1;
11815 {
11816 PyThreadState* __tstate = wxPyBeginAllowThreads();
11817 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11818 wxPyEndAllowThreads(__tstate);
11819 if (PyErr_Occurred()) SWIG_fail;
11820 }
11821 resultobj = SWIG_Py_Void();
11822 {
11823 if (temp1)
11824 delete arg1;
11825 }
11826 return resultobj;
11827 fail:
11828 {
11829 if (temp1)
11830 delete arg1;
11831 }
11832 return NULL;
11833 }
11834
11835
11836 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11837 PyObject *resultobj = 0;
11838 wxMemoryFSHandler *result = 0 ;
11839
11840 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11841 {
11842 PyThreadState* __tstate = wxPyBeginAllowThreads();
11843 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11844 wxPyEndAllowThreads(__tstate);
11845 if (PyErr_Occurred()) SWIG_fail;
11846 }
11847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11848 return resultobj;
11849 fail:
11850 return NULL;
11851 }
11852
11853
11854 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11855 PyObject *resultobj = 0;
11856 wxString *arg1 = 0 ;
11857 bool temp1 = false ;
11858 PyObject * obj0 = 0 ;
11859 char * kwnames[] = {
11860 (char *) "filename", NULL
11861 };
11862
11863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11864 {
11865 arg1 = wxString_in_helper(obj0);
11866 if (arg1 == NULL) SWIG_fail;
11867 temp1 = true;
11868 }
11869 {
11870 PyThreadState* __tstate = wxPyBeginAllowThreads();
11871 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11872 wxPyEndAllowThreads(__tstate);
11873 if (PyErr_Occurred()) SWIG_fail;
11874 }
11875 resultobj = SWIG_Py_Void();
11876 {
11877 if (temp1)
11878 delete arg1;
11879 }
11880 return resultobj;
11881 fail:
11882 {
11883 if (temp1)
11884 delete arg1;
11885 }
11886 return NULL;
11887 }
11888
11889
11890 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11891 PyObject *resultobj = 0;
11892 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11893 wxString *arg2 = 0 ;
11894 bool result;
11895 void *argp1 = 0 ;
11896 int res1 = 0 ;
11897 bool temp2 = false ;
11898 PyObject * obj0 = 0 ;
11899 PyObject * obj1 = 0 ;
11900 char * kwnames[] = {
11901 (char *) "self",(char *) "location", NULL
11902 };
11903
11904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11906 if (!SWIG_IsOK(res1)) {
11907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11908 }
11909 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11910 {
11911 arg2 = wxString_in_helper(obj1);
11912 if (arg2 == NULL) SWIG_fail;
11913 temp2 = true;
11914 }
11915 {
11916 PyThreadState* __tstate = wxPyBeginAllowThreads();
11917 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11918 wxPyEndAllowThreads(__tstate);
11919 if (PyErr_Occurred()) SWIG_fail;
11920 }
11921 {
11922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11923 }
11924 {
11925 if (temp2)
11926 delete arg2;
11927 }
11928 return resultobj;
11929 fail:
11930 {
11931 if (temp2)
11932 delete arg2;
11933 }
11934 return NULL;
11935 }
11936
11937
11938 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11939 PyObject *resultobj = 0;
11940 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11941 wxFileSystem *arg2 = 0 ;
11942 wxString *arg3 = 0 ;
11943 wxFSFile *result = 0 ;
11944 void *argp1 = 0 ;
11945 int res1 = 0 ;
11946 void *argp2 = 0 ;
11947 int res2 = 0 ;
11948 bool temp3 = false ;
11949 PyObject * obj0 = 0 ;
11950 PyObject * obj1 = 0 ;
11951 PyObject * obj2 = 0 ;
11952 char * kwnames[] = {
11953 (char *) "self",(char *) "fs",(char *) "location", NULL
11954 };
11955
11956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11958 if (!SWIG_IsOK(res1)) {
11959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11960 }
11961 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11962 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11963 if (!SWIG_IsOK(res2)) {
11964 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11965 }
11966 if (!argp2) {
11967 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11968 }
11969 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11970 {
11971 arg3 = wxString_in_helper(obj2);
11972 if (arg3 == NULL) SWIG_fail;
11973 temp3 = true;
11974 }
11975 {
11976 PyThreadState* __tstate = wxPyBeginAllowThreads();
11977 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11978 wxPyEndAllowThreads(__tstate);
11979 if (PyErr_Occurred()) SWIG_fail;
11980 }
11981 {
11982 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11983 }
11984 {
11985 if (temp3)
11986 delete arg3;
11987 }
11988 return resultobj;
11989 fail:
11990 {
11991 if (temp3)
11992 delete arg3;
11993 }
11994 return NULL;
11995 }
11996
11997
11998 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11999 PyObject *resultobj = 0;
12000 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
12001 wxString *arg2 = 0 ;
12002 int arg3 = (int) 0 ;
12003 wxString result;
12004 void *argp1 = 0 ;
12005 int res1 = 0 ;
12006 bool temp2 = false ;
12007 int val3 ;
12008 int ecode3 = 0 ;
12009 PyObject * obj0 = 0 ;
12010 PyObject * obj1 = 0 ;
12011 PyObject * obj2 = 0 ;
12012 char * kwnames[] = {
12013 (char *) "self",(char *) "spec",(char *) "flags", NULL
12014 };
12015
12016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
12018 if (!SWIG_IsOK(res1)) {
12019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
12020 }
12021 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
12022 {
12023 arg2 = wxString_in_helper(obj1);
12024 if (arg2 == NULL) SWIG_fail;
12025 temp2 = true;
12026 }
12027 if (obj2) {
12028 ecode3 = SWIG_AsVal_int(obj2, &val3);
12029 if (!SWIG_IsOK(ecode3)) {
12030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12031 }
12032 arg3 = static_cast< int >(val3);
12033 }
12034 {
12035 PyThreadState* __tstate = wxPyBeginAllowThreads();
12036 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12037 wxPyEndAllowThreads(__tstate);
12038 if (PyErr_Occurred()) SWIG_fail;
12039 }
12040 {
12041 #if wxUSE_UNICODE
12042 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12043 #else
12044 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12045 #endif
12046 }
12047 {
12048 if (temp2)
12049 delete arg2;
12050 }
12051 return resultobj;
12052 fail:
12053 {
12054 if (temp2)
12055 delete arg2;
12056 }
12057 return NULL;
12058 }
12059
12060
12061 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12062 PyObject *resultobj = 0;
12063 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
12064 wxString result;
12065 void *argp1 = 0 ;
12066 int res1 = 0 ;
12067 PyObject *swig_obj[1] ;
12068
12069 if (!args) SWIG_fail;
12070 swig_obj[0] = args;
12071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
12072 if (!SWIG_IsOK(res1)) {
12073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
12074 }
12075 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
12076 {
12077 PyThreadState* __tstate = wxPyBeginAllowThreads();
12078 result = (arg1)->FindNext();
12079 wxPyEndAllowThreads(__tstate);
12080 if (PyErr_Occurred()) SWIG_fail;
12081 }
12082 {
12083 #if wxUSE_UNICODE
12084 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12085 #else
12086 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12087 #endif
12088 }
12089 return resultobj;
12090 fail:
12091 return NULL;
12092 }
12093
12094
12095 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12096 PyObject *obj;
12097 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12098 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
12099 return SWIG_Py_Void();
12100 }
12101
12102 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12103 return SWIG_Python_InitShadowInstance(args);
12104 }
12105
12106 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12107 PyObject *resultobj = 0;
12108 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12109 wxString result;
12110 void *argp1 = 0 ;
12111 int res1 = 0 ;
12112 PyObject *swig_obj[1] ;
12113
12114 if (!args) SWIG_fail;
12115 swig_obj[0] = args;
12116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12117 if (!SWIG_IsOK(res1)) {
12118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12119 }
12120 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12121 {
12122 PyThreadState* __tstate = wxPyBeginAllowThreads();
12123 result = (arg1)->GetName();
12124 wxPyEndAllowThreads(__tstate);
12125 if (PyErr_Occurred()) SWIG_fail;
12126 }
12127 {
12128 #if wxUSE_UNICODE
12129 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12130 #else
12131 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12132 #endif
12133 }
12134 return resultobj;
12135 fail:
12136 return NULL;
12137 }
12138
12139
12140 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12141 PyObject *resultobj = 0;
12142 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12143 wxString result;
12144 void *argp1 = 0 ;
12145 int res1 = 0 ;
12146 PyObject *swig_obj[1] ;
12147
12148 if (!args) SWIG_fail;
12149 swig_obj[0] = args;
12150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12151 if (!SWIG_IsOK(res1)) {
12152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12153 }
12154 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12155 {
12156 PyThreadState* __tstate = wxPyBeginAllowThreads();
12157 result = (arg1)->GetExtension();
12158 wxPyEndAllowThreads(__tstate);
12159 if (PyErr_Occurred()) SWIG_fail;
12160 }
12161 {
12162 #if wxUSE_UNICODE
12163 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12164 #else
12165 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12166 #endif
12167 }
12168 return resultobj;
12169 fail:
12170 return NULL;
12171 }
12172
12173
12174 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12175 PyObject *resultobj = 0;
12176 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12177 long result;
12178 void *argp1 = 0 ;
12179 int res1 = 0 ;
12180 PyObject *swig_obj[1] ;
12181
12182 if (!args) SWIG_fail;
12183 swig_obj[0] = args;
12184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12185 if (!SWIG_IsOK(res1)) {
12186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12187 }
12188 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12189 {
12190 PyThreadState* __tstate = wxPyBeginAllowThreads();
12191 result = (long)(arg1)->GetType();
12192 wxPyEndAllowThreads(__tstate);
12193 if (PyErr_Occurred()) SWIG_fail;
12194 }
12195 resultobj = SWIG_From_long(static_cast< long >(result));
12196 return resultobj;
12197 fail:
12198 return NULL;
12199 }
12200
12201
12202 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12203 PyObject *resultobj = 0;
12204 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12205 wxString result;
12206 void *argp1 = 0 ;
12207 int res1 = 0 ;
12208 PyObject *swig_obj[1] ;
12209
12210 if (!args) SWIG_fail;
12211 swig_obj[0] = args;
12212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12213 if (!SWIG_IsOK(res1)) {
12214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12215 }
12216 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12217 {
12218 PyThreadState* __tstate = wxPyBeginAllowThreads();
12219 result = (arg1)->GetMimeType();
12220 wxPyEndAllowThreads(__tstate);
12221 if (PyErr_Occurred()) SWIG_fail;
12222 }
12223 {
12224 #if wxUSE_UNICODE
12225 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12226 #else
12227 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12228 #endif
12229 }
12230 return resultobj;
12231 fail:
12232 return NULL;
12233 }
12234
12235
12236 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12237 PyObject *resultobj = 0;
12238 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12239 wxString *arg2 = 0 ;
12240 bool result;
12241 void *argp1 = 0 ;
12242 int res1 = 0 ;
12243 bool temp2 = false ;
12244 PyObject * obj0 = 0 ;
12245 PyObject * obj1 = 0 ;
12246 char * kwnames[] = {
12247 (char *) "self",(char *) "name", NULL
12248 };
12249
12250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
12251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12252 if (!SWIG_IsOK(res1)) {
12253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12254 }
12255 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12256 {
12257 arg2 = wxString_in_helper(obj1);
12258 if (arg2 == NULL) SWIG_fail;
12259 temp2 = true;
12260 }
12261 {
12262 PyThreadState* __tstate = wxPyBeginAllowThreads();
12263 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
12264 wxPyEndAllowThreads(__tstate);
12265 if (PyErr_Occurred()) SWIG_fail;
12266 }
12267 {
12268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12269 }
12270 {
12271 if (temp2)
12272 delete arg2;
12273 }
12274 return resultobj;
12275 fail:
12276 {
12277 if (temp2)
12278 delete arg2;
12279 }
12280 return NULL;
12281 }
12282
12283
12284 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12285 PyObject *resultobj = 0;
12286 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12287 wxInputStream *arg2 = 0 ;
12288 bool result;
12289 void *argp1 = 0 ;
12290 int res1 = 0 ;
12291 wxPyInputStream *temp2 ;
12292 bool created2 ;
12293 PyObject * obj0 = 0 ;
12294 PyObject * obj1 = 0 ;
12295 char * kwnames[] = {
12296 (char *) "self",(char *) "stream", NULL
12297 };
12298
12299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
12300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12301 if (!SWIG_IsOK(res1)) {
12302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12303 }
12304 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12305 {
12306 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12307 arg2 = temp2->m_wxis;
12308 created2 = false;
12309 } else {
12310 PyErr_Clear(); // clear the failure of the wxPyConvert above
12311 arg2 = wxPyCBInputStream_create(obj1, false);
12312 if (arg2 == NULL) {
12313 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12314 SWIG_fail;
12315 }
12316 created2 = true;
12317 }
12318 }
12319 {
12320 PyThreadState* __tstate = wxPyBeginAllowThreads();
12321 result = (bool)(arg1)->CanRead(*arg2);
12322 wxPyEndAllowThreads(__tstate);
12323 if (PyErr_Occurred()) SWIG_fail;
12324 }
12325 {
12326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12327 }
12328 {
12329 if (created2) delete arg2;
12330 }
12331 return resultobj;
12332 fail:
12333 {
12334 if (created2) delete arg2;
12335 }
12336 return NULL;
12337 }
12338
12339
12340 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12341 PyObject *resultobj = 0;
12342 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12343 wxString *arg2 = 0 ;
12344 void *argp1 = 0 ;
12345 int res1 = 0 ;
12346 bool temp2 = false ;
12347 PyObject * obj0 = 0 ;
12348 PyObject * obj1 = 0 ;
12349 char * kwnames[] = {
12350 (char *) "self",(char *) "name", NULL
12351 };
12352
12353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12355 if (!SWIG_IsOK(res1)) {
12356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12357 }
12358 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12359 {
12360 arg2 = wxString_in_helper(obj1);
12361 if (arg2 == NULL) SWIG_fail;
12362 temp2 = true;
12363 }
12364 {
12365 PyThreadState* __tstate = wxPyBeginAllowThreads();
12366 (arg1)->SetName((wxString const &)*arg2);
12367 wxPyEndAllowThreads(__tstate);
12368 if (PyErr_Occurred()) SWIG_fail;
12369 }
12370 resultobj = SWIG_Py_Void();
12371 {
12372 if (temp2)
12373 delete arg2;
12374 }
12375 return resultobj;
12376 fail:
12377 {
12378 if (temp2)
12379 delete arg2;
12380 }
12381 return NULL;
12382 }
12383
12384
12385 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12386 PyObject *resultobj = 0;
12387 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12388 wxString *arg2 = 0 ;
12389 void *argp1 = 0 ;
12390 int res1 = 0 ;
12391 bool temp2 = false ;
12392 PyObject * obj0 = 0 ;
12393 PyObject * obj1 = 0 ;
12394 char * kwnames[] = {
12395 (char *) "self",(char *) "extension", NULL
12396 };
12397
12398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12400 if (!SWIG_IsOK(res1)) {
12401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12402 }
12403 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12404 {
12405 arg2 = wxString_in_helper(obj1);
12406 if (arg2 == NULL) SWIG_fail;
12407 temp2 = true;
12408 }
12409 {
12410 PyThreadState* __tstate = wxPyBeginAllowThreads();
12411 (arg1)->SetExtension((wxString const &)*arg2);
12412 wxPyEndAllowThreads(__tstate);
12413 if (PyErr_Occurred()) SWIG_fail;
12414 }
12415 resultobj = SWIG_Py_Void();
12416 {
12417 if (temp2)
12418 delete arg2;
12419 }
12420 return resultobj;
12421 fail:
12422 {
12423 if (temp2)
12424 delete arg2;
12425 }
12426 return NULL;
12427 }
12428
12429
12430 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12431 PyObject *resultobj = 0;
12432 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12433 long arg2 ;
12434 void *argp1 = 0 ;
12435 int res1 = 0 ;
12436 long val2 ;
12437 int ecode2 = 0 ;
12438 PyObject * obj0 = 0 ;
12439 PyObject * obj1 = 0 ;
12440 char * kwnames[] = {
12441 (char *) "self",(char *) "type", NULL
12442 };
12443
12444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12446 if (!SWIG_IsOK(res1)) {
12447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12448 }
12449 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12450 ecode2 = SWIG_AsVal_long(obj1, &val2);
12451 if (!SWIG_IsOK(ecode2)) {
12452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12453 }
12454 arg2 = static_cast< long >(val2);
12455 {
12456 PyThreadState* __tstate = wxPyBeginAllowThreads();
12457 (arg1)->SetType(arg2);
12458 wxPyEndAllowThreads(__tstate);
12459 if (PyErr_Occurred()) SWIG_fail;
12460 }
12461 resultobj = SWIG_Py_Void();
12462 return resultobj;
12463 fail:
12464 return NULL;
12465 }
12466
12467
12468 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12469 PyObject *resultobj = 0;
12470 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12471 wxString *arg2 = 0 ;
12472 void *argp1 = 0 ;
12473 int res1 = 0 ;
12474 bool temp2 = false ;
12475 PyObject * obj0 = 0 ;
12476 PyObject * obj1 = 0 ;
12477 char * kwnames[] = {
12478 (char *) "self",(char *) "mimetype", NULL
12479 };
12480
12481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12483 if (!SWIG_IsOK(res1)) {
12484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12485 }
12486 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12487 {
12488 arg2 = wxString_in_helper(obj1);
12489 if (arg2 == NULL) SWIG_fail;
12490 temp2 = true;
12491 }
12492 {
12493 PyThreadState* __tstate = wxPyBeginAllowThreads();
12494 (arg1)->SetMimeType((wxString const &)*arg2);
12495 wxPyEndAllowThreads(__tstate);
12496 if (PyErr_Occurred()) SWIG_fail;
12497 }
12498 resultobj = SWIG_Py_Void();
12499 {
12500 if (temp2)
12501 delete arg2;
12502 }
12503 return resultobj;
12504 fail:
12505 {
12506 if (temp2)
12507 delete arg2;
12508 }
12509 return NULL;
12510 }
12511
12512
12513 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12514 PyObject *obj;
12515 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12516 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12517 return SWIG_Py_Void();
12518 }
12519
12520 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12521 PyObject *resultobj = 0;
12522 wxPyImageHandler *result = 0 ;
12523
12524 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12525 {
12526 PyThreadState* __tstate = wxPyBeginAllowThreads();
12527 result = (wxPyImageHandler *)new wxPyImageHandler();
12528 wxPyEndAllowThreads(__tstate);
12529 if (PyErr_Occurred()) SWIG_fail;
12530 }
12531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12532 return resultobj;
12533 fail:
12534 return NULL;
12535 }
12536
12537
12538 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12539 PyObject *resultobj = 0;
12540 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12541 PyObject *arg2 = (PyObject *) 0 ;
12542 void *argp1 = 0 ;
12543 int res1 = 0 ;
12544 PyObject * obj0 = 0 ;
12545 PyObject * obj1 = 0 ;
12546 char * kwnames[] = {
12547 (char *) "self",(char *) "self", NULL
12548 };
12549
12550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12552 if (!SWIG_IsOK(res1)) {
12553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12554 }
12555 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12556 arg2 = obj1;
12557 {
12558 PyThreadState* __tstate = wxPyBeginAllowThreads();
12559 (arg1)->_SetSelf(arg2);
12560 wxPyEndAllowThreads(__tstate);
12561 if (PyErr_Occurred()) SWIG_fail;
12562 }
12563 resultobj = SWIG_Py_Void();
12564 return resultobj;
12565 fail:
12566 return NULL;
12567 }
12568
12569
12570 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12571 PyObject *obj;
12572 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12573 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12574 return SWIG_Py_Void();
12575 }
12576
12577 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12578 return SWIG_Python_InitShadowInstance(args);
12579 }
12580
12581 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12582 PyObject *resultobj = 0;
12583 wxImageHistogram *result = 0 ;
12584
12585 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12586 {
12587 PyThreadState* __tstate = wxPyBeginAllowThreads();
12588 result = (wxImageHistogram *)new wxImageHistogram();
12589 wxPyEndAllowThreads(__tstate);
12590 if (PyErr_Occurred()) SWIG_fail;
12591 }
12592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12593 return resultobj;
12594 fail:
12595 return NULL;
12596 }
12597
12598
12599 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12600 PyObject *resultobj = 0;
12601 byte arg1 ;
12602 byte arg2 ;
12603 byte arg3 ;
12604 unsigned long result;
12605 unsigned char val1 ;
12606 int ecode1 = 0 ;
12607 unsigned char val2 ;
12608 int ecode2 = 0 ;
12609 unsigned char val3 ;
12610 int ecode3 = 0 ;
12611 PyObject * obj0 = 0 ;
12612 PyObject * obj1 = 0 ;
12613 PyObject * obj2 = 0 ;
12614 char * kwnames[] = {
12615 (char *) "r",(char *) "g",(char *) "b", NULL
12616 };
12617
12618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12619 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12620 if (!SWIG_IsOK(ecode1)) {
12621 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12622 }
12623 arg1 = static_cast< byte >(val1);
12624 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12625 if (!SWIG_IsOK(ecode2)) {
12626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12627 }
12628 arg2 = static_cast< byte >(val2);
12629 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12630 if (!SWIG_IsOK(ecode3)) {
12631 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12632 }
12633 arg3 = static_cast< byte >(val3);
12634 {
12635 PyThreadState* __tstate = wxPyBeginAllowThreads();
12636 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12637 wxPyEndAllowThreads(__tstate);
12638 if (PyErr_Occurred()) SWIG_fail;
12639 }
12640 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12641 return resultobj;
12642 fail:
12643 return NULL;
12644 }
12645
12646
12647 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12648 PyObject *resultobj = 0;
12649 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12650 byte *arg2 = (byte *) 0 ;
12651 byte *arg3 = (byte *) 0 ;
12652 byte *arg4 = (byte *) 0 ;
12653 byte arg5 = (byte) 1 ;
12654 byte arg6 = (byte) 0 ;
12655 byte arg7 = (byte) 0 ;
12656 bool result;
12657 void *argp1 = 0 ;
12658 int res1 = 0 ;
12659 byte temp2 ;
12660 int res2 = SWIG_TMPOBJ ;
12661 byte temp3 ;
12662 int res3 = SWIG_TMPOBJ ;
12663 byte temp4 ;
12664 int res4 = SWIG_TMPOBJ ;
12665 unsigned char val5 ;
12666 int ecode5 = 0 ;
12667 unsigned char val6 ;
12668 int ecode6 = 0 ;
12669 unsigned char val7 ;
12670 int ecode7 = 0 ;
12671 PyObject * obj0 = 0 ;
12672 PyObject * obj1 = 0 ;
12673 PyObject * obj2 = 0 ;
12674 PyObject * obj3 = 0 ;
12675 char * kwnames[] = {
12676 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12677 };
12678
12679 arg2 = &temp2;
12680 arg3 = &temp3;
12681 arg4 = &temp4;
12682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12684 if (!SWIG_IsOK(res1)) {
12685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12686 }
12687 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12688 if (obj1) {
12689 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12690 if (!SWIG_IsOK(ecode5)) {
12691 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12692 }
12693 arg5 = static_cast< byte >(val5);
12694 }
12695 if (obj2) {
12696 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12697 if (!SWIG_IsOK(ecode6)) {
12698 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12699 }
12700 arg6 = static_cast< byte >(val6);
12701 }
12702 if (obj3) {
12703 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12704 if (!SWIG_IsOK(ecode7)) {
12705 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12706 }
12707 arg7 = static_cast< byte >(val7);
12708 }
12709 {
12710 PyThreadState* __tstate = wxPyBeginAllowThreads();
12711 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12712 wxPyEndAllowThreads(__tstate);
12713 if (PyErr_Occurred()) SWIG_fail;
12714 }
12715 {
12716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12717 }
12718 if (SWIG_IsTmpObj(res2)) {
12719 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12720 } else {
12721 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12722 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12723 }
12724 if (SWIG_IsTmpObj(res3)) {
12725 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12726 } else {
12727 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12728 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12729 }
12730 if (SWIG_IsTmpObj(res4)) {
12731 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12732 } else {
12733 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12734 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12735 }
12736 return resultobj;
12737 fail:
12738 return NULL;
12739 }
12740
12741
12742 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12743 PyObject *resultobj = 0;
12744 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12745 unsigned long arg2 ;
12746 unsigned long result;
12747 void *argp1 = 0 ;
12748 int res1 = 0 ;
12749 unsigned long val2 ;
12750 int ecode2 = 0 ;
12751 PyObject * obj0 = 0 ;
12752 PyObject * obj1 = 0 ;
12753 char * kwnames[] = {
12754 (char *) "self",(char *) "key", NULL
12755 };
12756
12757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12759 if (!SWIG_IsOK(res1)) {
12760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12761 }
12762 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12763 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12764 if (!SWIG_IsOK(ecode2)) {
12765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12766 }
12767 arg2 = static_cast< unsigned long >(val2);
12768 {
12769 PyThreadState* __tstate = wxPyBeginAllowThreads();
12770 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12771 wxPyEndAllowThreads(__tstate);
12772 if (PyErr_Occurred()) SWIG_fail;
12773 }
12774 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12775 return resultobj;
12776 fail:
12777 return NULL;
12778 }
12779
12780
12781 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12782 PyObject *resultobj = 0;
12783 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12784 byte arg2 ;
12785 byte arg3 ;
12786 byte arg4 ;
12787 unsigned long result;
12788 void *argp1 = 0 ;
12789 int res1 = 0 ;
12790 unsigned char val2 ;
12791 int ecode2 = 0 ;
12792 unsigned char val3 ;
12793 int ecode3 = 0 ;
12794 unsigned char val4 ;
12795 int ecode4 = 0 ;
12796 PyObject * obj0 = 0 ;
12797 PyObject * obj1 = 0 ;
12798 PyObject * obj2 = 0 ;
12799 PyObject * obj3 = 0 ;
12800 char * kwnames[] = {
12801 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12802 };
12803
12804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12806 if (!SWIG_IsOK(res1)) {
12807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12808 }
12809 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12810 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12811 if (!SWIG_IsOK(ecode2)) {
12812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12813 }
12814 arg2 = static_cast< byte >(val2);
12815 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12816 if (!SWIG_IsOK(ecode3)) {
12817 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12818 }
12819 arg3 = static_cast< byte >(val3);
12820 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12821 if (!SWIG_IsOK(ecode4)) {
12822 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12823 }
12824 arg4 = static_cast< byte >(val4);
12825 {
12826 PyThreadState* __tstate = wxPyBeginAllowThreads();
12827 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12828 wxPyEndAllowThreads(__tstate);
12829 if (PyErr_Occurred()) SWIG_fail;
12830 }
12831 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12832 return resultobj;
12833 fail:
12834 return NULL;
12835 }
12836
12837
12838 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12839 PyObject *resultobj = 0;
12840 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12841 wxColour *arg2 = 0 ;
12842 unsigned long result;
12843 void *argp1 = 0 ;
12844 int res1 = 0 ;
12845 wxColour temp2 ;
12846 PyObject * obj0 = 0 ;
12847 PyObject * obj1 = 0 ;
12848 char * kwnames[] = {
12849 (char *) "self",(char *) "colour", NULL
12850 };
12851
12852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12854 if (!SWIG_IsOK(res1)) {
12855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12856 }
12857 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12858 {
12859 arg2 = &temp2;
12860 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12861 }
12862 {
12863 PyThreadState* __tstate = wxPyBeginAllowThreads();
12864 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12865 wxPyEndAllowThreads(__tstate);
12866 if (PyErr_Occurred()) SWIG_fail;
12867 }
12868 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12869 return resultobj;
12870 fail:
12871 return NULL;
12872 }
12873
12874
12875 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12876 PyObject *obj;
12877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12878 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12879 return SWIG_Py_Void();
12880 }
12881
12882 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12883 return SWIG_Python_InitShadowInstance(args);
12884 }
12885
12886 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12887 PyObject *resultobj = 0;
12888 byte arg1 = (byte) 0 ;
12889 byte arg2 = (byte) 0 ;
12890 byte arg3 = (byte) 0 ;
12891 wxImage_RGBValue *result = 0 ;
12892 unsigned char val1 ;
12893 int ecode1 = 0 ;
12894 unsigned char val2 ;
12895 int ecode2 = 0 ;
12896 unsigned char val3 ;
12897 int ecode3 = 0 ;
12898 PyObject * obj0 = 0 ;
12899 PyObject * obj1 = 0 ;
12900 PyObject * obj2 = 0 ;
12901 char * kwnames[] = {
12902 (char *) "r",(char *) "g",(char *) "b", NULL
12903 };
12904
12905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12906 if (obj0) {
12907 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12908 if (!SWIG_IsOK(ecode1)) {
12909 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12910 }
12911 arg1 = static_cast< byte >(val1);
12912 }
12913 if (obj1) {
12914 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12915 if (!SWIG_IsOK(ecode2)) {
12916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12917 }
12918 arg2 = static_cast< byte >(val2);
12919 }
12920 if (obj2) {
12921 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12922 if (!SWIG_IsOK(ecode3)) {
12923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12924 }
12925 arg3 = static_cast< byte >(val3);
12926 }
12927 {
12928 PyThreadState* __tstate = wxPyBeginAllowThreads();
12929 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12930 wxPyEndAllowThreads(__tstate);
12931 if (PyErr_Occurred()) SWIG_fail;
12932 }
12933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12934 return resultobj;
12935 fail:
12936 return NULL;
12937 }
12938
12939
12940 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12941 PyObject *resultobj = 0;
12942 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12943 byte arg2 ;
12944 void *argp1 = 0 ;
12945 int res1 = 0 ;
12946 unsigned char val2 ;
12947 int ecode2 = 0 ;
12948 PyObject *swig_obj[2] ;
12949
12950 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12952 if (!SWIG_IsOK(res1)) {
12953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12954 }
12955 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12956 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12957 if (!SWIG_IsOK(ecode2)) {
12958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12959 }
12960 arg2 = static_cast< byte >(val2);
12961 if (arg1) (arg1)->red = arg2;
12962
12963 resultobj = SWIG_Py_Void();
12964 return resultobj;
12965 fail:
12966 return NULL;
12967 }
12968
12969
12970 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12971 PyObject *resultobj = 0;
12972 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12973 byte result;
12974 void *argp1 = 0 ;
12975 int res1 = 0 ;
12976 PyObject *swig_obj[1] ;
12977
12978 if (!args) SWIG_fail;
12979 swig_obj[0] = args;
12980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12981 if (!SWIG_IsOK(res1)) {
12982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12983 }
12984 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12985 result = (byte) ((arg1)->red);
12986 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12987 return resultobj;
12988 fail:
12989 return NULL;
12990 }
12991
12992
12993 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12994 PyObject *resultobj = 0;
12995 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12996 byte arg2 ;
12997 void *argp1 = 0 ;
12998 int res1 = 0 ;
12999 unsigned char val2 ;
13000 int ecode2 = 0 ;
13001 PyObject *swig_obj[2] ;
13002
13003 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
13004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13005 if (!SWIG_IsOK(res1)) {
13006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13007 }
13008 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13009 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
13010 if (!SWIG_IsOK(ecode2)) {
13011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
13012 }
13013 arg2 = static_cast< byte >(val2);
13014 if (arg1) (arg1)->green = arg2;
13015
13016 resultobj = SWIG_Py_Void();
13017 return resultobj;
13018 fail:
13019 return NULL;
13020 }
13021
13022
13023 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13024 PyObject *resultobj = 0;
13025 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13026 byte result;
13027 void *argp1 = 0 ;
13028 int res1 = 0 ;
13029 PyObject *swig_obj[1] ;
13030
13031 if (!args) SWIG_fail;
13032 swig_obj[0] = args;
13033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13034 if (!SWIG_IsOK(res1)) {
13035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13036 }
13037 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13038 result = (byte) ((arg1)->green);
13039 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13040 return resultobj;
13041 fail:
13042 return NULL;
13043 }
13044
13045
13046 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13047 PyObject *resultobj = 0;
13048 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13049 byte arg2 ;
13050 void *argp1 = 0 ;
13051 int res1 = 0 ;
13052 unsigned char val2 ;
13053 int ecode2 = 0 ;
13054 PyObject *swig_obj[2] ;
13055
13056 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
13057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13058 if (!SWIG_IsOK(res1)) {
13059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13060 }
13061 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13062 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
13063 if (!SWIG_IsOK(ecode2)) {
13064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
13065 }
13066 arg2 = static_cast< byte >(val2);
13067 if (arg1) (arg1)->blue = arg2;
13068
13069 resultobj = SWIG_Py_Void();
13070 return resultobj;
13071 fail:
13072 return NULL;
13073 }
13074
13075
13076 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13077 PyObject *resultobj = 0;
13078 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13079 byte result;
13080 void *argp1 = 0 ;
13081 int res1 = 0 ;
13082 PyObject *swig_obj[1] ;
13083
13084 if (!args) SWIG_fail;
13085 swig_obj[0] = args;
13086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13087 if (!SWIG_IsOK(res1)) {
13088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13089 }
13090 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13091 result = (byte) ((arg1)->blue);
13092 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13093 return resultobj;
13094 fail:
13095 return NULL;
13096 }
13097
13098
13099 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13100 PyObject *obj;
13101 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13102 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
13103 return SWIG_Py_Void();
13104 }
13105
13106 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13107 return SWIG_Python_InitShadowInstance(args);
13108 }
13109
13110 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13111 PyObject *resultobj = 0;
13112 double arg1 = (double) 0.0 ;
13113 double arg2 = (double) 0.0 ;
13114 double arg3 = (double) 0.0 ;
13115 wxImage_HSVValue *result = 0 ;
13116 double val1 ;
13117 int ecode1 = 0 ;
13118 double val2 ;
13119 int ecode2 = 0 ;
13120 double val3 ;
13121 int ecode3 = 0 ;
13122 PyObject * obj0 = 0 ;
13123 PyObject * obj1 = 0 ;
13124 PyObject * obj2 = 0 ;
13125 char * kwnames[] = {
13126 (char *) "h",(char *) "s",(char *) "v", NULL
13127 };
13128
13129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13130 if (obj0) {
13131 ecode1 = SWIG_AsVal_double(obj0, &val1);
13132 if (!SWIG_IsOK(ecode1)) {
13133 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
13134 }
13135 arg1 = static_cast< double >(val1);
13136 }
13137 if (obj1) {
13138 ecode2 = SWIG_AsVal_double(obj1, &val2);
13139 if (!SWIG_IsOK(ecode2)) {
13140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
13141 }
13142 arg2 = static_cast< double >(val2);
13143 }
13144 if (obj2) {
13145 ecode3 = SWIG_AsVal_double(obj2, &val3);
13146 if (!SWIG_IsOK(ecode3)) {
13147 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
13148 }
13149 arg3 = static_cast< double >(val3);
13150 }
13151 {
13152 PyThreadState* __tstate = wxPyBeginAllowThreads();
13153 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
13154 wxPyEndAllowThreads(__tstate);
13155 if (PyErr_Occurred()) SWIG_fail;
13156 }
13157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
13158 return resultobj;
13159 fail:
13160 return NULL;
13161 }
13162
13163
13164 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13165 PyObject *resultobj = 0;
13166 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13167 double arg2 ;
13168 void *argp1 = 0 ;
13169 int res1 = 0 ;
13170 double val2 ;
13171 int ecode2 = 0 ;
13172 PyObject *swig_obj[2] ;
13173
13174 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
13175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13176 if (!SWIG_IsOK(res1)) {
13177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13178 }
13179 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13180 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13181 if (!SWIG_IsOK(ecode2)) {
13182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
13183 }
13184 arg2 = static_cast< double >(val2);
13185 if (arg1) (arg1)->hue = arg2;
13186
13187 resultobj = SWIG_Py_Void();
13188 return resultobj;
13189 fail:
13190 return NULL;
13191 }
13192
13193
13194 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13195 PyObject *resultobj = 0;
13196 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13197 double result;
13198 void *argp1 = 0 ;
13199 int res1 = 0 ;
13200 PyObject *swig_obj[1] ;
13201
13202 if (!args) SWIG_fail;
13203 swig_obj[0] = args;
13204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13205 if (!SWIG_IsOK(res1)) {
13206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13207 }
13208 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13209 result = (double) ((arg1)->hue);
13210 resultobj = SWIG_From_double(static_cast< double >(result));
13211 return resultobj;
13212 fail:
13213 return NULL;
13214 }
13215
13216
13217 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13218 PyObject *resultobj = 0;
13219 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13220 double arg2 ;
13221 void *argp1 = 0 ;
13222 int res1 = 0 ;
13223 double val2 ;
13224 int ecode2 = 0 ;
13225 PyObject *swig_obj[2] ;
13226
13227 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
13228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13229 if (!SWIG_IsOK(res1)) {
13230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13231 }
13232 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13233 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13234 if (!SWIG_IsOK(ecode2)) {
13235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
13236 }
13237 arg2 = static_cast< double >(val2);
13238 if (arg1) (arg1)->saturation = arg2;
13239
13240 resultobj = SWIG_Py_Void();
13241 return resultobj;
13242 fail:
13243 return NULL;
13244 }
13245
13246
13247 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13248 PyObject *resultobj = 0;
13249 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13250 double result;
13251 void *argp1 = 0 ;
13252 int res1 = 0 ;
13253 PyObject *swig_obj[1] ;
13254
13255 if (!args) SWIG_fail;
13256 swig_obj[0] = args;
13257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13258 if (!SWIG_IsOK(res1)) {
13259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13260 }
13261 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13262 result = (double) ((arg1)->saturation);
13263 resultobj = SWIG_From_double(static_cast< double >(result));
13264 return resultobj;
13265 fail:
13266 return NULL;
13267 }
13268
13269
13270 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13271 PyObject *resultobj = 0;
13272 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13273 double arg2 ;
13274 void *argp1 = 0 ;
13275 int res1 = 0 ;
13276 double val2 ;
13277 int ecode2 = 0 ;
13278 PyObject *swig_obj[2] ;
13279
13280 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
13281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13282 if (!SWIG_IsOK(res1)) {
13283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13284 }
13285 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13286 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13287 if (!SWIG_IsOK(ecode2)) {
13288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
13289 }
13290 arg2 = static_cast< double >(val2);
13291 if (arg1) (arg1)->value = arg2;
13292
13293 resultobj = SWIG_Py_Void();
13294 return resultobj;
13295 fail:
13296 return NULL;
13297 }
13298
13299
13300 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13301 PyObject *resultobj = 0;
13302 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13303 double result;
13304 void *argp1 = 0 ;
13305 int res1 = 0 ;
13306 PyObject *swig_obj[1] ;
13307
13308 if (!args) SWIG_fail;
13309 swig_obj[0] = args;
13310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13311 if (!SWIG_IsOK(res1)) {
13312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13313 }
13314 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13315 result = (double) ((arg1)->value);
13316 resultobj = SWIG_From_double(static_cast< double >(result));
13317 return resultobj;
13318 fail:
13319 return NULL;
13320 }
13321
13322
13323 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13324 PyObject *obj;
13325 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13326 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13327 return SWIG_Py_Void();
13328 }
13329
13330 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13331 return SWIG_Python_InitShadowInstance(args);
13332 }
13333
13334 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13335 PyObject *resultobj = 0;
13336 wxString *arg1 = 0 ;
13337 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13338 int arg3 = (int) -1 ;
13339 wxImage *result = 0 ;
13340 bool temp1 = false ;
13341 long val2 ;
13342 int ecode2 = 0 ;
13343 int val3 ;
13344 int ecode3 = 0 ;
13345 PyObject * obj0 = 0 ;
13346 PyObject * obj1 = 0 ;
13347 PyObject * obj2 = 0 ;
13348 char * kwnames[] = {
13349 (char *) "name",(char *) "type",(char *) "index", NULL
13350 };
13351
13352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13353 {
13354 arg1 = wxString_in_helper(obj0);
13355 if (arg1 == NULL) SWIG_fail;
13356 temp1 = true;
13357 }
13358 if (obj1) {
13359 ecode2 = SWIG_AsVal_long(obj1, &val2);
13360 if (!SWIG_IsOK(ecode2)) {
13361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13362 }
13363 arg2 = static_cast< long >(val2);
13364 }
13365 if (obj2) {
13366 ecode3 = SWIG_AsVal_int(obj2, &val3);
13367 if (!SWIG_IsOK(ecode3)) {
13368 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13369 }
13370 arg3 = static_cast< int >(val3);
13371 }
13372 {
13373 PyThreadState* __tstate = wxPyBeginAllowThreads();
13374 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13375 wxPyEndAllowThreads(__tstate);
13376 if (PyErr_Occurred()) SWIG_fail;
13377 }
13378 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13379 {
13380 if (temp1)
13381 delete arg1;
13382 }
13383 return resultobj;
13384 fail:
13385 {
13386 if (temp1)
13387 delete arg1;
13388 }
13389 return NULL;
13390 }
13391
13392
13393 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13394 PyObject *resultobj = 0;
13395 wxImage *arg1 = (wxImage *) 0 ;
13396 void *argp1 = 0 ;
13397 int res1 = 0 ;
13398 PyObject *swig_obj[1] ;
13399
13400 if (!args) SWIG_fail;
13401 swig_obj[0] = args;
13402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13403 if (!SWIG_IsOK(res1)) {
13404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13405 }
13406 arg1 = reinterpret_cast< wxImage * >(argp1);
13407 {
13408 PyThreadState* __tstate = wxPyBeginAllowThreads();
13409 delete arg1;
13410
13411 wxPyEndAllowThreads(__tstate);
13412 if (PyErr_Occurred()) SWIG_fail;
13413 }
13414 resultobj = SWIG_Py_Void();
13415 return resultobj;
13416 fail:
13417 return NULL;
13418 }
13419
13420
13421 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13422 PyObject *resultobj = 0;
13423 wxString *arg1 = 0 ;
13424 wxString *arg2 = 0 ;
13425 int arg3 = (int) -1 ;
13426 wxImage *result = 0 ;
13427 bool temp1 = false ;
13428 bool temp2 = false ;
13429 int val3 ;
13430 int ecode3 = 0 ;
13431 PyObject * obj0 = 0 ;
13432 PyObject * obj1 = 0 ;
13433 PyObject * obj2 = 0 ;
13434 char * kwnames[] = {
13435 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13436 };
13437
13438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13439 {
13440 arg1 = wxString_in_helper(obj0);
13441 if (arg1 == NULL) SWIG_fail;
13442 temp1 = true;
13443 }
13444 {
13445 arg2 = wxString_in_helper(obj1);
13446 if (arg2 == NULL) SWIG_fail;
13447 temp2 = true;
13448 }
13449 if (obj2) {
13450 ecode3 = SWIG_AsVal_int(obj2, &val3);
13451 if (!SWIG_IsOK(ecode3)) {
13452 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13453 }
13454 arg3 = static_cast< int >(val3);
13455 }
13456 {
13457 PyThreadState* __tstate = wxPyBeginAllowThreads();
13458 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13459 wxPyEndAllowThreads(__tstate);
13460 if (PyErr_Occurred()) SWIG_fail;
13461 }
13462 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13463 {
13464 if (temp1)
13465 delete arg1;
13466 }
13467 {
13468 if (temp2)
13469 delete arg2;
13470 }
13471 return resultobj;
13472 fail:
13473 {
13474 if (temp1)
13475 delete arg1;
13476 }
13477 {
13478 if (temp2)
13479 delete arg2;
13480 }
13481 return NULL;
13482 }
13483
13484
13485 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13486 PyObject *resultobj = 0;
13487 wxInputStream *arg1 = 0 ;
13488 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13489 int arg3 = (int) -1 ;
13490 wxImage *result = 0 ;
13491 wxPyInputStream *temp1 ;
13492 bool created1 ;
13493 long val2 ;
13494 int ecode2 = 0 ;
13495 int val3 ;
13496 int ecode3 = 0 ;
13497 PyObject * obj0 = 0 ;
13498 PyObject * obj1 = 0 ;
13499 PyObject * obj2 = 0 ;
13500 char * kwnames[] = {
13501 (char *) "stream",(char *) "type",(char *) "index", NULL
13502 };
13503
13504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13505 {
13506 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13507 arg1 = temp1->m_wxis;
13508 created1 = false;
13509 } else {
13510 PyErr_Clear(); // clear the failure of the wxPyConvert above
13511 arg1 = wxPyCBInputStream_create(obj0, false);
13512 if (arg1 == NULL) {
13513 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13514 SWIG_fail;
13515 }
13516 created1 = true;
13517 }
13518 }
13519 if (obj1) {
13520 ecode2 = SWIG_AsVal_long(obj1, &val2);
13521 if (!SWIG_IsOK(ecode2)) {
13522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13523 }
13524 arg2 = static_cast< long >(val2);
13525 }
13526 if (obj2) {
13527 ecode3 = SWIG_AsVal_int(obj2, &val3);
13528 if (!SWIG_IsOK(ecode3)) {
13529 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13530 }
13531 arg3 = static_cast< int >(val3);
13532 }
13533 {
13534 PyThreadState* __tstate = wxPyBeginAllowThreads();
13535 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13536 wxPyEndAllowThreads(__tstate);
13537 if (PyErr_Occurred()) SWIG_fail;
13538 }
13539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13540 {
13541 if (created1) delete arg1;
13542 }
13543 return resultobj;
13544 fail:
13545 {
13546 if (created1) delete arg1;
13547 }
13548 return NULL;
13549 }
13550
13551
13552 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13553 PyObject *resultobj = 0;
13554 wxInputStream *arg1 = 0 ;
13555 wxString *arg2 = 0 ;
13556 int arg3 = (int) -1 ;
13557 wxImage *result = 0 ;
13558 wxPyInputStream *temp1 ;
13559 bool created1 ;
13560 bool temp2 = false ;
13561 int val3 ;
13562 int ecode3 = 0 ;
13563 PyObject * obj0 = 0 ;
13564 PyObject * obj1 = 0 ;
13565 PyObject * obj2 = 0 ;
13566 char * kwnames[] = {
13567 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13568 };
13569
13570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13571 {
13572 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13573 arg1 = temp1->m_wxis;
13574 created1 = false;
13575 } else {
13576 PyErr_Clear(); // clear the failure of the wxPyConvert above
13577 arg1 = wxPyCBInputStream_create(obj0, false);
13578 if (arg1 == NULL) {
13579 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13580 SWIG_fail;
13581 }
13582 created1 = true;
13583 }
13584 }
13585 {
13586 arg2 = wxString_in_helper(obj1);
13587 if (arg2 == NULL) SWIG_fail;
13588 temp2 = true;
13589 }
13590 if (obj2) {
13591 ecode3 = SWIG_AsVal_int(obj2, &val3);
13592 if (!SWIG_IsOK(ecode3)) {
13593 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13594 }
13595 arg3 = static_cast< int >(val3);
13596 }
13597 {
13598 PyThreadState* __tstate = wxPyBeginAllowThreads();
13599 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13600 wxPyEndAllowThreads(__tstate);
13601 if (PyErr_Occurred()) SWIG_fail;
13602 }
13603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13604 {
13605 if (created1) delete arg1;
13606 }
13607 {
13608 if (temp2)
13609 delete arg2;
13610 }
13611 return resultobj;
13612 fail:
13613 {
13614 if (created1) delete arg1;
13615 }
13616 {
13617 if (temp2)
13618 delete arg2;
13619 }
13620 return NULL;
13621 }
13622
13623
13624 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13625 PyObject *resultobj = 0;
13626 int arg1 = (int) 0 ;
13627 int arg2 = (int) 0 ;
13628 bool arg3 = (bool) true ;
13629 wxImage *result = 0 ;
13630 int val1 ;
13631 int ecode1 = 0 ;
13632 int val2 ;
13633 int ecode2 = 0 ;
13634 bool val3 ;
13635 int ecode3 = 0 ;
13636 PyObject * obj0 = 0 ;
13637 PyObject * obj1 = 0 ;
13638 PyObject * obj2 = 0 ;
13639 char * kwnames[] = {
13640 (char *) "width",(char *) "height",(char *) "clear", NULL
13641 };
13642
13643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13644 if (obj0) {
13645 ecode1 = SWIG_AsVal_int(obj0, &val1);
13646 if (!SWIG_IsOK(ecode1)) {
13647 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13648 }
13649 arg1 = static_cast< int >(val1);
13650 }
13651 if (obj1) {
13652 ecode2 = SWIG_AsVal_int(obj1, &val2);
13653 if (!SWIG_IsOK(ecode2)) {
13654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13655 }
13656 arg2 = static_cast< int >(val2);
13657 }
13658 if (obj2) {
13659 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13660 if (!SWIG_IsOK(ecode3)) {
13661 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13662 }
13663 arg3 = static_cast< bool >(val3);
13664 }
13665 {
13666 PyThreadState* __tstate = wxPyBeginAllowThreads();
13667 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13668 wxPyEndAllowThreads(__tstate);
13669 if (PyErr_Occurred()) SWIG_fail;
13670 }
13671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13672 return resultobj;
13673 fail:
13674 return NULL;
13675 }
13676
13677
13678 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13679 PyObject *resultobj = 0;
13680 wxBitmap *arg1 = 0 ;
13681 wxImage *result = 0 ;
13682 void *argp1 = 0 ;
13683 int res1 = 0 ;
13684 PyObject * obj0 = 0 ;
13685 char * kwnames[] = {
13686 (char *) "bitmap", NULL
13687 };
13688
13689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13690 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13691 if (!SWIG_IsOK(res1)) {
13692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13693 }
13694 if (!argp1) {
13695 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13696 }
13697 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13698 {
13699 if (!wxPyCheckForApp()) SWIG_fail;
13700 PyThreadState* __tstate = wxPyBeginAllowThreads();
13701 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13702 wxPyEndAllowThreads(__tstate);
13703 if (PyErr_Occurred()) SWIG_fail;
13704 }
13705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13706 return resultobj;
13707 fail:
13708 return NULL;
13709 }
13710
13711
13712 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13713 PyObject *resultobj = 0;
13714 int arg1 ;
13715 int arg2 ;
13716 buffer arg3 ;
13717 int arg4 ;
13718 wxImage *result = 0 ;
13719 int val1 ;
13720 int ecode1 = 0 ;
13721 int val2 ;
13722 int ecode2 = 0 ;
13723 Py_ssize_t temp3 ;
13724 PyObject * obj0 = 0 ;
13725 PyObject * obj1 = 0 ;
13726 PyObject * obj2 = 0 ;
13727 char * kwnames[] = {
13728 (char *) "width",(char *) "height",(char *) "data", NULL
13729 };
13730
13731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13732 ecode1 = SWIG_AsVal_int(obj0, &val1);
13733 if (!SWIG_IsOK(ecode1)) {
13734 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13735 }
13736 arg1 = static_cast< int >(val1);
13737 ecode2 = SWIG_AsVal_int(obj1, &val2);
13738 if (!SWIG_IsOK(ecode2)) {
13739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13740 }
13741 arg2 = static_cast< int >(val2);
13742 {
13743 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13744 arg4 = (int)temp3;
13745 }
13746 {
13747 PyThreadState* __tstate = wxPyBeginAllowThreads();
13748 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13749 wxPyEndAllowThreads(__tstate);
13750 if (PyErr_Occurred()) SWIG_fail;
13751 }
13752 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13753 return resultobj;
13754 fail:
13755 return NULL;
13756 }
13757
13758
13759 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13760 PyObject *resultobj = 0;
13761 int arg1 ;
13762 int arg2 ;
13763 buffer arg3 ;
13764 int arg4 ;
13765 buffer arg5 ;
13766 int arg6 ;
13767 wxImage *result = 0 ;
13768 int val1 ;
13769 int ecode1 = 0 ;
13770 int val2 ;
13771 int ecode2 = 0 ;
13772 Py_ssize_t temp3 ;
13773 Py_ssize_t temp5 ;
13774 PyObject * obj0 = 0 ;
13775 PyObject * obj1 = 0 ;
13776 PyObject * obj2 = 0 ;
13777 PyObject * obj3 = 0 ;
13778 char * kwnames[] = {
13779 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13780 };
13781
13782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13783 ecode1 = SWIG_AsVal_int(obj0, &val1);
13784 if (!SWIG_IsOK(ecode1)) {
13785 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13786 }
13787 arg1 = static_cast< int >(val1);
13788 ecode2 = SWIG_AsVal_int(obj1, &val2);
13789 if (!SWIG_IsOK(ecode2)) {
13790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13791 }
13792 arg2 = static_cast< int >(val2);
13793 {
13794 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13795 arg4 = (int)temp3;
13796 }
13797 {
13798 if (obj3 != Py_None) {
13799 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13800 arg6 = (int)temp5;
13801 }
13802 }
13803 {
13804 PyThreadState* __tstate = wxPyBeginAllowThreads();
13805 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13806 wxPyEndAllowThreads(__tstate);
13807 if (PyErr_Occurred()) SWIG_fail;
13808 }
13809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13810 return resultobj;
13811 fail:
13812 return NULL;
13813 }
13814
13815
13816 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13817 PyObject *resultobj = 0;
13818 wxImage *arg1 = (wxImage *) 0 ;
13819 int arg2 ;
13820 int arg3 ;
13821 bool arg4 = (bool) true ;
13822 void *argp1 = 0 ;
13823 int res1 = 0 ;
13824 int val2 ;
13825 int ecode2 = 0 ;
13826 int val3 ;
13827 int ecode3 = 0 ;
13828 bool val4 ;
13829 int ecode4 = 0 ;
13830 PyObject * obj0 = 0 ;
13831 PyObject * obj1 = 0 ;
13832 PyObject * obj2 = 0 ;
13833 PyObject * obj3 = 0 ;
13834 char * kwnames[] = {
13835 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13836 };
13837
13838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13840 if (!SWIG_IsOK(res1)) {
13841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13842 }
13843 arg1 = reinterpret_cast< wxImage * >(argp1);
13844 ecode2 = SWIG_AsVal_int(obj1, &val2);
13845 if (!SWIG_IsOK(ecode2)) {
13846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13847 }
13848 arg2 = static_cast< int >(val2);
13849 ecode3 = SWIG_AsVal_int(obj2, &val3);
13850 if (!SWIG_IsOK(ecode3)) {
13851 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13852 }
13853 arg3 = static_cast< int >(val3);
13854 if (obj3) {
13855 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13856 if (!SWIG_IsOK(ecode4)) {
13857 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13858 }
13859 arg4 = static_cast< bool >(val4);
13860 }
13861 {
13862 PyThreadState* __tstate = wxPyBeginAllowThreads();
13863 (arg1)->Create(arg2,arg3,arg4);
13864 wxPyEndAllowThreads(__tstate);
13865 if (PyErr_Occurred()) SWIG_fail;
13866 }
13867 resultobj = SWIG_Py_Void();
13868 return resultobj;
13869 fail:
13870 return NULL;
13871 }
13872
13873
13874 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13875 PyObject *resultobj = 0;
13876 wxImage *arg1 = (wxImage *) 0 ;
13877 void *argp1 = 0 ;
13878 int res1 = 0 ;
13879 PyObject *swig_obj[1] ;
13880
13881 if (!args) SWIG_fail;
13882 swig_obj[0] = args;
13883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13884 if (!SWIG_IsOK(res1)) {
13885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13886 }
13887 arg1 = reinterpret_cast< wxImage * >(argp1);
13888 {
13889 PyThreadState* __tstate = wxPyBeginAllowThreads();
13890 (arg1)->Destroy();
13891 wxPyEndAllowThreads(__tstate);
13892 if (PyErr_Occurred()) SWIG_fail;
13893 }
13894 resultobj = SWIG_Py_Void();
13895 return resultobj;
13896 fail:
13897 return NULL;
13898 }
13899
13900
13901 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13902 PyObject *resultobj = 0;
13903 wxImage *arg1 = (wxImage *) 0 ;
13904 int arg2 ;
13905 int arg3 ;
13906 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
13907 SwigValueWrapper<wxImage > result;
13908 void *argp1 = 0 ;
13909 int res1 = 0 ;
13910 int val2 ;
13911 int ecode2 = 0 ;
13912 int val3 ;
13913 int ecode3 = 0 ;
13914 int val4 ;
13915 int ecode4 = 0 ;
13916 PyObject * obj0 = 0 ;
13917 PyObject * obj1 = 0 ;
13918 PyObject * obj2 = 0 ;
13919 PyObject * obj3 = 0 ;
13920 char * kwnames[] = {
13921 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
13922 };
13923
13924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13926 if (!SWIG_IsOK(res1)) {
13927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13928 }
13929 arg1 = reinterpret_cast< wxImage * >(argp1);
13930 ecode2 = SWIG_AsVal_int(obj1, &val2);
13931 if (!SWIG_IsOK(ecode2)) {
13932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13933 }
13934 arg2 = static_cast< int >(val2);
13935 ecode3 = SWIG_AsVal_int(obj2, &val3);
13936 if (!SWIG_IsOK(ecode3)) {
13937 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13938 }
13939 arg3 = static_cast< int >(val3);
13940 if (obj3) {
13941 ecode4 = SWIG_AsVal_int(obj3, &val4);
13942 if (!SWIG_IsOK(ecode4)) {
13943 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
13944 }
13945 arg4 = static_cast< int >(val4);
13946 }
13947 {
13948 PyThreadState* __tstate = wxPyBeginAllowThreads();
13949 result = (arg1)->Scale(arg2,arg3,arg4);
13950 wxPyEndAllowThreads(__tstate);
13951 if (PyErr_Occurred()) SWIG_fail;
13952 }
13953 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13954 return resultobj;
13955 fail:
13956 return NULL;
13957 }
13958
13959
13960 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13961 PyObject *resultobj = 0;
13962 wxImage *arg1 = (wxImage *) 0 ;
13963 int arg2 ;
13964 int arg3 ;
13965 SwigValueWrapper<wxImage > result;
13966 void *argp1 = 0 ;
13967 int res1 = 0 ;
13968 int val2 ;
13969 int ecode2 = 0 ;
13970 int val3 ;
13971 int ecode3 = 0 ;
13972 PyObject * obj0 = 0 ;
13973 PyObject * obj1 = 0 ;
13974 PyObject * obj2 = 0 ;
13975 char * kwnames[] = {
13976 (char *) "self",(char *) "width",(char *) "height", NULL
13977 };
13978
13979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13981 if (!SWIG_IsOK(res1)) {
13982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
13983 }
13984 arg1 = reinterpret_cast< wxImage * >(argp1);
13985 ecode2 = SWIG_AsVal_int(obj1, &val2);
13986 if (!SWIG_IsOK(ecode2)) {
13987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
13988 }
13989 arg2 = static_cast< int >(val2);
13990 ecode3 = SWIG_AsVal_int(obj2, &val3);
13991 if (!SWIG_IsOK(ecode3)) {
13992 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
13993 }
13994 arg3 = static_cast< int >(val3);
13995 {
13996 PyThreadState* __tstate = wxPyBeginAllowThreads();
13997 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
13998 wxPyEndAllowThreads(__tstate);
13999 if (PyErr_Occurred()) SWIG_fail;
14000 }
14001 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14002 return resultobj;
14003 fail:
14004 return NULL;
14005 }
14006
14007
14008 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14009 PyObject *resultobj = 0;
14010 wxImage *arg1 = (wxImage *) 0 ;
14011 int arg2 ;
14012 int arg3 ;
14013 SwigValueWrapper<wxImage > result;
14014 void *argp1 = 0 ;
14015 int res1 = 0 ;
14016 int val2 ;
14017 int ecode2 = 0 ;
14018 int val3 ;
14019 int ecode3 = 0 ;
14020 PyObject * obj0 = 0 ;
14021 PyObject * obj1 = 0 ;
14022 PyObject * obj2 = 0 ;
14023 char * kwnames[] = {
14024 (char *) "self",(char *) "width",(char *) "height", NULL
14025 };
14026
14027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14029 if (!SWIG_IsOK(res1)) {
14030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
14031 }
14032 arg1 = reinterpret_cast< wxImage * >(argp1);
14033 ecode2 = SWIG_AsVal_int(obj1, &val2);
14034 if (!SWIG_IsOK(ecode2)) {
14035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
14036 }
14037 arg2 = static_cast< int >(val2);
14038 ecode3 = SWIG_AsVal_int(obj2, &val3);
14039 if (!SWIG_IsOK(ecode3)) {
14040 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
14041 }
14042 arg3 = static_cast< int >(val3);
14043 {
14044 PyThreadState* __tstate = wxPyBeginAllowThreads();
14045 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
14046 wxPyEndAllowThreads(__tstate);
14047 if (PyErr_Occurred()) SWIG_fail;
14048 }
14049 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14050 return resultobj;
14051 fail:
14052 return NULL;
14053 }
14054
14055
14056 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14057 PyObject *resultobj = 0;
14058 wxImage *arg1 = (wxImage *) 0 ;
14059 int arg2 ;
14060 SwigValueWrapper<wxImage > result;
14061 void *argp1 = 0 ;
14062 int res1 = 0 ;
14063 int val2 ;
14064 int ecode2 = 0 ;
14065 PyObject * obj0 = 0 ;
14066 PyObject * obj1 = 0 ;
14067 char * kwnames[] = {
14068 (char *) "self",(char *) "radius", NULL
14069 };
14070
14071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
14072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14073 if (!SWIG_IsOK(res1)) {
14074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
14075 }
14076 arg1 = reinterpret_cast< wxImage * >(argp1);
14077 ecode2 = SWIG_AsVal_int(obj1, &val2);
14078 if (!SWIG_IsOK(ecode2)) {
14079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
14080 }
14081 arg2 = static_cast< int >(val2);
14082 {
14083 PyThreadState* __tstate = wxPyBeginAllowThreads();
14084 result = (arg1)->Blur(arg2);
14085 wxPyEndAllowThreads(__tstate);
14086 if (PyErr_Occurred()) SWIG_fail;
14087 }
14088 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14089 return resultobj;
14090 fail:
14091 return NULL;
14092 }
14093
14094
14095 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14096 PyObject *resultobj = 0;
14097 wxImage *arg1 = (wxImage *) 0 ;
14098 int arg2 ;
14099 SwigValueWrapper<wxImage > result;
14100 void *argp1 = 0 ;
14101 int res1 = 0 ;
14102 int val2 ;
14103 int ecode2 = 0 ;
14104 PyObject * obj0 = 0 ;
14105 PyObject * obj1 = 0 ;
14106 char * kwnames[] = {
14107 (char *) "self",(char *) "radius", NULL
14108 };
14109
14110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
14111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14112 if (!SWIG_IsOK(res1)) {
14113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
14114 }
14115 arg1 = reinterpret_cast< wxImage * >(argp1);
14116 ecode2 = SWIG_AsVal_int(obj1, &val2);
14117 if (!SWIG_IsOK(ecode2)) {
14118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
14119 }
14120 arg2 = static_cast< int >(val2);
14121 {
14122 PyThreadState* __tstate = wxPyBeginAllowThreads();
14123 result = (arg1)->BlurHorizontal(arg2);
14124 wxPyEndAllowThreads(__tstate);
14125 if (PyErr_Occurred()) SWIG_fail;
14126 }
14127 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14128 return resultobj;
14129 fail:
14130 return NULL;
14131 }
14132
14133
14134 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14135 PyObject *resultobj = 0;
14136 wxImage *arg1 = (wxImage *) 0 ;
14137 int arg2 ;
14138 SwigValueWrapper<wxImage > result;
14139 void *argp1 = 0 ;
14140 int res1 = 0 ;
14141 int val2 ;
14142 int ecode2 = 0 ;
14143 PyObject * obj0 = 0 ;
14144 PyObject * obj1 = 0 ;
14145 char * kwnames[] = {
14146 (char *) "self",(char *) "radius", NULL
14147 };
14148
14149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
14150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14151 if (!SWIG_IsOK(res1)) {
14152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
14153 }
14154 arg1 = reinterpret_cast< wxImage * >(argp1);
14155 ecode2 = SWIG_AsVal_int(obj1, &val2);
14156 if (!SWIG_IsOK(ecode2)) {
14157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
14158 }
14159 arg2 = static_cast< int >(val2);
14160 {
14161 PyThreadState* __tstate = wxPyBeginAllowThreads();
14162 result = (arg1)->BlurVertical(arg2);
14163 wxPyEndAllowThreads(__tstate);
14164 if (PyErr_Occurred()) SWIG_fail;
14165 }
14166 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14167 return resultobj;
14168 fail:
14169 return NULL;
14170 }
14171
14172
14173 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14174 PyObject *resultobj = 0;
14175 wxImage *arg1 = (wxImage *) 0 ;
14176 int arg2 ;
14177 int arg3 ;
14178 SwigValueWrapper<wxImage > result;
14179 void *argp1 = 0 ;
14180 int res1 = 0 ;
14181 int val2 ;
14182 int ecode2 = 0 ;
14183 int val3 ;
14184 int ecode3 = 0 ;
14185 PyObject * obj0 = 0 ;
14186 PyObject * obj1 = 0 ;
14187 PyObject * obj2 = 0 ;
14188 char * kwnames[] = {
14189 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
14190 };
14191
14192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14194 if (!SWIG_IsOK(res1)) {
14195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
14196 }
14197 arg1 = reinterpret_cast< wxImage * >(argp1);
14198 ecode2 = SWIG_AsVal_int(obj1, &val2);
14199 if (!SWIG_IsOK(ecode2)) {
14200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
14201 }
14202 arg2 = static_cast< int >(val2);
14203 ecode3 = SWIG_AsVal_int(obj2, &val3);
14204 if (!SWIG_IsOK(ecode3)) {
14205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
14206 }
14207 arg3 = static_cast< int >(val3);
14208 {
14209 PyThreadState* __tstate = wxPyBeginAllowThreads();
14210 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
14211 wxPyEndAllowThreads(__tstate);
14212 if (PyErr_Occurred()) SWIG_fail;
14213 }
14214 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14215 return resultobj;
14216 fail:
14217 return NULL;
14218 }
14219
14220
14221 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14222 PyObject *resultobj = 0;
14223 wxImage *arg1 = (wxImage *) 0 ;
14224 int arg2 ;
14225 int arg3 ;
14226 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
14227 wxImage *result = 0 ;
14228 void *argp1 = 0 ;
14229 int res1 = 0 ;
14230 int val2 ;
14231 int ecode2 = 0 ;
14232 int val3 ;
14233 int ecode3 = 0 ;
14234 int val4 ;
14235 int ecode4 = 0 ;
14236 PyObject * obj0 = 0 ;
14237 PyObject * obj1 = 0 ;
14238 PyObject * obj2 = 0 ;
14239 PyObject * obj3 = 0 ;
14240 char * kwnames[] = {
14241 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
14242 };
14243
14244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14246 if (!SWIG_IsOK(res1)) {
14247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
14248 }
14249 arg1 = reinterpret_cast< wxImage * >(argp1);
14250 ecode2 = SWIG_AsVal_int(obj1, &val2);
14251 if (!SWIG_IsOK(ecode2)) {
14252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
14253 }
14254 arg2 = static_cast< int >(val2);
14255 ecode3 = SWIG_AsVal_int(obj2, &val3);
14256 if (!SWIG_IsOK(ecode3)) {
14257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
14258 }
14259 arg3 = static_cast< int >(val3);
14260 if (obj3) {
14261 ecode4 = SWIG_AsVal_int(obj3, &val4);
14262 if (!SWIG_IsOK(ecode4)) {
14263 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
14264 }
14265 arg4 = static_cast< int >(val4);
14266 }
14267 {
14268 PyThreadState* __tstate = wxPyBeginAllowThreads();
14269 {
14270 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
14271 result = (wxImage *) &_result_ref;
14272 }
14273 wxPyEndAllowThreads(__tstate);
14274 if (PyErr_Occurred()) SWIG_fail;
14275 }
14276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
14277 return resultobj;
14278 fail:
14279 return NULL;
14280 }
14281
14282
14283 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14284 PyObject *resultobj = 0;
14285 wxImage *arg1 = (wxImage *) 0 ;
14286 wxSize *arg2 = 0 ;
14287 wxPoint *arg3 = 0 ;
14288 int arg4 = (int) -1 ;
14289 int arg5 = (int) -1 ;
14290 int arg6 = (int) -1 ;
14291 wxImage *result = 0 ;
14292 void *argp1 = 0 ;
14293 int res1 = 0 ;
14294 wxSize temp2 ;
14295 wxPoint temp3 ;
14296 int val4 ;
14297 int ecode4 = 0 ;
14298 int val5 ;
14299 int ecode5 = 0 ;
14300 int val6 ;
14301 int ecode6 = 0 ;
14302 PyObject * obj0 = 0 ;
14303 PyObject * obj1 = 0 ;
14304 PyObject * obj2 = 0 ;
14305 PyObject * obj3 = 0 ;
14306 PyObject * obj4 = 0 ;
14307 PyObject * obj5 = 0 ;
14308 char * kwnames[] = {
14309 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
14310 };
14311
14312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14314 if (!SWIG_IsOK(res1)) {
14315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
14316 }
14317 arg1 = reinterpret_cast< wxImage * >(argp1);
14318 {
14319 arg2 = &temp2;
14320 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
14321 }
14322 {
14323 arg3 = &temp3;
14324 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14325 }
14326 if (obj3) {
14327 ecode4 = SWIG_AsVal_int(obj3, &val4);
14328 if (!SWIG_IsOK(ecode4)) {
14329 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
14330 }
14331 arg4 = static_cast< int >(val4);
14332 }
14333 if (obj4) {
14334 ecode5 = SWIG_AsVal_int(obj4, &val5);
14335 if (!SWIG_IsOK(ecode5)) {
14336 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
14337 }
14338 arg5 = static_cast< int >(val5);
14339 }
14340 if (obj5) {
14341 ecode6 = SWIG_AsVal_int(obj5, &val6);
14342 if (!SWIG_IsOK(ecode6)) {
14343 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
14344 }
14345 arg6 = static_cast< int >(val6);
14346 }
14347 {
14348 PyThreadState* __tstate = wxPyBeginAllowThreads();
14349 {
14350 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
14351 result = (wxImage *) &_result_ref;
14352 }
14353 wxPyEndAllowThreads(__tstate);
14354 if (PyErr_Occurred()) SWIG_fail;
14355 }
14356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
14357 return resultobj;
14358 fail:
14359 return NULL;
14360 }
14361
14362
14363 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14364 PyObject *resultobj = 0;
14365 wxImage *arg1 = (wxImage *) 0 ;
14366 int arg2 ;
14367 int arg3 ;
14368 byte arg4 ;
14369 byte arg5 ;
14370 byte arg6 ;
14371 void *argp1 = 0 ;
14372 int res1 = 0 ;
14373 int val2 ;
14374 int ecode2 = 0 ;
14375 int val3 ;
14376 int ecode3 = 0 ;
14377 unsigned char val4 ;
14378 int ecode4 = 0 ;
14379 unsigned char val5 ;
14380 int ecode5 = 0 ;
14381 unsigned char val6 ;
14382 int ecode6 = 0 ;
14383 PyObject * obj0 = 0 ;
14384 PyObject * obj1 = 0 ;
14385 PyObject * obj2 = 0 ;
14386 PyObject * obj3 = 0 ;
14387 PyObject * obj4 = 0 ;
14388 PyObject * obj5 = 0 ;
14389 char * kwnames[] = {
14390 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
14391 };
14392
14393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14395 if (!SWIG_IsOK(res1)) {
14396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
14397 }
14398 arg1 = reinterpret_cast< wxImage * >(argp1);
14399 ecode2 = SWIG_AsVal_int(obj1, &val2);
14400 if (!SWIG_IsOK(ecode2)) {
14401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
14402 }
14403 arg2 = static_cast< int >(val2);
14404 ecode3 = SWIG_AsVal_int(obj2, &val3);
14405 if (!SWIG_IsOK(ecode3)) {
14406 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
14407 }
14408 arg3 = static_cast< int >(val3);
14409 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14410 if (!SWIG_IsOK(ecode4)) {
14411 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
14412 }
14413 arg4 = static_cast< byte >(val4);
14414 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14415 if (!SWIG_IsOK(ecode5)) {
14416 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
14417 }
14418 arg5 = static_cast< byte >(val5);
14419 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
14420 if (!SWIG_IsOK(ecode6)) {
14421 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
14422 }
14423 arg6 = static_cast< byte >(val6);
14424 {
14425 PyThreadState* __tstate = wxPyBeginAllowThreads();
14426 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
14427 wxPyEndAllowThreads(__tstate);
14428 if (PyErr_Occurred()) SWIG_fail;
14429 }
14430 resultobj = SWIG_Py_Void();
14431 return resultobj;
14432 fail:
14433 return NULL;
14434 }
14435
14436
14437 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14438 PyObject *resultobj = 0;
14439 wxImage *arg1 = (wxImage *) 0 ;
14440 wxRect *arg2 = 0 ;
14441 byte arg3 ;
14442 byte arg4 ;
14443 byte arg5 ;
14444 void *argp1 = 0 ;
14445 int res1 = 0 ;
14446 wxRect temp2 ;
14447 unsigned char val3 ;
14448 int ecode3 = 0 ;
14449 unsigned char val4 ;
14450 int ecode4 = 0 ;
14451 unsigned char val5 ;
14452 int ecode5 = 0 ;
14453 PyObject * obj0 = 0 ;
14454 PyObject * obj1 = 0 ;
14455 PyObject * obj2 = 0 ;
14456 PyObject * obj3 = 0 ;
14457 PyObject * obj4 = 0 ;
14458 char * kwnames[] = {
14459 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
14460 };
14461
14462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14464 if (!SWIG_IsOK(res1)) {
14465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
14466 }
14467 arg1 = reinterpret_cast< wxImage * >(argp1);
14468 {
14469 arg2 = &temp2;
14470 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14471 }
14472 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14473 if (!SWIG_IsOK(ecode3)) {
14474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
14475 }
14476 arg3 = static_cast< byte >(val3);
14477 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14478 if (!SWIG_IsOK(ecode4)) {
14479 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
14480 }
14481 arg4 = static_cast< byte >(val4);
14482 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14483 if (!SWIG_IsOK(ecode5)) {
14484 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
14485 }
14486 arg5 = static_cast< byte >(val5);
14487 {
14488 PyThreadState* __tstate = wxPyBeginAllowThreads();
14489 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
14490 wxPyEndAllowThreads(__tstate);
14491 if (PyErr_Occurred()) SWIG_fail;
14492 }
14493 resultobj = SWIG_Py_Void();
14494 return resultobj;
14495 fail:
14496 return NULL;
14497 }
14498
14499
14500 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14501 PyObject *resultobj = 0;
14502 wxImage *arg1 = (wxImage *) 0 ;
14503 int arg2 ;
14504 int arg3 ;
14505 byte result;
14506 void *argp1 = 0 ;
14507 int res1 = 0 ;
14508 int val2 ;
14509 int ecode2 = 0 ;
14510 int val3 ;
14511 int ecode3 = 0 ;
14512 PyObject * obj0 = 0 ;
14513 PyObject * obj1 = 0 ;
14514 PyObject * obj2 = 0 ;
14515 char * kwnames[] = {
14516 (char *) "self",(char *) "x",(char *) "y", NULL
14517 };
14518
14519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14521 if (!SWIG_IsOK(res1)) {
14522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
14523 }
14524 arg1 = reinterpret_cast< wxImage * >(argp1);
14525 ecode2 = SWIG_AsVal_int(obj1, &val2);
14526 if (!SWIG_IsOK(ecode2)) {
14527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
14528 }
14529 arg2 = static_cast< int >(val2);
14530 ecode3 = SWIG_AsVal_int(obj2, &val3);
14531 if (!SWIG_IsOK(ecode3)) {
14532 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
14533 }
14534 arg3 = static_cast< int >(val3);
14535 {
14536 PyThreadState* __tstate = wxPyBeginAllowThreads();
14537 result = (byte)(arg1)->GetRed(arg2,arg3);
14538 wxPyEndAllowThreads(__tstate);
14539 if (PyErr_Occurred()) SWIG_fail;
14540 }
14541 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14542 return resultobj;
14543 fail:
14544 return NULL;
14545 }
14546
14547
14548 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14549 PyObject *resultobj = 0;
14550 wxImage *arg1 = (wxImage *) 0 ;
14551 int arg2 ;
14552 int arg3 ;
14553 byte result;
14554 void *argp1 = 0 ;
14555 int res1 = 0 ;
14556 int val2 ;
14557 int ecode2 = 0 ;
14558 int val3 ;
14559 int ecode3 = 0 ;
14560 PyObject * obj0 = 0 ;
14561 PyObject * obj1 = 0 ;
14562 PyObject * obj2 = 0 ;
14563 char * kwnames[] = {
14564 (char *) "self",(char *) "x",(char *) "y", NULL
14565 };
14566
14567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14569 if (!SWIG_IsOK(res1)) {
14570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14571 }
14572 arg1 = reinterpret_cast< wxImage * >(argp1);
14573 ecode2 = SWIG_AsVal_int(obj1, &val2);
14574 if (!SWIG_IsOK(ecode2)) {
14575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14576 }
14577 arg2 = static_cast< int >(val2);
14578 ecode3 = SWIG_AsVal_int(obj2, &val3);
14579 if (!SWIG_IsOK(ecode3)) {
14580 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14581 }
14582 arg3 = static_cast< int >(val3);
14583 {
14584 PyThreadState* __tstate = wxPyBeginAllowThreads();
14585 result = (byte)(arg1)->GetGreen(arg2,arg3);
14586 wxPyEndAllowThreads(__tstate);
14587 if (PyErr_Occurred()) SWIG_fail;
14588 }
14589 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14590 return resultobj;
14591 fail:
14592 return NULL;
14593 }
14594
14595
14596 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14597 PyObject *resultobj = 0;
14598 wxImage *arg1 = (wxImage *) 0 ;
14599 int arg2 ;
14600 int arg3 ;
14601 byte result;
14602 void *argp1 = 0 ;
14603 int res1 = 0 ;
14604 int val2 ;
14605 int ecode2 = 0 ;
14606 int val3 ;
14607 int ecode3 = 0 ;
14608 PyObject * obj0 = 0 ;
14609 PyObject * obj1 = 0 ;
14610 PyObject * obj2 = 0 ;
14611 char * kwnames[] = {
14612 (char *) "self",(char *) "x",(char *) "y", NULL
14613 };
14614
14615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14617 if (!SWIG_IsOK(res1)) {
14618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14619 }
14620 arg1 = reinterpret_cast< wxImage * >(argp1);
14621 ecode2 = SWIG_AsVal_int(obj1, &val2);
14622 if (!SWIG_IsOK(ecode2)) {
14623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14624 }
14625 arg2 = static_cast< int >(val2);
14626 ecode3 = SWIG_AsVal_int(obj2, &val3);
14627 if (!SWIG_IsOK(ecode3)) {
14628 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14629 }
14630 arg3 = static_cast< int >(val3);
14631 {
14632 PyThreadState* __tstate = wxPyBeginAllowThreads();
14633 result = (byte)(arg1)->GetBlue(arg2,arg3);
14634 wxPyEndAllowThreads(__tstate);
14635 if (PyErr_Occurred()) SWIG_fail;
14636 }
14637 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14638 return resultobj;
14639 fail:
14640 return NULL;
14641 }
14642
14643
14644 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14645 PyObject *resultobj = 0;
14646 wxImage *arg1 = (wxImage *) 0 ;
14647 int arg2 ;
14648 int arg3 ;
14649 byte arg4 ;
14650 void *argp1 = 0 ;
14651 int res1 = 0 ;
14652 int val2 ;
14653 int ecode2 = 0 ;
14654 int val3 ;
14655 int ecode3 = 0 ;
14656 unsigned char val4 ;
14657 int ecode4 = 0 ;
14658 PyObject * obj0 = 0 ;
14659 PyObject * obj1 = 0 ;
14660 PyObject * obj2 = 0 ;
14661 PyObject * obj3 = 0 ;
14662 char * kwnames[] = {
14663 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14664 };
14665
14666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14668 if (!SWIG_IsOK(res1)) {
14669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14670 }
14671 arg1 = reinterpret_cast< wxImage * >(argp1);
14672 ecode2 = SWIG_AsVal_int(obj1, &val2);
14673 if (!SWIG_IsOK(ecode2)) {
14674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14675 }
14676 arg2 = static_cast< int >(val2);
14677 ecode3 = SWIG_AsVal_int(obj2, &val3);
14678 if (!SWIG_IsOK(ecode3)) {
14679 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14680 }
14681 arg3 = static_cast< int >(val3);
14682 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14683 if (!SWIG_IsOK(ecode4)) {
14684 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14685 }
14686 arg4 = static_cast< byte >(val4);
14687 {
14688 PyThreadState* __tstate = wxPyBeginAllowThreads();
14689 (arg1)->SetAlpha(arg2,arg3,arg4);
14690 wxPyEndAllowThreads(__tstate);
14691 if (PyErr_Occurred()) SWIG_fail;
14692 }
14693 resultobj = SWIG_Py_Void();
14694 return resultobj;
14695 fail:
14696 return NULL;
14697 }
14698
14699
14700 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14701 PyObject *resultobj = 0;
14702 wxImage *arg1 = (wxImage *) 0 ;
14703 int arg2 ;
14704 int arg3 ;
14705 byte result;
14706 void *argp1 = 0 ;
14707 int res1 = 0 ;
14708 int val2 ;
14709 int ecode2 = 0 ;
14710 int val3 ;
14711 int ecode3 = 0 ;
14712 PyObject * obj0 = 0 ;
14713 PyObject * obj1 = 0 ;
14714 PyObject * obj2 = 0 ;
14715 char * kwnames[] = {
14716 (char *) "self",(char *) "x",(char *) "y", NULL
14717 };
14718
14719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14721 if (!SWIG_IsOK(res1)) {
14722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14723 }
14724 arg1 = reinterpret_cast< wxImage * >(argp1);
14725 ecode2 = SWIG_AsVal_int(obj1, &val2);
14726 if (!SWIG_IsOK(ecode2)) {
14727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14728 }
14729 arg2 = static_cast< int >(val2);
14730 ecode3 = SWIG_AsVal_int(obj2, &val3);
14731 if (!SWIG_IsOK(ecode3)) {
14732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14733 }
14734 arg3 = static_cast< int >(val3);
14735 {
14736 PyThreadState* __tstate = wxPyBeginAllowThreads();
14737 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14738 wxPyEndAllowThreads(__tstate);
14739 if (PyErr_Occurred()) SWIG_fail;
14740 }
14741 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14742 return resultobj;
14743 fail:
14744 return NULL;
14745 }
14746
14747
14748 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14749 PyObject *resultobj = 0;
14750 wxImage *arg1 = (wxImage *) 0 ;
14751 bool result;
14752 void *argp1 = 0 ;
14753 int res1 = 0 ;
14754 PyObject *swig_obj[1] ;
14755
14756 if (!args) SWIG_fail;
14757 swig_obj[0] = args;
14758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14759 if (!SWIG_IsOK(res1)) {
14760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14761 }
14762 arg1 = reinterpret_cast< wxImage * >(argp1);
14763 {
14764 PyThreadState* __tstate = wxPyBeginAllowThreads();
14765 result = (bool)(arg1)->HasAlpha();
14766 wxPyEndAllowThreads(__tstate);
14767 if (PyErr_Occurred()) SWIG_fail;
14768 }
14769 {
14770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14771 }
14772 return resultobj;
14773 fail:
14774 return NULL;
14775 }
14776
14777
14778 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14779 PyObject *resultobj = 0;
14780 wxImage *arg1 = (wxImage *) 0 ;
14781 void *argp1 = 0 ;
14782 int res1 = 0 ;
14783 PyObject *swig_obj[1] ;
14784
14785 if (!args) SWIG_fail;
14786 swig_obj[0] = args;
14787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14788 if (!SWIG_IsOK(res1)) {
14789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14790 }
14791 arg1 = reinterpret_cast< wxImage * >(argp1);
14792 {
14793 PyThreadState* __tstate = wxPyBeginAllowThreads();
14794 (arg1)->InitAlpha();
14795 wxPyEndAllowThreads(__tstate);
14796 if (PyErr_Occurred()) SWIG_fail;
14797 }
14798 resultobj = SWIG_Py_Void();
14799 return resultobj;
14800 fail:
14801 return NULL;
14802 }
14803
14804
14805 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14806 PyObject *resultobj = 0;
14807 wxImage *arg1 = (wxImage *) 0 ;
14808 int arg2 ;
14809 int arg3 ;
14810 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14811 bool result;
14812 void *argp1 = 0 ;
14813 int res1 = 0 ;
14814 int val2 ;
14815 int ecode2 = 0 ;
14816 int val3 ;
14817 int ecode3 = 0 ;
14818 unsigned char val4 ;
14819 int ecode4 = 0 ;
14820 PyObject * obj0 = 0 ;
14821 PyObject * obj1 = 0 ;
14822 PyObject * obj2 = 0 ;
14823 PyObject * obj3 = 0 ;
14824 char * kwnames[] = {
14825 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14826 };
14827
14828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14830 if (!SWIG_IsOK(res1)) {
14831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14832 }
14833 arg1 = reinterpret_cast< wxImage * >(argp1);
14834 ecode2 = SWIG_AsVal_int(obj1, &val2);
14835 if (!SWIG_IsOK(ecode2)) {
14836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14837 }
14838 arg2 = static_cast< int >(val2);
14839 ecode3 = SWIG_AsVal_int(obj2, &val3);
14840 if (!SWIG_IsOK(ecode3)) {
14841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14842 }
14843 arg3 = static_cast< int >(val3);
14844 if (obj3) {
14845 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14846 if (!SWIG_IsOK(ecode4)) {
14847 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14848 }
14849 arg4 = static_cast< byte >(val4);
14850 }
14851 {
14852 PyThreadState* __tstate = wxPyBeginAllowThreads();
14853 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14854 wxPyEndAllowThreads(__tstate);
14855 if (PyErr_Occurred()) SWIG_fail;
14856 }
14857 {
14858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14859 }
14860 return resultobj;
14861 fail:
14862 return NULL;
14863 }
14864
14865
14866 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14867 PyObject *resultobj = 0;
14868 wxImage *arg1 = (wxImage *) 0 ;
14869 byte *arg2 = (byte *) 0 ;
14870 byte *arg3 = (byte *) 0 ;
14871 byte *arg4 = (byte *) 0 ;
14872 byte arg5 = (byte) 0 ;
14873 byte arg6 = (byte) 0 ;
14874 byte arg7 = (byte) 0 ;
14875 bool result;
14876 void *argp1 = 0 ;
14877 int res1 = 0 ;
14878 byte temp2 ;
14879 int res2 = SWIG_TMPOBJ ;
14880 byte temp3 ;
14881 int res3 = SWIG_TMPOBJ ;
14882 byte temp4 ;
14883 int res4 = SWIG_TMPOBJ ;
14884 unsigned char val5 ;
14885 int ecode5 = 0 ;
14886 unsigned char val6 ;
14887 int ecode6 = 0 ;
14888 unsigned char val7 ;
14889 int ecode7 = 0 ;
14890 PyObject * obj0 = 0 ;
14891 PyObject * obj1 = 0 ;
14892 PyObject * obj2 = 0 ;
14893 PyObject * obj3 = 0 ;
14894 char * kwnames[] = {
14895 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14896 };
14897
14898 arg2 = &temp2;
14899 arg3 = &temp3;
14900 arg4 = &temp4;
14901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14903 if (!SWIG_IsOK(res1)) {
14904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14905 }
14906 arg1 = reinterpret_cast< wxImage * >(argp1);
14907 if (obj1) {
14908 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14909 if (!SWIG_IsOK(ecode5)) {
14910 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14911 }
14912 arg5 = static_cast< byte >(val5);
14913 }
14914 if (obj2) {
14915 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14916 if (!SWIG_IsOK(ecode6)) {
14917 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14918 }
14919 arg6 = static_cast< byte >(val6);
14920 }
14921 if (obj3) {
14922 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14923 if (!SWIG_IsOK(ecode7)) {
14924 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14925 }
14926 arg7 = static_cast< byte >(val7);
14927 }
14928 {
14929 PyThreadState* __tstate = wxPyBeginAllowThreads();
14930 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14931 wxPyEndAllowThreads(__tstate);
14932 if (PyErr_Occurred()) SWIG_fail;
14933 }
14934 {
14935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14936 }
14937 if (SWIG_IsTmpObj(res2)) {
14938 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14939 } else {
14940 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14941 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14942 }
14943 if (SWIG_IsTmpObj(res3)) {
14944 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14945 } else {
14946 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14947 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14948 }
14949 if (SWIG_IsTmpObj(res4)) {
14950 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14951 } else {
14952 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14953 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14954 }
14955 return resultobj;
14956 fail:
14957 return NULL;
14958 }
14959
14960
14961 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14962 PyObject *resultobj = 0;
14963 wxImage *arg1 = (wxImage *) 0 ;
14964 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14965 bool result;
14966 void *argp1 = 0 ;
14967 int res1 = 0 ;
14968 unsigned char val2 ;
14969 int ecode2 = 0 ;
14970 PyObject * obj0 = 0 ;
14971 PyObject * obj1 = 0 ;
14972 char * kwnames[] = {
14973 (char *) "self",(char *) "threshold", NULL
14974 };
14975
14976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14978 if (!SWIG_IsOK(res1)) {
14979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14980 }
14981 arg1 = reinterpret_cast< wxImage * >(argp1);
14982 if (obj1) {
14983 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14984 if (!SWIG_IsOK(ecode2)) {
14985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14986 }
14987 arg2 = static_cast< byte >(val2);
14988 }
14989 {
14990 PyThreadState* __tstate = wxPyBeginAllowThreads();
14991 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14992 wxPyEndAllowThreads(__tstate);
14993 if (PyErr_Occurred()) SWIG_fail;
14994 }
14995 {
14996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14997 }
14998 return resultobj;
14999 fail:
15000 return NULL;
15001 }
15002
15003
15004 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15005 PyObject *resultobj = 0;
15006 wxImage *arg1 = (wxImage *) 0 ;
15007 byte arg2 ;
15008 byte arg3 ;
15009 byte arg4 ;
15010 bool result;
15011 void *argp1 = 0 ;
15012 int res1 = 0 ;
15013 unsigned char val2 ;
15014 int ecode2 = 0 ;
15015 unsigned char val3 ;
15016 int ecode3 = 0 ;
15017 unsigned char val4 ;
15018 int ecode4 = 0 ;
15019 PyObject * obj0 = 0 ;
15020 PyObject * obj1 = 0 ;
15021 PyObject * obj2 = 0 ;
15022 PyObject * obj3 = 0 ;
15023 char * kwnames[] = {
15024 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15025 };
15026
15027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15029 if (!SWIG_IsOK(res1)) {
15030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
15031 }
15032 arg1 = reinterpret_cast< wxImage * >(argp1);
15033 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15034 if (!SWIG_IsOK(ecode2)) {
15035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
15036 }
15037 arg2 = static_cast< byte >(val2);
15038 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15039 if (!SWIG_IsOK(ecode3)) {
15040 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
15041 }
15042 arg3 = static_cast< byte >(val3);
15043 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15044 if (!SWIG_IsOK(ecode4)) {
15045 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
15046 }
15047 arg4 = static_cast< byte >(val4);
15048 {
15049 PyThreadState* __tstate = wxPyBeginAllowThreads();
15050 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
15051 wxPyEndAllowThreads(__tstate);
15052 if (PyErr_Occurred()) SWIG_fail;
15053 }
15054 {
15055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15056 }
15057 return resultobj;
15058 fail:
15059 return NULL;
15060 }
15061
15062
15063 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15064 PyObject *resultobj = 0;
15065 wxImage *arg1 = (wxImage *) 0 ;
15066 wxImage *arg2 = 0 ;
15067 byte arg3 ;
15068 byte arg4 ;
15069 byte arg5 ;
15070 bool result;
15071 void *argp1 = 0 ;
15072 int res1 = 0 ;
15073 void *argp2 = 0 ;
15074 int res2 = 0 ;
15075 unsigned char val3 ;
15076 int ecode3 = 0 ;
15077 unsigned char val4 ;
15078 int ecode4 = 0 ;
15079 unsigned char val5 ;
15080 int ecode5 = 0 ;
15081 PyObject * obj0 = 0 ;
15082 PyObject * obj1 = 0 ;
15083 PyObject * obj2 = 0 ;
15084 PyObject * obj3 = 0 ;
15085 PyObject * obj4 = 0 ;
15086 char * kwnames[] = {
15087 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
15088 };
15089
15090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15092 if (!SWIG_IsOK(res1)) {
15093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
15094 }
15095 arg1 = reinterpret_cast< wxImage * >(argp1);
15096 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15097 if (!SWIG_IsOK(res2)) {
15098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
15099 }
15100 if (!argp2) {
15101 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
15102 }
15103 arg2 = reinterpret_cast< wxImage * >(argp2);
15104 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15105 if (!SWIG_IsOK(ecode3)) {
15106 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
15107 }
15108 arg3 = static_cast< byte >(val3);
15109 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15110 if (!SWIG_IsOK(ecode4)) {
15111 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
15112 }
15113 arg4 = static_cast< byte >(val4);
15114 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15115 if (!SWIG_IsOK(ecode5)) {
15116 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
15117 }
15118 arg5 = static_cast< byte >(val5);
15119 {
15120 PyThreadState* __tstate = wxPyBeginAllowThreads();
15121 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
15122 wxPyEndAllowThreads(__tstate);
15123 if (PyErr_Occurred()) SWIG_fail;
15124 }
15125 {
15126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15127 }
15128 return resultobj;
15129 fail:
15130 return NULL;
15131 }
15132
15133
15134 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15135 PyObject *resultobj = 0;
15136 wxString *arg1 = 0 ;
15137 bool result;
15138 bool temp1 = false ;
15139 PyObject * obj0 = 0 ;
15140 char * kwnames[] = {
15141 (char *) "filename", NULL
15142 };
15143
15144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
15145 {
15146 arg1 = wxString_in_helper(obj0);
15147 if (arg1 == NULL) SWIG_fail;
15148 temp1 = true;
15149 }
15150 {
15151 PyThreadState* __tstate = wxPyBeginAllowThreads();
15152 result = (bool)wxImage::CanRead((wxString const &)*arg1);
15153 wxPyEndAllowThreads(__tstate);
15154 if (PyErr_Occurred()) SWIG_fail;
15155 }
15156 {
15157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15158 }
15159 {
15160 if (temp1)
15161 delete arg1;
15162 }
15163 return resultobj;
15164 fail:
15165 {
15166 if (temp1)
15167 delete arg1;
15168 }
15169 return NULL;
15170 }
15171
15172
15173 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15174 PyObject *resultobj = 0;
15175 wxString *arg1 = 0 ;
15176 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15177 int result;
15178 bool temp1 = false ;
15179 long val2 ;
15180 int ecode2 = 0 ;
15181 PyObject * obj0 = 0 ;
15182 PyObject * obj1 = 0 ;
15183 char * kwnames[] = {
15184 (char *) "filename",(char *) "type", NULL
15185 };
15186
15187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
15188 {
15189 arg1 = wxString_in_helper(obj0);
15190 if (arg1 == NULL) SWIG_fail;
15191 temp1 = true;
15192 }
15193 if (obj1) {
15194 ecode2 = SWIG_AsVal_long(obj1, &val2);
15195 if (!SWIG_IsOK(ecode2)) {
15196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
15197 }
15198 arg2 = static_cast< long >(val2);
15199 }
15200 {
15201 PyThreadState* __tstate = wxPyBeginAllowThreads();
15202 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
15203 wxPyEndAllowThreads(__tstate);
15204 if (PyErr_Occurred()) SWIG_fail;
15205 }
15206 resultobj = SWIG_From_int(static_cast< int >(result));
15207 {
15208 if (temp1)
15209 delete arg1;
15210 }
15211 return resultobj;
15212 fail:
15213 {
15214 if (temp1)
15215 delete arg1;
15216 }
15217 return NULL;
15218 }
15219
15220
15221 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15222 PyObject *resultobj = 0;
15223 wxImage *arg1 = (wxImage *) 0 ;
15224 wxString *arg2 = 0 ;
15225 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15226 int arg4 = (int) -1 ;
15227 bool result;
15228 void *argp1 = 0 ;
15229 int res1 = 0 ;
15230 bool temp2 = false ;
15231 long val3 ;
15232 int ecode3 = 0 ;
15233 int val4 ;
15234 int ecode4 = 0 ;
15235 PyObject * obj0 = 0 ;
15236 PyObject * obj1 = 0 ;
15237 PyObject * obj2 = 0 ;
15238 PyObject * obj3 = 0 ;
15239 char * kwnames[] = {
15240 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
15241 };
15242
15243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15245 if (!SWIG_IsOK(res1)) {
15246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
15247 }
15248 arg1 = reinterpret_cast< wxImage * >(argp1);
15249 {
15250 arg2 = wxString_in_helper(obj1);
15251 if (arg2 == NULL) SWIG_fail;
15252 temp2 = true;
15253 }
15254 if (obj2) {
15255 ecode3 = SWIG_AsVal_long(obj2, &val3);
15256 if (!SWIG_IsOK(ecode3)) {
15257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
15258 }
15259 arg3 = static_cast< long >(val3);
15260 }
15261 if (obj3) {
15262 ecode4 = SWIG_AsVal_int(obj3, &val4);
15263 if (!SWIG_IsOK(ecode4)) {
15264 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
15265 }
15266 arg4 = static_cast< int >(val4);
15267 }
15268 {
15269 PyThreadState* __tstate = wxPyBeginAllowThreads();
15270 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
15271 wxPyEndAllowThreads(__tstate);
15272 if (PyErr_Occurred()) SWIG_fail;
15273 }
15274 {
15275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15276 }
15277 {
15278 if (temp2)
15279 delete arg2;
15280 }
15281 return resultobj;
15282 fail:
15283 {
15284 if (temp2)
15285 delete arg2;
15286 }
15287 return NULL;
15288 }
15289
15290
15291 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15292 PyObject *resultobj = 0;
15293 wxImage *arg1 = (wxImage *) 0 ;
15294 wxString *arg2 = 0 ;
15295 wxString *arg3 = 0 ;
15296 int arg4 = (int) -1 ;
15297 bool result;
15298 void *argp1 = 0 ;
15299 int res1 = 0 ;
15300 bool temp2 = false ;
15301 bool temp3 = false ;
15302 int val4 ;
15303 int ecode4 = 0 ;
15304 PyObject * obj0 = 0 ;
15305 PyObject * obj1 = 0 ;
15306 PyObject * obj2 = 0 ;
15307 PyObject * obj3 = 0 ;
15308 char * kwnames[] = {
15309 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
15310 };
15311
15312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15314 if (!SWIG_IsOK(res1)) {
15315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15316 }
15317 arg1 = reinterpret_cast< wxImage * >(argp1);
15318 {
15319 arg2 = wxString_in_helper(obj1);
15320 if (arg2 == NULL) SWIG_fail;
15321 temp2 = true;
15322 }
15323 {
15324 arg3 = wxString_in_helper(obj2);
15325 if (arg3 == NULL) SWIG_fail;
15326 temp3 = true;
15327 }
15328 if (obj3) {
15329 ecode4 = SWIG_AsVal_int(obj3, &val4);
15330 if (!SWIG_IsOK(ecode4)) {
15331 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
15332 }
15333 arg4 = static_cast< int >(val4);
15334 }
15335 {
15336 PyThreadState* __tstate = wxPyBeginAllowThreads();
15337 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
15338 wxPyEndAllowThreads(__tstate);
15339 if (PyErr_Occurred()) SWIG_fail;
15340 }
15341 {
15342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15343 }
15344 {
15345 if (temp2)
15346 delete arg2;
15347 }
15348 {
15349 if (temp3)
15350 delete arg3;
15351 }
15352 return resultobj;
15353 fail:
15354 {
15355 if (temp2)
15356 delete arg2;
15357 }
15358 {
15359 if (temp3)
15360 delete arg3;
15361 }
15362 return NULL;
15363 }
15364
15365
15366 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15367 PyObject *resultobj = 0;
15368 wxImage *arg1 = (wxImage *) 0 ;
15369 wxString *arg2 = 0 ;
15370 int arg3 ;
15371 bool result;
15372 void *argp1 = 0 ;
15373 int res1 = 0 ;
15374 bool temp2 = false ;
15375 int val3 ;
15376 int ecode3 = 0 ;
15377 PyObject * obj0 = 0 ;
15378 PyObject * obj1 = 0 ;
15379 PyObject * obj2 = 0 ;
15380 char * kwnames[] = {
15381 (char *) "self",(char *) "name",(char *) "type", NULL
15382 };
15383
15384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15386 if (!SWIG_IsOK(res1)) {
15387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
15388 }
15389 arg1 = reinterpret_cast< wxImage * >(argp1);
15390 {
15391 arg2 = wxString_in_helper(obj1);
15392 if (arg2 == NULL) SWIG_fail;
15393 temp2 = true;
15394 }
15395 ecode3 = SWIG_AsVal_int(obj2, &val3);
15396 if (!SWIG_IsOK(ecode3)) {
15397 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
15398 }
15399 arg3 = static_cast< int >(val3);
15400 {
15401 PyThreadState* __tstate = wxPyBeginAllowThreads();
15402 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
15403 wxPyEndAllowThreads(__tstate);
15404 if (PyErr_Occurred()) SWIG_fail;
15405 }
15406 {
15407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15408 }
15409 {
15410 if (temp2)
15411 delete arg2;
15412 }
15413 return resultobj;
15414 fail:
15415 {
15416 if (temp2)
15417 delete arg2;
15418 }
15419 return NULL;
15420 }
15421
15422
15423 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15424 PyObject *resultobj = 0;
15425 wxImage *arg1 = (wxImage *) 0 ;
15426 wxString *arg2 = 0 ;
15427 wxString *arg3 = 0 ;
15428 bool result;
15429 void *argp1 = 0 ;
15430 int res1 = 0 ;
15431 bool temp2 = false ;
15432 bool temp3 = false ;
15433 PyObject * obj0 = 0 ;
15434 PyObject * obj1 = 0 ;
15435 PyObject * obj2 = 0 ;
15436 char * kwnames[] = {
15437 (char *) "self",(char *) "name",(char *) "mimetype", NULL
15438 };
15439
15440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) 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_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15444 }
15445 arg1 = reinterpret_cast< wxImage * >(argp1);
15446 {
15447 arg2 = wxString_in_helper(obj1);
15448 if (arg2 == NULL) SWIG_fail;
15449 temp2 = true;
15450 }
15451 {
15452 arg3 = wxString_in_helper(obj2);
15453 if (arg3 == NULL) SWIG_fail;
15454 temp3 = true;
15455 }
15456 {
15457 PyThreadState* __tstate = wxPyBeginAllowThreads();
15458 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
15459 wxPyEndAllowThreads(__tstate);
15460 if (PyErr_Occurred()) SWIG_fail;
15461 }
15462 {
15463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15464 }
15465 {
15466 if (temp2)
15467 delete arg2;
15468 }
15469 {
15470 if (temp3)
15471 delete arg3;
15472 }
15473 return resultobj;
15474 fail:
15475 {
15476 if (temp2)
15477 delete arg2;
15478 }
15479 {
15480 if (temp3)
15481 delete arg3;
15482 }
15483 return NULL;
15484 }
15485
15486
15487 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15488 PyObject *resultobj = 0;
15489 wxInputStream *arg1 = 0 ;
15490 bool result;
15491 wxPyInputStream *temp1 ;
15492 bool created1 ;
15493 PyObject * obj0 = 0 ;
15494 char * kwnames[] = {
15495 (char *) "stream", NULL
15496 };
15497
15498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
15499 {
15500 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15501 arg1 = temp1->m_wxis;
15502 created1 = false;
15503 } else {
15504 PyErr_Clear(); // clear the failure of the wxPyConvert above
15505 arg1 = wxPyCBInputStream_create(obj0, false);
15506 if (arg1 == NULL) {
15507 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15508 SWIG_fail;
15509 }
15510 created1 = true;
15511 }
15512 }
15513 {
15514 PyThreadState* __tstate = wxPyBeginAllowThreads();
15515 result = (bool)wxImage::CanRead(*arg1);
15516 wxPyEndAllowThreads(__tstate);
15517 if (PyErr_Occurred()) SWIG_fail;
15518 }
15519 {
15520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15521 }
15522 {
15523 if (created1) delete arg1;
15524 }
15525 return resultobj;
15526 fail:
15527 {
15528 if (created1) delete arg1;
15529 }
15530 return NULL;
15531 }
15532
15533
15534 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15535 PyObject *resultobj = 0;
15536 wxImage *arg1 = (wxImage *) 0 ;
15537 wxInputStream *arg2 = 0 ;
15538 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15539 int arg4 = (int) -1 ;
15540 bool result;
15541 void *argp1 = 0 ;
15542 int res1 = 0 ;
15543 wxPyInputStream *temp2 ;
15544 bool created2 ;
15545 long val3 ;
15546 int ecode3 = 0 ;
15547 int val4 ;
15548 int ecode4 = 0 ;
15549 PyObject * obj0 = 0 ;
15550 PyObject * obj1 = 0 ;
15551 PyObject * obj2 = 0 ;
15552 PyObject * obj3 = 0 ;
15553 char * kwnames[] = {
15554 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15555 };
15556
15557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15559 if (!SWIG_IsOK(res1)) {
15560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15561 }
15562 arg1 = reinterpret_cast< wxImage * >(argp1);
15563 {
15564 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15565 arg2 = temp2->m_wxis;
15566 created2 = false;
15567 } else {
15568 PyErr_Clear(); // clear the failure of the wxPyConvert above
15569 arg2 = wxPyCBInputStream_create(obj1, false);
15570 if (arg2 == NULL) {
15571 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15572 SWIG_fail;
15573 }
15574 created2 = true;
15575 }
15576 }
15577 if (obj2) {
15578 ecode3 = SWIG_AsVal_long(obj2, &val3);
15579 if (!SWIG_IsOK(ecode3)) {
15580 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15581 }
15582 arg3 = static_cast< long >(val3);
15583 }
15584 if (obj3) {
15585 ecode4 = SWIG_AsVal_int(obj3, &val4);
15586 if (!SWIG_IsOK(ecode4)) {
15587 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15588 }
15589 arg4 = static_cast< int >(val4);
15590 }
15591 {
15592 PyThreadState* __tstate = wxPyBeginAllowThreads();
15593 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15594 wxPyEndAllowThreads(__tstate);
15595 if (PyErr_Occurred()) SWIG_fail;
15596 }
15597 {
15598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15599 }
15600 {
15601 if (created2) delete arg2;
15602 }
15603 return resultobj;
15604 fail:
15605 {
15606 if (created2) delete arg2;
15607 }
15608 return NULL;
15609 }
15610
15611
15612 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15613 PyObject *resultobj = 0;
15614 wxImage *arg1 = (wxImage *) 0 ;
15615 wxInputStream *arg2 = 0 ;
15616 wxString *arg3 = 0 ;
15617 int arg4 = (int) -1 ;
15618 bool result;
15619 void *argp1 = 0 ;
15620 int res1 = 0 ;
15621 wxPyInputStream *temp2 ;
15622 bool created2 ;
15623 bool temp3 = false ;
15624 int val4 ;
15625 int ecode4 = 0 ;
15626 PyObject * obj0 = 0 ;
15627 PyObject * obj1 = 0 ;
15628 PyObject * obj2 = 0 ;
15629 PyObject * obj3 = 0 ;
15630 char * kwnames[] = {
15631 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15632 };
15633
15634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15636 if (!SWIG_IsOK(res1)) {
15637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15638 }
15639 arg1 = reinterpret_cast< wxImage * >(argp1);
15640 {
15641 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15642 arg2 = temp2->m_wxis;
15643 created2 = false;
15644 } else {
15645 PyErr_Clear(); // clear the failure of the wxPyConvert above
15646 arg2 = wxPyCBInputStream_create(obj1, false);
15647 if (arg2 == NULL) {
15648 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15649 SWIG_fail;
15650 }
15651 created2 = true;
15652 }
15653 }
15654 {
15655 arg3 = wxString_in_helper(obj2);
15656 if (arg3 == NULL) SWIG_fail;
15657 temp3 = true;
15658 }
15659 if (obj3) {
15660 ecode4 = SWIG_AsVal_int(obj3, &val4);
15661 if (!SWIG_IsOK(ecode4)) {
15662 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15663 }
15664 arg4 = static_cast< int >(val4);
15665 }
15666 {
15667 PyThreadState* __tstate = wxPyBeginAllowThreads();
15668 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15669 wxPyEndAllowThreads(__tstate);
15670 if (PyErr_Occurred()) SWIG_fail;
15671 }
15672 {
15673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15674 }
15675 {
15676 if (created2) delete arg2;
15677 }
15678 {
15679 if (temp3)
15680 delete arg3;
15681 }
15682 return resultobj;
15683 fail:
15684 {
15685 if (created2) delete arg2;
15686 }
15687 {
15688 if (temp3)
15689 delete arg3;
15690 }
15691 return NULL;
15692 }
15693
15694
15695 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15696 PyObject *resultobj = 0;
15697 wxImage *arg1 = (wxImage *) 0 ;
15698 bool result;
15699 void *argp1 = 0 ;
15700 int res1 = 0 ;
15701 PyObject *swig_obj[1] ;
15702
15703 if (!args) SWIG_fail;
15704 swig_obj[0] = args;
15705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15706 if (!SWIG_IsOK(res1)) {
15707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
15708 }
15709 arg1 = reinterpret_cast< wxImage * >(argp1);
15710 {
15711 PyThreadState* __tstate = wxPyBeginAllowThreads();
15712 result = (bool)(arg1)->IsOk();
15713 wxPyEndAllowThreads(__tstate);
15714 if (PyErr_Occurred()) SWIG_fail;
15715 }
15716 {
15717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15718 }
15719 return resultobj;
15720 fail:
15721 return NULL;
15722 }
15723
15724
15725 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15726 PyObject *resultobj = 0;
15727 wxImage *arg1 = (wxImage *) 0 ;
15728 int result;
15729 void *argp1 = 0 ;
15730 int res1 = 0 ;
15731 PyObject *swig_obj[1] ;
15732
15733 if (!args) SWIG_fail;
15734 swig_obj[0] = args;
15735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15736 if (!SWIG_IsOK(res1)) {
15737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15738 }
15739 arg1 = reinterpret_cast< wxImage * >(argp1);
15740 {
15741 PyThreadState* __tstate = wxPyBeginAllowThreads();
15742 result = (int)(arg1)->GetWidth();
15743 wxPyEndAllowThreads(__tstate);
15744 if (PyErr_Occurred()) SWIG_fail;
15745 }
15746 resultobj = SWIG_From_int(static_cast< int >(result));
15747 return resultobj;
15748 fail:
15749 return NULL;
15750 }
15751
15752
15753 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15754 PyObject *resultobj = 0;
15755 wxImage *arg1 = (wxImage *) 0 ;
15756 int result;
15757 void *argp1 = 0 ;
15758 int res1 = 0 ;
15759 PyObject *swig_obj[1] ;
15760
15761 if (!args) SWIG_fail;
15762 swig_obj[0] = args;
15763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15764 if (!SWIG_IsOK(res1)) {
15765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15766 }
15767 arg1 = reinterpret_cast< wxImage * >(argp1);
15768 {
15769 PyThreadState* __tstate = wxPyBeginAllowThreads();
15770 result = (int)(arg1)->GetHeight();
15771 wxPyEndAllowThreads(__tstate);
15772 if (PyErr_Occurred()) SWIG_fail;
15773 }
15774 resultobj = SWIG_From_int(static_cast< int >(result));
15775 return resultobj;
15776 fail:
15777 return NULL;
15778 }
15779
15780
15781 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15782 PyObject *resultobj = 0;
15783 wxImage *arg1 = (wxImage *) 0 ;
15784 wxSize result;
15785 void *argp1 = 0 ;
15786 int res1 = 0 ;
15787 PyObject *swig_obj[1] ;
15788
15789 if (!args) SWIG_fail;
15790 swig_obj[0] = args;
15791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15792 if (!SWIG_IsOK(res1)) {
15793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15794 }
15795 arg1 = reinterpret_cast< wxImage * >(argp1);
15796 {
15797 PyThreadState* __tstate = wxPyBeginAllowThreads();
15798 result = wxImage_GetSize(arg1);
15799 wxPyEndAllowThreads(__tstate);
15800 if (PyErr_Occurred()) SWIG_fail;
15801 }
15802 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15803 return resultobj;
15804 fail:
15805 return NULL;
15806 }
15807
15808
15809 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15810 PyObject *resultobj = 0;
15811 wxImage *arg1 = (wxImage *) 0 ;
15812 wxRect *arg2 = 0 ;
15813 SwigValueWrapper<wxImage > result;
15814 void *argp1 = 0 ;
15815 int res1 = 0 ;
15816 wxRect temp2 ;
15817 PyObject * obj0 = 0 ;
15818 PyObject * obj1 = 0 ;
15819 char * kwnames[] = {
15820 (char *) "self",(char *) "rect", NULL
15821 };
15822
15823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15825 if (!SWIG_IsOK(res1)) {
15826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15827 }
15828 arg1 = reinterpret_cast< wxImage * >(argp1);
15829 {
15830 arg2 = &temp2;
15831 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15832 }
15833 {
15834 PyThreadState* __tstate = wxPyBeginAllowThreads();
15835 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15836 wxPyEndAllowThreads(__tstate);
15837 if (PyErr_Occurred()) SWIG_fail;
15838 }
15839 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15840 return resultobj;
15841 fail:
15842 return NULL;
15843 }
15844
15845
15846 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15847 PyObject *resultobj = 0;
15848 wxImage *arg1 = (wxImage *) 0 ;
15849 wxSize *arg2 = 0 ;
15850 wxPoint *arg3 = 0 ;
15851 int arg4 = (int) -1 ;
15852 int arg5 = (int) -1 ;
15853 int arg6 = (int) -1 ;
15854 SwigValueWrapper<wxImage > result;
15855 void *argp1 = 0 ;
15856 int res1 = 0 ;
15857 wxSize temp2 ;
15858 wxPoint temp3 ;
15859 int val4 ;
15860 int ecode4 = 0 ;
15861 int val5 ;
15862 int ecode5 = 0 ;
15863 int val6 ;
15864 int ecode6 = 0 ;
15865 PyObject * obj0 = 0 ;
15866 PyObject * obj1 = 0 ;
15867 PyObject * obj2 = 0 ;
15868 PyObject * obj3 = 0 ;
15869 PyObject * obj4 = 0 ;
15870 PyObject * obj5 = 0 ;
15871 char * kwnames[] = {
15872 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15873 };
15874
15875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15877 if (!SWIG_IsOK(res1)) {
15878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15879 }
15880 arg1 = reinterpret_cast< wxImage * >(argp1);
15881 {
15882 arg2 = &temp2;
15883 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15884 }
15885 {
15886 arg3 = &temp3;
15887 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15888 }
15889 if (obj3) {
15890 ecode4 = SWIG_AsVal_int(obj3, &val4);
15891 if (!SWIG_IsOK(ecode4)) {
15892 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15893 }
15894 arg4 = static_cast< int >(val4);
15895 }
15896 if (obj4) {
15897 ecode5 = SWIG_AsVal_int(obj4, &val5);
15898 if (!SWIG_IsOK(ecode5)) {
15899 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15900 }
15901 arg5 = static_cast< int >(val5);
15902 }
15903 if (obj5) {
15904 ecode6 = SWIG_AsVal_int(obj5, &val6);
15905 if (!SWIG_IsOK(ecode6)) {
15906 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15907 }
15908 arg6 = static_cast< int >(val6);
15909 }
15910 {
15911 PyThreadState* __tstate = wxPyBeginAllowThreads();
15912 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15913 wxPyEndAllowThreads(__tstate);
15914 if (PyErr_Occurred()) SWIG_fail;
15915 }
15916 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15917 return resultobj;
15918 fail:
15919 return NULL;
15920 }
15921
15922
15923 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15924 PyObject *resultobj = 0;
15925 wxImage *arg1 = (wxImage *) 0 ;
15926 SwigValueWrapper<wxImage > result;
15927 void *argp1 = 0 ;
15928 int res1 = 0 ;
15929 PyObject *swig_obj[1] ;
15930
15931 if (!args) SWIG_fail;
15932 swig_obj[0] = args;
15933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15934 if (!SWIG_IsOK(res1)) {
15935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15936 }
15937 arg1 = reinterpret_cast< wxImage * >(argp1);
15938 {
15939 PyThreadState* __tstate = wxPyBeginAllowThreads();
15940 result = (arg1)->Copy();
15941 wxPyEndAllowThreads(__tstate);
15942 if (PyErr_Occurred()) SWIG_fail;
15943 }
15944 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15945 return resultobj;
15946 fail:
15947 return NULL;
15948 }
15949
15950
15951 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15952 PyObject *resultobj = 0;
15953 wxImage *arg1 = (wxImage *) 0 ;
15954 wxImage *arg2 = 0 ;
15955 int arg3 ;
15956 int arg4 ;
15957 void *argp1 = 0 ;
15958 int res1 = 0 ;
15959 void *argp2 = 0 ;
15960 int res2 = 0 ;
15961 int val3 ;
15962 int ecode3 = 0 ;
15963 int val4 ;
15964 int ecode4 = 0 ;
15965 PyObject * obj0 = 0 ;
15966 PyObject * obj1 = 0 ;
15967 PyObject * obj2 = 0 ;
15968 PyObject * obj3 = 0 ;
15969 char * kwnames[] = {
15970 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15971 };
15972
15973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15975 if (!SWIG_IsOK(res1)) {
15976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15977 }
15978 arg1 = reinterpret_cast< wxImage * >(argp1);
15979 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15980 if (!SWIG_IsOK(res2)) {
15981 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15982 }
15983 if (!argp2) {
15984 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15985 }
15986 arg2 = reinterpret_cast< wxImage * >(argp2);
15987 ecode3 = SWIG_AsVal_int(obj2, &val3);
15988 if (!SWIG_IsOK(ecode3)) {
15989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15990 }
15991 arg3 = static_cast< int >(val3);
15992 ecode4 = SWIG_AsVal_int(obj3, &val4);
15993 if (!SWIG_IsOK(ecode4)) {
15994 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15995 }
15996 arg4 = static_cast< int >(val4);
15997 {
15998 PyThreadState* __tstate = wxPyBeginAllowThreads();
15999 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
16000 wxPyEndAllowThreads(__tstate);
16001 if (PyErr_Occurred()) SWIG_fail;
16002 }
16003 resultobj = SWIG_Py_Void();
16004 return resultobj;
16005 fail:
16006 return NULL;
16007 }
16008
16009
16010 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16011 PyObject *resultobj = 0;
16012 wxImage *arg1 = (wxImage *) 0 ;
16013 PyObject *result = 0 ;
16014 void *argp1 = 0 ;
16015 int res1 = 0 ;
16016 PyObject *swig_obj[1] ;
16017
16018 if (!args) SWIG_fail;
16019 swig_obj[0] = args;
16020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16021 if (!SWIG_IsOK(res1)) {
16022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
16023 }
16024 arg1 = reinterpret_cast< wxImage * >(argp1);
16025 {
16026 PyThreadState* __tstate = wxPyBeginAllowThreads();
16027 result = (PyObject *)wxImage_GetData(arg1);
16028 wxPyEndAllowThreads(__tstate);
16029 if (PyErr_Occurred()) SWIG_fail;
16030 }
16031 resultobj = result;
16032 return resultobj;
16033 fail:
16034 return NULL;
16035 }
16036
16037
16038 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16039 PyObject *resultobj = 0;
16040 wxImage *arg1 = (wxImage *) 0 ;
16041 buffer arg2 ;
16042 int arg3 ;
16043 void *argp1 = 0 ;
16044 int res1 = 0 ;
16045 Py_ssize_t temp2 ;
16046 PyObject * obj0 = 0 ;
16047 PyObject * obj1 = 0 ;
16048 char * kwnames[] = {
16049 (char *) "self",(char *) "data", NULL
16050 };
16051
16052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
16053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16054 if (!SWIG_IsOK(res1)) {
16055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
16056 }
16057 arg1 = reinterpret_cast< wxImage * >(argp1);
16058 {
16059 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16060 arg3 = (int)temp2;
16061 }
16062 {
16063 PyThreadState* __tstate = wxPyBeginAllowThreads();
16064 wxImage_SetData(arg1,arg2,arg3);
16065 wxPyEndAllowThreads(__tstate);
16066 if (PyErr_Occurred()) SWIG_fail;
16067 }
16068 resultobj = SWIG_Py_Void();
16069 return resultobj;
16070 fail:
16071 return NULL;
16072 }
16073
16074
16075 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16076 PyObject *resultobj = 0;
16077 wxImage *arg1 = (wxImage *) 0 ;
16078 PyObject *result = 0 ;
16079 void *argp1 = 0 ;
16080 int res1 = 0 ;
16081 PyObject *swig_obj[1] ;
16082
16083 if (!args) SWIG_fail;
16084 swig_obj[0] = args;
16085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16086 if (!SWIG_IsOK(res1)) {
16087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16088 }
16089 arg1 = reinterpret_cast< wxImage * >(argp1);
16090 {
16091 PyThreadState* __tstate = wxPyBeginAllowThreads();
16092 result = (PyObject *)wxImage_GetDataBuffer(arg1);
16093 wxPyEndAllowThreads(__tstate);
16094 if (PyErr_Occurred()) SWIG_fail;
16095 }
16096 resultobj = result;
16097 return resultobj;
16098 fail:
16099 return NULL;
16100 }
16101
16102
16103 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16104 PyObject *resultobj = 0;
16105 wxImage *arg1 = (wxImage *) 0 ;
16106 buffer arg2 ;
16107 int arg3 ;
16108 void *argp1 = 0 ;
16109 int res1 = 0 ;
16110 Py_ssize_t temp2 ;
16111 PyObject * obj0 = 0 ;
16112 PyObject * obj1 = 0 ;
16113 char * kwnames[] = {
16114 (char *) "self",(char *) "data", NULL
16115 };
16116
16117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
16118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16119 if (!SWIG_IsOK(res1)) {
16120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16121 }
16122 arg1 = reinterpret_cast< wxImage * >(argp1);
16123 {
16124 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16125 arg3 = (int)temp2;
16126 }
16127 {
16128 PyThreadState* __tstate = wxPyBeginAllowThreads();
16129 wxImage_SetDataBuffer(arg1,arg2,arg3);
16130 wxPyEndAllowThreads(__tstate);
16131 if (PyErr_Occurred()) SWIG_fail;
16132 }
16133 resultobj = SWIG_Py_Void();
16134 return resultobj;
16135 fail:
16136 return NULL;
16137 }
16138
16139
16140 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16141 PyObject *resultobj = 0;
16142 wxImage *arg1 = (wxImage *) 0 ;
16143 PyObject *result = 0 ;
16144 void *argp1 = 0 ;
16145 int res1 = 0 ;
16146 PyObject *swig_obj[1] ;
16147
16148 if (!args) SWIG_fail;
16149 swig_obj[0] = args;
16150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16151 if (!SWIG_IsOK(res1)) {
16152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
16153 }
16154 arg1 = reinterpret_cast< wxImage * >(argp1);
16155 {
16156 PyThreadState* __tstate = wxPyBeginAllowThreads();
16157 result = (PyObject *)wxImage_GetAlphaData(arg1);
16158 wxPyEndAllowThreads(__tstate);
16159 if (PyErr_Occurred()) SWIG_fail;
16160 }
16161 resultobj = result;
16162 return resultobj;
16163 fail:
16164 return NULL;
16165 }
16166
16167
16168 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16169 PyObject *resultobj = 0;
16170 wxImage *arg1 = (wxImage *) 0 ;
16171 buffer arg2 ;
16172 int arg3 ;
16173 void *argp1 = 0 ;
16174 int res1 = 0 ;
16175 Py_ssize_t temp2 ;
16176 PyObject * obj0 = 0 ;
16177 PyObject * obj1 = 0 ;
16178 char * kwnames[] = {
16179 (char *) "self",(char *) "alpha", NULL
16180 };
16181
16182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
16183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16184 if (!SWIG_IsOK(res1)) {
16185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
16186 }
16187 arg1 = reinterpret_cast< wxImage * >(argp1);
16188 {
16189 if (obj1 != Py_None) {
16190 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16191 arg3 = (int)temp2;
16192 }
16193 }
16194 {
16195 PyThreadState* __tstate = wxPyBeginAllowThreads();
16196 wxImage_SetAlphaData(arg1,arg2,arg3);
16197 wxPyEndAllowThreads(__tstate);
16198 if (PyErr_Occurred()) SWIG_fail;
16199 }
16200 resultobj = SWIG_Py_Void();
16201 return resultobj;
16202 fail:
16203 return NULL;
16204 }
16205
16206
16207 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16208 PyObject *resultobj = 0;
16209 wxImage *arg1 = (wxImage *) 0 ;
16210 PyObject *result = 0 ;
16211 void *argp1 = 0 ;
16212 int res1 = 0 ;
16213 PyObject *swig_obj[1] ;
16214
16215 if (!args) SWIG_fail;
16216 swig_obj[0] = args;
16217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16218 if (!SWIG_IsOK(res1)) {
16219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16220 }
16221 arg1 = reinterpret_cast< wxImage * >(argp1);
16222 {
16223 PyThreadState* __tstate = wxPyBeginAllowThreads();
16224 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
16225 wxPyEndAllowThreads(__tstate);
16226 if (PyErr_Occurred()) SWIG_fail;
16227 }
16228 resultobj = result;
16229 return resultobj;
16230 fail:
16231 return NULL;
16232 }
16233
16234
16235 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16236 PyObject *resultobj = 0;
16237 wxImage *arg1 = (wxImage *) 0 ;
16238 buffer arg2 ;
16239 int arg3 ;
16240 void *argp1 = 0 ;
16241 int res1 = 0 ;
16242 Py_ssize_t temp2 ;
16243 PyObject * obj0 = 0 ;
16244 PyObject * obj1 = 0 ;
16245 char * kwnames[] = {
16246 (char *) "self",(char *) "alpha", NULL
16247 };
16248
16249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
16250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16251 if (!SWIG_IsOK(res1)) {
16252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16253 }
16254 arg1 = reinterpret_cast< wxImage * >(argp1);
16255 {
16256 if (obj1 != Py_None) {
16257 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16258 arg3 = (int)temp2;
16259 }
16260 }
16261 {
16262 PyThreadState* __tstate = wxPyBeginAllowThreads();
16263 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
16264 wxPyEndAllowThreads(__tstate);
16265 if (PyErr_Occurred()) SWIG_fail;
16266 }
16267 resultobj = SWIG_Py_Void();
16268 return resultobj;
16269 fail:
16270 return NULL;
16271 }
16272
16273
16274 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16275 PyObject *resultobj = 0;
16276 wxImage *arg1 = (wxImage *) 0 ;
16277 byte arg2 ;
16278 byte arg3 ;
16279 byte arg4 ;
16280 void *argp1 = 0 ;
16281 int res1 = 0 ;
16282 unsigned char val2 ;
16283 int ecode2 = 0 ;
16284 unsigned char val3 ;
16285 int ecode3 = 0 ;
16286 unsigned char val4 ;
16287 int ecode4 = 0 ;
16288 PyObject * obj0 = 0 ;
16289 PyObject * obj1 = 0 ;
16290 PyObject * obj2 = 0 ;
16291 PyObject * obj3 = 0 ;
16292 char * kwnames[] = {
16293 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16294 };
16295
16296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16298 if (!SWIG_IsOK(res1)) {
16299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
16300 }
16301 arg1 = reinterpret_cast< wxImage * >(argp1);
16302 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16303 if (!SWIG_IsOK(ecode2)) {
16304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
16305 }
16306 arg2 = static_cast< byte >(val2);
16307 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16308 if (!SWIG_IsOK(ecode3)) {
16309 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
16310 }
16311 arg3 = static_cast< byte >(val3);
16312 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16313 if (!SWIG_IsOK(ecode4)) {
16314 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
16315 }
16316 arg4 = static_cast< byte >(val4);
16317 {
16318 PyThreadState* __tstate = wxPyBeginAllowThreads();
16319 (arg1)->SetMaskColour(arg2,arg3,arg4);
16320 wxPyEndAllowThreads(__tstate);
16321 if (PyErr_Occurred()) SWIG_fail;
16322 }
16323 resultobj = SWIG_Py_Void();
16324 return resultobj;
16325 fail:
16326 return NULL;
16327 }
16328
16329
16330 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16331 PyObject *resultobj = 0;
16332 wxImage *arg1 = (wxImage *) 0 ;
16333 byte *arg2 = (byte *) 0 ;
16334 byte *arg3 = (byte *) 0 ;
16335 byte *arg4 = (byte *) 0 ;
16336 void *argp1 = 0 ;
16337 int res1 = 0 ;
16338 byte temp2 ;
16339 int res2 = SWIG_TMPOBJ ;
16340 byte temp3 ;
16341 int res3 = SWIG_TMPOBJ ;
16342 byte temp4 ;
16343 int res4 = SWIG_TMPOBJ ;
16344 PyObject *swig_obj[1] ;
16345
16346 arg2 = &temp2;
16347 arg3 = &temp3;
16348 arg4 = &temp4;
16349 if (!args) SWIG_fail;
16350 swig_obj[0] = args;
16351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16352 if (!SWIG_IsOK(res1)) {
16353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
16354 }
16355 arg1 = reinterpret_cast< wxImage * >(argp1);
16356 {
16357 PyThreadState* __tstate = wxPyBeginAllowThreads();
16358 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
16359 wxPyEndAllowThreads(__tstate);
16360 if (PyErr_Occurred()) SWIG_fail;
16361 }
16362 resultobj = SWIG_Py_Void();
16363 if (SWIG_IsTmpObj(res2)) {
16364 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
16365 } else {
16366 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16367 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
16368 }
16369 if (SWIG_IsTmpObj(res3)) {
16370 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
16371 } else {
16372 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16373 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
16374 }
16375 if (SWIG_IsTmpObj(res4)) {
16376 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
16377 } else {
16378 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16379 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
16380 }
16381 return resultobj;
16382 fail:
16383 return NULL;
16384 }
16385
16386
16387 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16388 PyObject *resultobj = 0;
16389 wxImage *arg1 = (wxImage *) 0 ;
16390 byte result;
16391 void *argp1 = 0 ;
16392 int res1 = 0 ;
16393 PyObject *swig_obj[1] ;
16394
16395 if (!args) SWIG_fail;
16396 swig_obj[0] = args;
16397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16398 if (!SWIG_IsOK(res1)) {
16399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
16400 }
16401 arg1 = reinterpret_cast< wxImage * >(argp1);
16402 {
16403 PyThreadState* __tstate = wxPyBeginAllowThreads();
16404 result = (byte)(arg1)->GetMaskRed();
16405 wxPyEndAllowThreads(__tstate);
16406 if (PyErr_Occurred()) SWIG_fail;
16407 }
16408 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16409 return resultobj;
16410 fail:
16411 return NULL;
16412 }
16413
16414
16415 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16416 PyObject *resultobj = 0;
16417 wxImage *arg1 = (wxImage *) 0 ;
16418 byte result;
16419 void *argp1 = 0 ;
16420 int res1 = 0 ;
16421 PyObject *swig_obj[1] ;
16422
16423 if (!args) SWIG_fail;
16424 swig_obj[0] = args;
16425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16426 if (!SWIG_IsOK(res1)) {
16427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16428 }
16429 arg1 = reinterpret_cast< wxImage * >(argp1);
16430 {
16431 PyThreadState* __tstate = wxPyBeginAllowThreads();
16432 result = (byte)(arg1)->GetMaskGreen();
16433 wxPyEndAllowThreads(__tstate);
16434 if (PyErr_Occurred()) SWIG_fail;
16435 }
16436 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16437 return resultobj;
16438 fail:
16439 return NULL;
16440 }
16441
16442
16443 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16444 PyObject *resultobj = 0;
16445 wxImage *arg1 = (wxImage *) 0 ;
16446 byte result;
16447 void *argp1 = 0 ;
16448 int res1 = 0 ;
16449 PyObject *swig_obj[1] ;
16450
16451 if (!args) SWIG_fail;
16452 swig_obj[0] = args;
16453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16454 if (!SWIG_IsOK(res1)) {
16455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16456 }
16457 arg1 = reinterpret_cast< wxImage * >(argp1);
16458 {
16459 PyThreadState* __tstate = wxPyBeginAllowThreads();
16460 result = (byte)(arg1)->GetMaskBlue();
16461 wxPyEndAllowThreads(__tstate);
16462 if (PyErr_Occurred()) SWIG_fail;
16463 }
16464 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16465 return resultobj;
16466 fail:
16467 return NULL;
16468 }
16469
16470
16471 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16472 PyObject *resultobj = 0;
16473 wxImage *arg1 = (wxImage *) 0 ;
16474 bool arg2 = (bool) true ;
16475 void *argp1 = 0 ;
16476 int res1 = 0 ;
16477 bool val2 ;
16478 int ecode2 = 0 ;
16479 PyObject * obj0 = 0 ;
16480 PyObject * obj1 = 0 ;
16481 char * kwnames[] = {
16482 (char *) "self",(char *) "mask", NULL
16483 };
16484
16485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
16486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16487 if (!SWIG_IsOK(res1)) {
16488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
16489 }
16490 arg1 = reinterpret_cast< wxImage * >(argp1);
16491 if (obj1) {
16492 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16493 if (!SWIG_IsOK(ecode2)) {
16494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
16495 }
16496 arg2 = static_cast< bool >(val2);
16497 }
16498 {
16499 PyThreadState* __tstate = wxPyBeginAllowThreads();
16500 (arg1)->SetMask(arg2);
16501 wxPyEndAllowThreads(__tstate);
16502 if (PyErr_Occurred()) SWIG_fail;
16503 }
16504 resultobj = SWIG_Py_Void();
16505 return resultobj;
16506 fail:
16507 return NULL;
16508 }
16509
16510
16511 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16512 PyObject *resultobj = 0;
16513 wxImage *arg1 = (wxImage *) 0 ;
16514 bool result;
16515 void *argp1 = 0 ;
16516 int res1 = 0 ;
16517 PyObject *swig_obj[1] ;
16518
16519 if (!args) SWIG_fail;
16520 swig_obj[0] = args;
16521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16522 if (!SWIG_IsOK(res1)) {
16523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
16524 }
16525 arg1 = reinterpret_cast< wxImage * >(argp1);
16526 {
16527 PyThreadState* __tstate = wxPyBeginAllowThreads();
16528 result = (bool)(arg1)->HasMask();
16529 wxPyEndAllowThreads(__tstate);
16530 if (PyErr_Occurred()) SWIG_fail;
16531 }
16532 {
16533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16534 }
16535 return resultobj;
16536 fail:
16537 return NULL;
16538 }
16539
16540
16541 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16542 PyObject *resultobj = 0;
16543 wxImage *arg1 = (wxImage *) 0 ;
16544 double arg2 ;
16545 wxPoint *arg3 = 0 ;
16546 bool arg4 = (bool) true ;
16547 wxPoint *arg5 = (wxPoint *) NULL ;
16548 SwigValueWrapper<wxImage > result;
16549 void *argp1 = 0 ;
16550 int res1 = 0 ;
16551 double val2 ;
16552 int ecode2 = 0 ;
16553 wxPoint temp3 ;
16554 bool val4 ;
16555 int ecode4 = 0 ;
16556 void *argp5 = 0 ;
16557 int res5 = 0 ;
16558 PyObject * obj0 = 0 ;
16559 PyObject * obj1 = 0 ;
16560 PyObject * obj2 = 0 ;
16561 PyObject * obj3 = 0 ;
16562 PyObject * obj4 = 0 ;
16563 char * kwnames[] = {
16564 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16565 };
16566
16567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16569 if (!SWIG_IsOK(res1)) {
16570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16571 }
16572 arg1 = reinterpret_cast< wxImage * >(argp1);
16573 ecode2 = SWIG_AsVal_double(obj1, &val2);
16574 if (!SWIG_IsOK(ecode2)) {
16575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16576 }
16577 arg2 = static_cast< double >(val2);
16578 {
16579 arg3 = &temp3;
16580 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16581 }
16582 if (obj3) {
16583 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16584 if (!SWIG_IsOK(ecode4)) {
16585 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16586 }
16587 arg4 = static_cast< bool >(val4);
16588 }
16589 if (obj4) {
16590 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16591 if (!SWIG_IsOK(res5)) {
16592 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16593 }
16594 arg5 = reinterpret_cast< wxPoint * >(argp5);
16595 }
16596 {
16597 PyThreadState* __tstate = wxPyBeginAllowThreads();
16598 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16599 wxPyEndAllowThreads(__tstate);
16600 if (PyErr_Occurred()) SWIG_fail;
16601 }
16602 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16603 return resultobj;
16604 fail:
16605 return NULL;
16606 }
16607
16608
16609 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16610 PyObject *resultobj = 0;
16611 wxImage *arg1 = (wxImage *) 0 ;
16612 bool arg2 = (bool) true ;
16613 SwigValueWrapper<wxImage > result;
16614 void *argp1 = 0 ;
16615 int res1 = 0 ;
16616 bool val2 ;
16617 int ecode2 = 0 ;
16618 PyObject * obj0 = 0 ;
16619 PyObject * obj1 = 0 ;
16620 char * kwnames[] = {
16621 (char *) "self",(char *) "clockwise", NULL
16622 };
16623
16624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16626 if (!SWIG_IsOK(res1)) {
16627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16628 }
16629 arg1 = reinterpret_cast< wxImage * >(argp1);
16630 if (obj1) {
16631 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16632 if (!SWIG_IsOK(ecode2)) {
16633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16634 }
16635 arg2 = static_cast< bool >(val2);
16636 }
16637 {
16638 PyThreadState* __tstate = wxPyBeginAllowThreads();
16639 result = (arg1)->Rotate90(arg2);
16640 wxPyEndAllowThreads(__tstate);
16641 if (PyErr_Occurred()) SWIG_fail;
16642 }
16643 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16644 return resultobj;
16645 fail:
16646 return NULL;
16647 }
16648
16649
16650 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16651 PyObject *resultobj = 0;
16652 wxImage *arg1 = (wxImage *) 0 ;
16653 bool arg2 = (bool) true ;
16654 SwigValueWrapper<wxImage > result;
16655 void *argp1 = 0 ;
16656 int res1 = 0 ;
16657 bool val2 ;
16658 int ecode2 = 0 ;
16659 PyObject * obj0 = 0 ;
16660 PyObject * obj1 = 0 ;
16661 char * kwnames[] = {
16662 (char *) "self",(char *) "horizontally", NULL
16663 };
16664
16665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16667 if (!SWIG_IsOK(res1)) {
16668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16669 }
16670 arg1 = reinterpret_cast< wxImage * >(argp1);
16671 if (obj1) {
16672 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16673 if (!SWIG_IsOK(ecode2)) {
16674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16675 }
16676 arg2 = static_cast< bool >(val2);
16677 }
16678 {
16679 PyThreadState* __tstate = wxPyBeginAllowThreads();
16680 result = (arg1)->Mirror(arg2);
16681 wxPyEndAllowThreads(__tstate);
16682 if (PyErr_Occurred()) SWIG_fail;
16683 }
16684 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16685 return resultobj;
16686 fail:
16687 return NULL;
16688 }
16689
16690
16691 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16692 PyObject *resultobj = 0;
16693 wxImage *arg1 = (wxImage *) 0 ;
16694 byte arg2 ;
16695 byte arg3 ;
16696 byte arg4 ;
16697 byte arg5 ;
16698 byte arg6 ;
16699 byte arg7 ;
16700 void *argp1 = 0 ;
16701 int res1 = 0 ;
16702 unsigned char val2 ;
16703 int ecode2 = 0 ;
16704 unsigned char val3 ;
16705 int ecode3 = 0 ;
16706 unsigned char val4 ;
16707 int ecode4 = 0 ;
16708 unsigned char val5 ;
16709 int ecode5 = 0 ;
16710 unsigned char val6 ;
16711 int ecode6 = 0 ;
16712 unsigned char val7 ;
16713 int ecode7 = 0 ;
16714 PyObject * obj0 = 0 ;
16715 PyObject * obj1 = 0 ;
16716 PyObject * obj2 = 0 ;
16717 PyObject * obj3 = 0 ;
16718 PyObject * obj4 = 0 ;
16719 PyObject * obj5 = 0 ;
16720 PyObject * obj6 = 0 ;
16721 char * kwnames[] = {
16722 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16723 };
16724
16725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16727 if (!SWIG_IsOK(res1)) {
16728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16729 }
16730 arg1 = reinterpret_cast< wxImage * >(argp1);
16731 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16732 if (!SWIG_IsOK(ecode2)) {
16733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16734 }
16735 arg2 = static_cast< byte >(val2);
16736 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16737 if (!SWIG_IsOK(ecode3)) {
16738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16739 }
16740 arg3 = static_cast< byte >(val3);
16741 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16742 if (!SWIG_IsOK(ecode4)) {
16743 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16744 }
16745 arg4 = static_cast< byte >(val4);
16746 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16747 if (!SWIG_IsOK(ecode5)) {
16748 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16749 }
16750 arg5 = static_cast< byte >(val5);
16751 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16752 if (!SWIG_IsOK(ecode6)) {
16753 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16754 }
16755 arg6 = static_cast< byte >(val6);
16756 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16757 if (!SWIG_IsOK(ecode7)) {
16758 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16759 }
16760 arg7 = static_cast< byte >(val7);
16761 {
16762 PyThreadState* __tstate = wxPyBeginAllowThreads();
16763 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16764 wxPyEndAllowThreads(__tstate);
16765 if (PyErr_Occurred()) SWIG_fail;
16766 }
16767 resultobj = SWIG_Py_Void();
16768 return resultobj;
16769 fail:
16770 return NULL;
16771 }
16772
16773
16774 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16775 PyObject *resultobj = 0;
16776 wxImage *arg1 = (wxImage *) 0 ;
16777 double arg2 = (double) 0.299 ;
16778 double arg3 = (double) 0.587 ;
16779 double arg4 = (double) 0.114 ;
16780 SwigValueWrapper<wxImage > result;
16781 void *argp1 = 0 ;
16782 int res1 = 0 ;
16783 double val2 ;
16784 int ecode2 = 0 ;
16785 double val3 ;
16786 int ecode3 = 0 ;
16787 double val4 ;
16788 int ecode4 = 0 ;
16789 PyObject * obj0 = 0 ;
16790 PyObject * obj1 = 0 ;
16791 PyObject * obj2 = 0 ;
16792 PyObject * obj3 = 0 ;
16793 char * kwnames[] = {
16794 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16795 };
16796
16797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16799 if (!SWIG_IsOK(res1)) {
16800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16801 }
16802 arg1 = reinterpret_cast< wxImage * >(argp1);
16803 if (obj1) {
16804 ecode2 = SWIG_AsVal_double(obj1, &val2);
16805 if (!SWIG_IsOK(ecode2)) {
16806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16807 }
16808 arg2 = static_cast< double >(val2);
16809 }
16810 if (obj2) {
16811 ecode3 = SWIG_AsVal_double(obj2, &val3);
16812 if (!SWIG_IsOK(ecode3)) {
16813 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16814 }
16815 arg3 = static_cast< double >(val3);
16816 }
16817 if (obj3) {
16818 ecode4 = SWIG_AsVal_double(obj3, &val4);
16819 if (!SWIG_IsOK(ecode4)) {
16820 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16821 }
16822 arg4 = static_cast< double >(val4);
16823 }
16824 {
16825 PyThreadState* __tstate = wxPyBeginAllowThreads();
16826 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16827 wxPyEndAllowThreads(__tstate);
16828 if (PyErr_Occurred()) SWIG_fail;
16829 }
16830 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16831 return resultobj;
16832 fail:
16833 return NULL;
16834 }
16835
16836
16837 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16838 PyObject *resultobj = 0;
16839 wxImage *arg1 = (wxImage *) 0 ;
16840 byte arg2 ;
16841 byte arg3 ;
16842 byte arg4 ;
16843 SwigValueWrapper<wxImage > result;
16844 void *argp1 = 0 ;
16845 int res1 = 0 ;
16846 unsigned char val2 ;
16847 int ecode2 = 0 ;
16848 unsigned char val3 ;
16849 int ecode3 = 0 ;
16850 unsigned char val4 ;
16851 int ecode4 = 0 ;
16852 PyObject * obj0 = 0 ;
16853 PyObject * obj1 = 0 ;
16854 PyObject * obj2 = 0 ;
16855 PyObject * obj3 = 0 ;
16856 char * kwnames[] = {
16857 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16858 };
16859
16860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16862 if (!SWIG_IsOK(res1)) {
16863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16864 }
16865 arg1 = reinterpret_cast< wxImage * >(argp1);
16866 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16867 if (!SWIG_IsOK(ecode2)) {
16868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16869 }
16870 arg2 = static_cast< byte >(val2);
16871 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16872 if (!SWIG_IsOK(ecode3)) {
16873 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16874 }
16875 arg3 = static_cast< byte >(val3);
16876 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16877 if (!SWIG_IsOK(ecode4)) {
16878 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16879 }
16880 arg4 = static_cast< byte >(val4);
16881 {
16882 PyThreadState* __tstate = wxPyBeginAllowThreads();
16883 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16884 wxPyEndAllowThreads(__tstate);
16885 if (PyErr_Occurred()) SWIG_fail;
16886 }
16887 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16888 return resultobj;
16889 fail:
16890 return NULL;
16891 }
16892
16893
16894 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16895 PyObject *resultobj = 0;
16896 wxImage *arg1 = (wxImage *) 0 ;
16897 wxString *arg2 = 0 ;
16898 wxString *arg3 = 0 ;
16899 void *argp1 = 0 ;
16900 int res1 = 0 ;
16901 bool temp2 = false ;
16902 bool temp3 = false ;
16903 PyObject * obj0 = 0 ;
16904 PyObject * obj1 = 0 ;
16905 PyObject * obj2 = 0 ;
16906 char * kwnames[] = {
16907 (char *) "self",(char *) "name",(char *) "value", NULL
16908 };
16909
16910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16912 if (!SWIG_IsOK(res1)) {
16913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16914 }
16915 arg1 = reinterpret_cast< wxImage * >(argp1);
16916 {
16917 arg2 = wxString_in_helper(obj1);
16918 if (arg2 == NULL) SWIG_fail;
16919 temp2 = true;
16920 }
16921 {
16922 arg3 = wxString_in_helper(obj2);
16923 if (arg3 == NULL) SWIG_fail;
16924 temp3 = true;
16925 }
16926 {
16927 PyThreadState* __tstate = wxPyBeginAllowThreads();
16928 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16929 wxPyEndAllowThreads(__tstate);
16930 if (PyErr_Occurred()) SWIG_fail;
16931 }
16932 resultobj = SWIG_Py_Void();
16933 {
16934 if (temp2)
16935 delete arg2;
16936 }
16937 {
16938 if (temp3)
16939 delete arg3;
16940 }
16941 return resultobj;
16942 fail:
16943 {
16944 if (temp2)
16945 delete arg2;
16946 }
16947 {
16948 if (temp3)
16949 delete arg3;
16950 }
16951 return NULL;
16952 }
16953
16954
16955 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16956 PyObject *resultobj = 0;
16957 wxImage *arg1 = (wxImage *) 0 ;
16958 wxString *arg2 = 0 ;
16959 int arg3 ;
16960 void *argp1 = 0 ;
16961 int res1 = 0 ;
16962 bool temp2 = false ;
16963 int val3 ;
16964 int ecode3 = 0 ;
16965 PyObject * obj0 = 0 ;
16966 PyObject * obj1 = 0 ;
16967 PyObject * obj2 = 0 ;
16968 char * kwnames[] = {
16969 (char *) "self",(char *) "name",(char *) "value", NULL
16970 };
16971
16972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16974 if (!SWIG_IsOK(res1)) {
16975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16976 }
16977 arg1 = reinterpret_cast< wxImage * >(argp1);
16978 {
16979 arg2 = wxString_in_helper(obj1);
16980 if (arg2 == NULL) SWIG_fail;
16981 temp2 = true;
16982 }
16983 ecode3 = SWIG_AsVal_int(obj2, &val3);
16984 if (!SWIG_IsOK(ecode3)) {
16985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16986 }
16987 arg3 = static_cast< int >(val3);
16988 {
16989 PyThreadState* __tstate = wxPyBeginAllowThreads();
16990 (arg1)->SetOption((wxString const &)*arg2,arg3);
16991 wxPyEndAllowThreads(__tstate);
16992 if (PyErr_Occurred()) SWIG_fail;
16993 }
16994 resultobj = SWIG_Py_Void();
16995 {
16996 if (temp2)
16997 delete arg2;
16998 }
16999 return resultobj;
17000 fail:
17001 {
17002 if (temp2)
17003 delete arg2;
17004 }
17005 return NULL;
17006 }
17007
17008
17009 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17010 PyObject *resultobj = 0;
17011 wxImage *arg1 = (wxImage *) 0 ;
17012 wxString *arg2 = 0 ;
17013 wxString result;
17014 void *argp1 = 0 ;
17015 int res1 = 0 ;
17016 bool temp2 = false ;
17017 PyObject * obj0 = 0 ;
17018 PyObject * obj1 = 0 ;
17019 char * kwnames[] = {
17020 (char *) "self",(char *) "name", NULL
17021 };
17022
17023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
17024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17025 if (!SWIG_IsOK(res1)) {
17026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
17027 }
17028 arg1 = reinterpret_cast< wxImage * >(argp1);
17029 {
17030 arg2 = wxString_in_helper(obj1);
17031 if (arg2 == NULL) SWIG_fail;
17032 temp2 = true;
17033 }
17034 {
17035 PyThreadState* __tstate = wxPyBeginAllowThreads();
17036 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
17037 wxPyEndAllowThreads(__tstate);
17038 if (PyErr_Occurred()) SWIG_fail;
17039 }
17040 {
17041 #if wxUSE_UNICODE
17042 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17043 #else
17044 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17045 #endif
17046 }
17047 {
17048 if (temp2)
17049 delete arg2;
17050 }
17051 return resultobj;
17052 fail:
17053 {
17054 if (temp2)
17055 delete arg2;
17056 }
17057 return NULL;
17058 }
17059
17060
17061 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17062 PyObject *resultobj = 0;
17063 wxImage *arg1 = (wxImage *) 0 ;
17064 wxString *arg2 = 0 ;
17065 int result;
17066 void *argp1 = 0 ;
17067 int res1 = 0 ;
17068 bool temp2 = false ;
17069 PyObject * obj0 = 0 ;
17070 PyObject * obj1 = 0 ;
17071 char * kwnames[] = {
17072 (char *) "self",(char *) "name", NULL
17073 };
17074
17075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
17076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17077 if (!SWIG_IsOK(res1)) {
17078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
17079 }
17080 arg1 = reinterpret_cast< wxImage * >(argp1);
17081 {
17082 arg2 = wxString_in_helper(obj1);
17083 if (arg2 == NULL) SWIG_fail;
17084 temp2 = true;
17085 }
17086 {
17087 PyThreadState* __tstate = wxPyBeginAllowThreads();
17088 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
17089 wxPyEndAllowThreads(__tstate);
17090 if (PyErr_Occurred()) SWIG_fail;
17091 }
17092 resultobj = SWIG_From_int(static_cast< int >(result));
17093 {
17094 if (temp2)
17095 delete arg2;
17096 }
17097 return resultobj;
17098 fail:
17099 {
17100 if (temp2)
17101 delete arg2;
17102 }
17103 return NULL;
17104 }
17105
17106
17107 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17108 PyObject *resultobj = 0;
17109 wxImage *arg1 = (wxImage *) 0 ;
17110 wxString *arg2 = 0 ;
17111 bool result;
17112 void *argp1 = 0 ;
17113 int res1 = 0 ;
17114 bool temp2 = false ;
17115 PyObject * obj0 = 0 ;
17116 PyObject * obj1 = 0 ;
17117 char * kwnames[] = {
17118 (char *) "self",(char *) "name", NULL
17119 };
17120
17121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
17122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17123 if (!SWIG_IsOK(res1)) {
17124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
17125 }
17126 arg1 = reinterpret_cast< wxImage * >(argp1);
17127 {
17128 arg2 = wxString_in_helper(obj1);
17129 if (arg2 == NULL) SWIG_fail;
17130 temp2 = true;
17131 }
17132 {
17133 PyThreadState* __tstate = wxPyBeginAllowThreads();
17134 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
17135 wxPyEndAllowThreads(__tstate);
17136 if (PyErr_Occurred()) SWIG_fail;
17137 }
17138 {
17139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17140 }
17141 {
17142 if (temp2)
17143 delete arg2;
17144 }
17145 return resultobj;
17146 fail:
17147 {
17148 if (temp2)
17149 delete arg2;
17150 }
17151 return NULL;
17152 }
17153
17154
17155 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17156 PyObject *resultobj = 0;
17157 wxImage *arg1 = (wxImage *) 0 ;
17158 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
17159 unsigned long result;
17160 void *argp1 = 0 ;
17161 int res1 = 0 ;
17162 unsigned long val2 ;
17163 int ecode2 = 0 ;
17164 PyObject * obj0 = 0 ;
17165 PyObject * obj1 = 0 ;
17166 char * kwnames[] = {
17167 (char *) "self",(char *) "stopafter", NULL
17168 };
17169
17170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
17171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17172 if (!SWIG_IsOK(res1)) {
17173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
17174 }
17175 arg1 = reinterpret_cast< wxImage * >(argp1);
17176 if (obj1) {
17177 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
17178 if (!SWIG_IsOK(ecode2)) {
17179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
17180 }
17181 arg2 = static_cast< unsigned long >(val2);
17182 }
17183 {
17184 PyThreadState* __tstate = wxPyBeginAllowThreads();
17185 result = (unsigned long)(arg1)->CountColours(arg2);
17186 wxPyEndAllowThreads(__tstate);
17187 if (PyErr_Occurred()) SWIG_fail;
17188 }
17189 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
17190 return resultobj;
17191 fail:
17192 return NULL;
17193 }
17194
17195
17196 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17197 PyObject *resultobj = 0;
17198 wxImage *arg1 = (wxImage *) 0 ;
17199 wxImageHistogram *arg2 = 0 ;
17200 unsigned long result;
17201 void *argp1 = 0 ;
17202 int res1 = 0 ;
17203 void *argp2 = 0 ;
17204 int res2 = 0 ;
17205 PyObject * obj0 = 0 ;
17206 PyObject * obj1 = 0 ;
17207 char * kwnames[] = {
17208 (char *) "self",(char *) "h", NULL
17209 };
17210
17211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
17212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17213 if (!SWIG_IsOK(res1)) {
17214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
17215 }
17216 arg1 = reinterpret_cast< wxImage * >(argp1);
17217 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
17218 if (!SWIG_IsOK(res2)) {
17219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
17220 }
17221 if (!argp2) {
17222 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
17223 }
17224 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
17225 {
17226 PyThreadState* __tstate = wxPyBeginAllowThreads();
17227 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
17228 wxPyEndAllowThreads(__tstate);
17229 if (PyErr_Occurred()) SWIG_fail;
17230 }
17231 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
17232 return resultobj;
17233 fail:
17234 return NULL;
17235 }
17236
17237
17238 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17239 PyObject *resultobj = 0;
17240 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
17241 void *argp1 = 0 ;
17242 int res1 = 0 ;
17243 PyObject * obj0 = 0 ;
17244 char * kwnames[] = {
17245 (char *) "handler", NULL
17246 };
17247
17248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
17249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
17250 if (!SWIG_IsOK(res1)) {
17251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
17252 }
17253 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
17254 {
17255 PyThreadState* __tstate = wxPyBeginAllowThreads();
17256 wxImage::AddHandler(arg1);
17257 wxPyEndAllowThreads(__tstate);
17258 if (PyErr_Occurred()) SWIG_fail;
17259 }
17260 resultobj = SWIG_Py_Void();
17261 return resultobj;
17262 fail:
17263 return NULL;
17264 }
17265
17266
17267 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17268 PyObject *resultobj = 0;
17269 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
17270 void *argp1 = 0 ;
17271 int res1 = 0 ;
17272 PyObject * obj0 = 0 ;
17273 char * kwnames[] = {
17274 (char *) "handler", NULL
17275 };
17276
17277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
17278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
17279 if (!SWIG_IsOK(res1)) {
17280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
17281 }
17282 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
17283 {
17284 PyThreadState* __tstate = wxPyBeginAllowThreads();
17285 wxImage::InsertHandler(arg1);
17286 wxPyEndAllowThreads(__tstate);
17287 if (PyErr_Occurred()) SWIG_fail;
17288 }
17289 resultobj = SWIG_Py_Void();
17290 return resultobj;
17291 fail:
17292 return NULL;
17293 }
17294
17295
17296 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17297 PyObject *resultobj = 0;
17298 wxString *arg1 = 0 ;
17299 bool result;
17300 bool temp1 = false ;
17301 PyObject * obj0 = 0 ;
17302 char * kwnames[] = {
17303 (char *) "name", NULL
17304 };
17305
17306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
17307 {
17308 arg1 = wxString_in_helper(obj0);
17309 if (arg1 == NULL) SWIG_fail;
17310 temp1 = true;
17311 }
17312 {
17313 PyThreadState* __tstate = wxPyBeginAllowThreads();
17314 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
17315 wxPyEndAllowThreads(__tstate);
17316 if (PyErr_Occurred()) SWIG_fail;
17317 }
17318 {
17319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17320 }
17321 {
17322 if (temp1)
17323 delete arg1;
17324 }
17325 return resultobj;
17326 fail:
17327 {
17328 if (temp1)
17329 delete arg1;
17330 }
17331 return NULL;
17332 }
17333
17334
17335 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17336 PyObject *resultobj = 0;
17337 PyObject *result = 0 ;
17338
17339 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
17340 {
17341 PyThreadState* __tstate = wxPyBeginAllowThreads();
17342 result = (PyObject *)wxImage_GetHandlers();
17343 wxPyEndAllowThreads(__tstate);
17344 if (PyErr_Occurred()) SWIG_fail;
17345 }
17346 resultobj = result;
17347 return resultobj;
17348 fail:
17349 return NULL;
17350 }
17351
17352
17353 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17354 PyObject *resultobj = 0;
17355 wxString result;
17356
17357 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
17358 {
17359 PyThreadState* __tstate = wxPyBeginAllowThreads();
17360 result = wxImage::GetImageExtWildcard();
17361 wxPyEndAllowThreads(__tstate);
17362 if (PyErr_Occurred()) SWIG_fail;
17363 }
17364 {
17365 #if wxUSE_UNICODE
17366 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17367 #else
17368 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17369 #endif
17370 }
17371 return resultobj;
17372 fail:
17373 return NULL;
17374 }
17375
17376
17377 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17378 PyObject *resultobj = 0;
17379 wxImage *arg1 = (wxImage *) 0 ;
17380 int arg2 = (int) -1 ;
17381 wxBitmap result;
17382 void *argp1 = 0 ;
17383 int res1 = 0 ;
17384 int val2 ;
17385 int ecode2 = 0 ;
17386 PyObject * obj0 = 0 ;
17387 PyObject * obj1 = 0 ;
17388 char * kwnames[] = {
17389 (char *) "self",(char *) "depth", NULL
17390 };
17391
17392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
17393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17394 if (!SWIG_IsOK(res1)) {
17395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17396 }
17397 arg1 = reinterpret_cast< wxImage * >(argp1);
17398 if (obj1) {
17399 ecode2 = SWIG_AsVal_int(obj1, &val2);
17400 if (!SWIG_IsOK(ecode2)) {
17401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
17402 }
17403 arg2 = static_cast< int >(val2);
17404 }
17405 {
17406 if (!wxPyCheckForApp()) SWIG_fail;
17407 PyThreadState* __tstate = wxPyBeginAllowThreads();
17408 result = wxImage_ConvertToBitmap(arg1,arg2);
17409 wxPyEndAllowThreads(__tstate);
17410 if (PyErr_Occurred()) SWIG_fail;
17411 }
17412 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17413 return resultobj;
17414 fail:
17415 return NULL;
17416 }
17417
17418
17419 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17420 PyObject *resultobj = 0;
17421 wxImage *arg1 = (wxImage *) 0 ;
17422 byte arg2 ;
17423 byte arg3 ;
17424 byte arg4 ;
17425 wxBitmap result;
17426 void *argp1 = 0 ;
17427 int res1 = 0 ;
17428 unsigned char val2 ;
17429 int ecode2 = 0 ;
17430 unsigned char val3 ;
17431 int ecode3 = 0 ;
17432 unsigned char val4 ;
17433 int ecode4 = 0 ;
17434 PyObject * obj0 = 0 ;
17435 PyObject * obj1 = 0 ;
17436 PyObject * obj2 = 0 ;
17437 PyObject * obj3 = 0 ;
17438 char * kwnames[] = {
17439 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
17440 };
17441
17442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17444 if (!SWIG_IsOK(res1)) {
17445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17446 }
17447 arg1 = reinterpret_cast< wxImage * >(argp1);
17448 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17449 if (!SWIG_IsOK(ecode2)) {
17450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
17451 }
17452 arg2 = static_cast< byte >(val2);
17453 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17454 if (!SWIG_IsOK(ecode3)) {
17455 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
17456 }
17457 arg3 = static_cast< byte >(val3);
17458 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17459 if (!SWIG_IsOK(ecode4)) {
17460 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
17461 }
17462 arg4 = static_cast< byte >(val4);
17463 {
17464 if (!wxPyCheckForApp()) SWIG_fail;
17465 PyThreadState* __tstate = wxPyBeginAllowThreads();
17466 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
17467 wxPyEndAllowThreads(__tstate);
17468 if (PyErr_Occurred()) SWIG_fail;
17469 }
17470 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17471 return resultobj;
17472 fail:
17473 return NULL;
17474 }
17475
17476
17477 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17478 PyObject *resultobj = 0;
17479 wxImage *arg1 = (wxImage *) 0 ;
17480 double arg2 ;
17481 void *argp1 = 0 ;
17482 int res1 = 0 ;
17483 double val2 ;
17484 int ecode2 = 0 ;
17485 PyObject * obj0 = 0 ;
17486 PyObject * obj1 = 0 ;
17487 char * kwnames[] = {
17488 (char *) "self",(char *) "angle", NULL
17489 };
17490
17491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
17492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17493 if (!SWIG_IsOK(res1)) {
17494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
17495 }
17496 arg1 = reinterpret_cast< wxImage * >(argp1);
17497 ecode2 = SWIG_AsVal_double(obj1, &val2);
17498 if (!SWIG_IsOK(ecode2)) {
17499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
17500 }
17501 arg2 = static_cast< double >(val2);
17502 {
17503 PyThreadState* __tstate = wxPyBeginAllowThreads();
17504 (arg1)->RotateHue(arg2);
17505 wxPyEndAllowThreads(__tstate);
17506 if (PyErr_Occurred()) SWIG_fail;
17507 }
17508 resultobj = SWIG_Py_Void();
17509 return resultobj;
17510 fail:
17511 return NULL;
17512 }
17513
17514
17515 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17516 PyObject *resultobj = 0;
17517 wxImage_RGBValue arg1 ;
17518 wxImage_HSVValue result;
17519 void *argp1 ;
17520 int res1 = 0 ;
17521 PyObject * obj0 = 0 ;
17522 char * kwnames[] = {
17523 (char *) "rgb", NULL
17524 };
17525
17526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
17527 {
17528 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
17529 if (!SWIG_IsOK(res1)) {
17530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17531 }
17532 if (!argp1) {
17533 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17534 } else {
17535 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
17536 arg1 = *temp;
17537 if (SWIG_IsNewObj(res1)) delete temp;
17538 }
17539 }
17540 {
17541 PyThreadState* __tstate = wxPyBeginAllowThreads();
17542 result = wxImage::RGBtoHSV(arg1);
17543 wxPyEndAllowThreads(__tstate);
17544 if (PyErr_Occurred()) SWIG_fail;
17545 }
17546 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17547 return resultobj;
17548 fail:
17549 return NULL;
17550 }
17551
17552
17553 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17554 PyObject *resultobj = 0;
17555 wxImage_HSVValue arg1 ;
17556 wxImage_RGBValue result;
17557 void *argp1 ;
17558 int res1 = 0 ;
17559 PyObject * obj0 = 0 ;
17560 char * kwnames[] = {
17561 (char *) "hsv", NULL
17562 };
17563
17564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17565 {
17566 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17567 if (!SWIG_IsOK(res1)) {
17568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17569 }
17570 if (!argp1) {
17571 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17572 } else {
17573 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17574 arg1 = *temp;
17575 if (SWIG_IsNewObj(res1)) delete temp;
17576 }
17577 }
17578 {
17579 PyThreadState* __tstate = wxPyBeginAllowThreads();
17580 result = wxImage::HSVtoRGB(arg1);
17581 wxPyEndAllowThreads(__tstate);
17582 if (PyErr_Occurred()) SWIG_fail;
17583 }
17584 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17585 return resultobj;
17586 fail:
17587 return NULL;
17588 }
17589
17590
17591 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17592 PyObject *obj;
17593 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17594 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17595 return SWIG_Py_Void();
17596 }
17597
17598 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17599 return SWIG_Python_InitShadowInstance(args);
17600 }
17601
17602 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17603 PyObject *resultobj = 0;
17604 int arg1 ;
17605 int arg2 ;
17606 buffer arg3 ;
17607 int arg4 ;
17608 buffer arg5 = (buffer) NULL ;
17609 int arg6 = (int) 0 ;
17610 wxImage *result = 0 ;
17611 int val1 ;
17612 int ecode1 = 0 ;
17613 int val2 ;
17614 int ecode2 = 0 ;
17615 Py_ssize_t temp3 ;
17616 Py_ssize_t temp5 ;
17617 PyObject * obj0 = 0 ;
17618 PyObject * obj1 = 0 ;
17619 PyObject * obj2 = 0 ;
17620 PyObject * obj3 = 0 ;
17621 char * kwnames[] = {
17622 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17623 };
17624
17625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17626 ecode1 = SWIG_AsVal_int(obj0, &val1);
17627 if (!SWIG_IsOK(ecode1)) {
17628 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17629 }
17630 arg1 = static_cast< int >(val1);
17631 ecode2 = SWIG_AsVal_int(obj1, &val2);
17632 if (!SWIG_IsOK(ecode2)) {
17633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17634 }
17635 arg2 = static_cast< int >(val2);
17636 {
17637 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17638 arg4 = (int)temp3;
17639 }
17640 if (obj3) {
17641 {
17642 if (obj3 != Py_None) {
17643 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17644 arg6 = (int)temp5;
17645 }
17646 }
17647 }
17648 {
17649 PyThreadState* __tstate = wxPyBeginAllowThreads();
17650 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17651 wxPyEndAllowThreads(__tstate);
17652 if (PyErr_Occurred()) SWIG_fail;
17653 }
17654 {
17655 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17656 }
17657 return resultobj;
17658 fail:
17659 return NULL;
17660 }
17661
17662
17663 SWIGINTERN int NullImage_set(PyObject *) {
17664 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17665 return 1;
17666 }
17667
17668
17669 SWIGINTERN PyObject *NullImage_get(void) {
17670 PyObject *pyobj = 0;
17671
17672 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17673 return pyobj;
17674 }
17675
17676
17677 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17678 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17679 return 1;
17680 }
17681
17682
17683 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17684 PyObject *pyobj = 0;
17685
17686 {
17687 #if wxUSE_UNICODE
17688 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17689 #else
17690 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17691 #endif
17692 }
17693 return pyobj;
17694 }
17695
17696
17697 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17698 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17699 return 1;
17700 }
17701
17702
17703 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17704 PyObject *pyobj = 0;
17705
17706 {
17707 #if wxUSE_UNICODE
17708 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17709 #else
17710 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17711 #endif
17712 }
17713 return pyobj;
17714 }
17715
17716
17717 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17718 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17719 return 1;
17720 }
17721
17722
17723 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17724 PyObject *pyobj = 0;
17725
17726 {
17727 #if wxUSE_UNICODE
17728 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17729 #else
17730 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17731 #endif
17732 }
17733 return pyobj;
17734 }
17735
17736
17737 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17738 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17739 return 1;
17740 }
17741
17742
17743 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17744 PyObject *pyobj = 0;
17745
17746 {
17747 #if wxUSE_UNICODE
17748 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17749 #else
17750 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17751 #endif
17752 }
17753 return pyobj;
17754 }
17755
17756
17757 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17758 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17759 return 1;
17760 }
17761
17762
17763 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17764 PyObject *pyobj = 0;
17765
17766 {
17767 #if wxUSE_UNICODE
17768 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17769 #else
17770 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17771 #endif
17772 }
17773 return pyobj;
17774 }
17775
17776
17777 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17778 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17779 return 1;
17780 }
17781
17782
17783 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17784 PyObject *pyobj = 0;
17785
17786 {
17787 #if wxUSE_UNICODE
17788 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17789 #else
17790 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17791 #endif
17792 }
17793 return pyobj;
17794 }
17795
17796
17797 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17798 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17799 return 1;
17800 }
17801
17802
17803 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17804 PyObject *pyobj = 0;
17805
17806 {
17807 #if wxUSE_UNICODE
17808 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17809 #else
17810 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17811 #endif
17812 }
17813 return pyobj;
17814 }
17815
17816
17817 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17818 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17819 return 1;
17820 }
17821
17822
17823 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17824 PyObject *pyobj = 0;
17825
17826 {
17827 #if wxUSE_UNICODE
17828 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17829 #else
17830 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17831 #endif
17832 }
17833 return pyobj;
17834 }
17835
17836
17837 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17838 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17839 return 1;
17840 }
17841
17842
17843 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17844 PyObject *pyobj = 0;
17845
17846 {
17847 #if wxUSE_UNICODE
17848 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17849 #else
17850 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17851 #endif
17852 }
17853 return pyobj;
17854 }
17855
17856
17857 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17858 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17859 return 1;
17860 }
17861
17862
17863 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17864 PyObject *pyobj = 0;
17865
17866 {
17867 #if wxUSE_UNICODE
17868 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17869 #else
17870 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17871 #endif
17872 }
17873 return pyobj;
17874 }
17875
17876
17877 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17878 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17879 return 1;
17880 }
17881
17882
17883 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17884 PyObject *pyobj = 0;
17885
17886 {
17887 #if wxUSE_UNICODE
17888 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17889 #else
17890 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17891 #endif
17892 }
17893 return pyobj;
17894 }
17895
17896
17897 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17898 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17899 return 1;
17900 }
17901
17902
17903 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17904 PyObject *pyobj = 0;
17905
17906 {
17907 #if wxUSE_UNICODE
17908 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17909 #else
17910 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17911 #endif
17912 }
17913 return pyobj;
17914 }
17915
17916
17917 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17918 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17919 return 1;
17920 }
17921
17922
17923 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17924 PyObject *pyobj = 0;
17925
17926 {
17927 #if wxUSE_UNICODE
17928 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17929 #else
17930 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17931 #endif
17932 }
17933 return pyobj;
17934 }
17935
17936
17937 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17938 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17939 return 1;
17940 }
17941
17942
17943 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17944 PyObject *pyobj = 0;
17945
17946 {
17947 #if wxUSE_UNICODE
17948 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17949 #else
17950 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17951 #endif
17952 }
17953 return pyobj;
17954 }
17955
17956
17957 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17958 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17959 return 1;
17960 }
17961
17962
17963 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17964 PyObject *pyobj = 0;
17965
17966 {
17967 #if wxUSE_UNICODE
17968 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17969 #else
17970 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17971 #endif
17972 }
17973 return pyobj;
17974 }
17975
17976
17977 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17978 PyObject *resultobj = 0;
17979 wxBMPHandler *result = 0 ;
17980
17981 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17982 {
17983 PyThreadState* __tstate = wxPyBeginAllowThreads();
17984 result = (wxBMPHandler *)new wxBMPHandler();
17985 wxPyEndAllowThreads(__tstate);
17986 if (PyErr_Occurred()) SWIG_fail;
17987 }
17988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17989 return resultobj;
17990 fail:
17991 return NULL;
17992 }
17993
17994
17995 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17996 PyObject *obj;
17997 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17998 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17999 return SWIG_Py_Void();
18000 }
18001
18002 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18003 return SWIG_Python_InitShadowInstance(args);
18004 }
18005
18006 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18007 PyObject *resultobj = 0;
18008 wxICOHandler *result = 0 ;
18009
18010 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
18011 {
18012 PyThreadState* __tstate = wxPyBeginAllowThreads();
18013 result = (wxICOHandler *)new wxICOHandler();
18014 wxPyEndAllowThreads(__tstate);
18015 if (PyErr_Occurred()) SWIG_fail;
18016 }
18017 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
18018 return resultobj;
18019 fail:
18020 return NULL;
18021 }
18022
18023
18024 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18025 PyObject *obj;
18026 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18027 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
18028 return SWIG_Py_Void();
18029 }
18030
18031 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18032 return SWIG_Python_InitShadowInstance(args);
18033 }
18034
18035 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18036 PyObject *resultobj = 0;
18037 wxCURHandler *result = 0 ;
18038
18039 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
18040 {
18041 PyThreadState* __tstate = wxPyBeginAllowThreads();
18042 result = (wxCURHandler *)new wxCURHandler();
18043 wxPyEndAllowThreads(__tstate);
18044 if (PyErr_Occurred()) SWIG_fail;
18045 }
18046 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
18047 return resultobj;
18048 fail:
18049 return NULL;
18050 }
18051
18052
18053 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18054 PyObject *obj;
18055 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18056 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
18057 return SWIG_Py_Void();
18058 }
18059
18060 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18061 return SWIG_Python_InitShadowInstance(args);
18062 }
18063
18064 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18065 PyObject *resultobj = 0;
18066 wxANIHandler *result = 0 ;
18067
18068 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
18069 {
18070 PyThreadState* __tstate = wxPyBeginAllowThreads();
18071 result = (wxANIHandler *)new wxANIHandler();
18072 wxPyEndAllowThreads(__tstate);
18073 if (PyErr_Occurred()) SWIG_fail;
18074 }
18075 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
18076 return resultobj;
18077 fail:
18078 return NULL;
18079 }
18080
18081
18082 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18083 PyObject *obj;
18084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18085 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
18086 return SWIG_Py_Void();
18087 }
18088
18089 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18090 return SWIG_Python_InitShadowInstance(args);
18091 }
18092
18093 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18094 PyObject *resultobj = 0;
18095 wxPNGHandler *result = 0 ;
18096
18097 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
18098 {
18099 PyThreadState* __tstate = wxPyBeginAllowThreads();
18100 result = (wxPNGHandler *)new wxPNGHandler();
18101 wxPyEndAllowThreads(__tstate);
18102 if (PyErr_Occurred()) SWIG_fail;
18103 }
18104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
18105 return resultobj;
18106 fail:
18107 return NULL;
18108 }
18109
18110
18111 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18112 PyObject *obj;
18113 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18114 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
18115 return SWIG_Py_Void();
18116 }
18117
18118 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18119 return SWIG_Python_InitShadowInstance(args);
18120 }
18121
18122 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18123 PyObject *resultobj = 0;
18124 wxGIFHandler *result = 0 ;
18125
18126 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
18127 {
18128 PyThreadState* __tstate = wxPyBeginAllowThreads();
18129 result = (wxGIFHandler *)new wxGIFHandler();
18130 wxPyEndAllowThreads(__tstate);
18131 if (PyErr_Occurred()) SWIG_fail;
18132 }
18133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
18134 return resultobj;
18135 fail:
18136 return NULL;
18137 }
18138
18139
18140 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18141 PyObject *obj;
18142 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18143 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
18144 return SWIG_Py_Void();
18145 }
18146
18147 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18148 return SWIG_Python_InitShadowInstance(args);
18149 }
18150
18151 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18152 PyObject *resultobj = 0;
18153 wxPCXHandler *result = 0 ;
18154
18155 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
18156 {
18157 PyThreadState* __tstate = wxPyBeginAllowThreads();
18158 result = (wxPCXHandler *)new wxPCXHandler();
18159 wxPyEndAllowThreads(__tstate);
18160 if (PyErr_Occurred()) SWIG_fail;
18161 }
18162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
18163 return resultobj;
18164 fail:
18165 return NULL;
18166 }
18167
18168
18169 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18170 PyObject *obj;
18171 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18172 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
18173 return SWIG_Py_Void();
18174 }
18175
18176 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18177 return SWIG_Python_InitShadowInstance(args);
18178 }
18179
18180 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18181 PyObject *resultobj = 0;
18182 wxJPEGHandler *result = 0 ;
18183
18184 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
18185 {
18186 PyThreadState* __tstate = wxPyBeginAllowThreads();
18187 result = (wxJPEGHandler *)new wxJPEGHandler();
18188 wxPyEndAllowThreads(__tstate);
18189 if (PyErr_Occurred()) SWIG_fail;
18190 }
18191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
18192 return resultobj;
18193 fail:
18194 return NULL;
18195 }
18196
18197
18198 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18199 PyObject *obj;
18200 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18201 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
18202 return SWIG_Py_Void();
18203 }
18204
18205 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18206 return SWIG_Python_InitShadowInstance(args);
18207 }
18208
18209 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18210 PyObject *resultobj = 0;
18211 wxPNMHandler *result = 0 ;
18212
18213 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
18214 {
18215 PyThreadState* __tstate = wxPyBeginAllowThreads();
18216 result = (wxPNMHandler *)new wxPNMHandler();
18217 wxPyEndAllowThreads(__tstate);
18218 if (PyErr_Occurred()) SWIG_fail;
18219 }
18220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
18221 return resultobj;
18222 fail:
18223 return NULL;
18224 }
18225
18226
18227 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18228 PyObject *obj;
18229 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18230 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
18231 return SWIG_Py_Void();
18232 }
18233
18234 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18235 return SWIG_Python_InitShadowInstance(args);
18236 }
18237
18238 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18239 PyObject *resultobj = 0;
18240 wxXPMHandler *result = 0 ;
18241
18242 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
18243 {
18244 PyThreadState* __tstate = wxPyBeginAllowThreads();
18245 result = (wxXPMHandler *)new wxXPMHandler();
18246 wxPyEndAllowThreads(__tstate);
18247 if (PyErr_Occurred()) SWIG_fail;
18248 }
18249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
18250 return resultobj;
18251 fail:
18252 return NULL;
18253 }
18254
18255
18256 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18257 PyObject *obj;
18258 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18259 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
18260 return SWIG_Py_Void();
18261 }
18262
18263 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18264 return SWIG_Python_InitShadowInstance(args);
18265 }
18266
18267 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18268 PyObject *resultobj = 0;
18269 wxTIFFHandler *result = 0 ;
18270
18271 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
18272 {
18273 PyThreadState* __tstate = wxPyBeginAllowThreads();
18274 result = (wxTIFFHandler *)new wxTIFFHandler();
18275 wxPyEndAllowThreads(__tstate);
18276 if (PyErr_Occurred()) SWIG_fail;
18277 }
18278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
18279 return resultobj;
18280 fail:
18281 return NULL;
18282 }
18283
18284
18285 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18286 PyObject *obj;
18287 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18288 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
18289 return SWIG_Py_Void();
18290 }
18291
18292 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18293 return SWIG_Python_InitShadowInstance(args);
18294 }
18295
18296 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18297 PyObject *resultobj = 0;
18298 wxImage *arg1 = 0 ;
18299 wxImage *arg2 = 0 ;
18300 int arg3 = (int) 236 ;
18301 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
18302 bool result;
18303 void *argp1 = 0 ;
18304 int res1 = 0 ;
18305 void *argp2 = 0 ;
18306 int res2 = 0 ;
18307 int val3 ;
18308 int ecode3 = 0 ;
18309 int val4 ;
18310 int ecode4 = 0 ;
18311 PyObject * obj0 = 0 ;
18312 PyObject * obj1 = 0 ;
18313 PyObject * obj2 = 0 ;
18314 PyObject * obj3 = 0 ;
18315 char * kwnames[] = {
18316 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
18317 };
18318
18319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18320 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
18321 if (!SWIG_IsOK(res1)) {
18322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
18323 }
18324 if (!argp1) {
18325 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
18326 }
18327 arg1 = reinterpret_cast< wxImage * >(argp1);
18328 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
18329 if (!SWIG_IsOK(res2)) {
18330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
18331 }
18332 if (!argp2) {
18333 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
18334 }
18335 arg2 = reinterpret_cast< wxImage * >(argp2);
18336 if (obj2) {
18337 ecode3 = SWIG_AsVal_int(obj2, &val3);
18338 if (!SWIG_IsOK(ecode3)) {
18339 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
18340 }
18341 arg3 = static_cast< int >(val3);
18342 }
18343 if (obj3) {
18344 ecode4 = SWIG_AsVal_int(obj3, &val4);
18345 if (!SWIG_IsOK(ecode4)) {
18346 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
18347 }
18348 arg4 = static_cast< int >(val4);
18349 }
18350 {
18351 PyThreadState* __tstate = wxPyBeginAllowThreads();
18352 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
18353 wxPyEndAllowThreads(__tstate);
18354 if (PyErr_Occurred()) SWIG_fail;
18355 }
18356 {
18357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18358 }
18359 return resultobj;
18360 fail:
18361 return NULL;
18362 }
18363
18364
18365 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18366 PyObject *obj;
18367 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18368 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
18369 return SWIG_Py_Void();
18370 }
18371
18372 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18373 PyObject *resultobj = 0;
18374 wxEvtHandler *result = 0 ;
18375
18376 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
18377 {
18378 PyThreadState* __tstate = wxPyBeginAllowThreads();
18379 result = (wxEvtHandler *)new wxEvtHandler();
18380 wxPyEndAllowThreads(__tstate);
18381 if (PyErr_Occurred()) SWIG_fail;
18382 }
18383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
18384 return resultobj;
18385 fail:
18386 return NULL;
18387 }
18388
18389
18390 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18391 PyObject *resultobj = 0;
18392 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18393 wxEvtHandler *result = 0 ;
18394 void *argp1 = 0 ;
18395 int res1 = 0 ;
18396 PyObject *swig_obj[1] ;
18397
18398 if (!args) SWIG_fail;
18399 swig_obj[0] = args;
18400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18401 if (!SWIG_IsOK(res1)) {
18402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18403 }
18404 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18405 {
18406 PyThreadState* __tstate = wxPyBeginAllowThreads();
18407 result = (wxEvtHandler *)(arg1)->GetNextHandler();
18408 wxPyEndAllowThreads(__tstate);
18409 if (PyErr_Occurred()) SWIG_fail;
18410 }
18411 {
18412 resultobj = wxPyMake_wxObject(result, 0);
18413 }
18414 return resultobj;
18415 fail:
18416 return NULL;
18417 }
18418
18419
18420 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18421 PyObject *resultobj = 0;
18422 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18423 wxEvtHandler *result = 0 ;
18424 void *argp1 = 0 ;
18425 int res1 = 0 ;
18426 PyObject *swig_obj[1] ;
18427
18428 if (!args) SWIG_fail;
18429 swig_obj[0] = args;
18430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18431 if (!SWIG_IsOK(res1)) {
18432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18433 }
18434 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18435 {
18436 PyThreadState* __tstate = wxPyBeginAllowThreads();
18437 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
18438 wxPyEndAllowThreads(__tstate);
18439 if (PyErr_Occurred()) SWIG_fail;
18440 }
18441 {
18442 resultobj = wxPyMake_wxObject(result, 0);
18443 }
18444 return resultobj;
18445 fail:
18446 return NULL;
18447 }
18448
18449
18450 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18451 PyObject *resultobj = 0;
18452 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18453 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18454 void *argp1 = 0 ;
18455 int res1 = 0 ;
18456 void *argp2 = 0 ;
18457 int res2 = 0 ;
18458 PyObject * obj0 = 0 ;
18459 PyObject * obj1 = 0 ;
18460 char * kwnames[] = {
18461 (char *) "self",(char *) "handler", NULL
18462 };
18463
18464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18466 if (!SWIG_IsOK(res1)) {
18467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18468 }
18469 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18470 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18471 if (!SWIG_IsOK(res2)) {
18472 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18473 }
18474 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18475 {
18476 PyThreadState* __tstate = wxPyBeginAllowThreads();
18477 (arg1)->SetNextHandler(arg2);
18478 wxPyEndAllowThreads(__tstate);
18479 if (PyErr_Occurred()) SWIG_fail;
18480 }
18481 resultobj = SWIG_Py_Void();
18482 return resultobj;
18483 fail:
18484 return NULL;
18485 }
18486
18487
18488 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18489 PyObject *resultobj = 0;
18490 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18491 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18492 void *argp1 = 0 ;
18493 int res1 = 0 ;
18494 void *argp2 = 0 ;
18495 int res2 = 0 ;
18496 PyObject * obj0 = 0 ;
18497 PyObject * obj1 = 0 ;
18498 char * kwnames[] = {
18499 (char *) "self",(char *) "handler", NULL
18500 };
18501
18502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18504 if (!SWIG_IsOK(res1)) {
18505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18506 }
18507 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18508 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18509 if (!SWIG_IsOK(res2)) {
18510 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18511 }
18512 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18513 {
18514 PyThreadState* __tstate = wxPyBeginAllowThreads();
18515 (arg1)->SetPreviousHandler(arg2);
18516 wxPyEndAllowThreads(__tstate);
18517 if (PyErr_Occurred()) SWIG_fail;
18518 }
18519 resultobj = SWIG_Py_Void();
18520 return resultobj;
18521 fail:
18522 return NULL;
18523 }
18524
18525
18526 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18527 PyObject *resultobj = 0;
18528 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18529 bool result;
18530 void *argp1 = 0 ;
18531 int res1 = 0 ;
18532 PyObject *swig_obj[1] ;
18533
18534 if (!args) SWIG_fail;
18535 swig_obj[0] = args;
18536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18537 if (!SWIG_IsOK(res1)) {
18538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18539 }
18540 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18541 {
18542 PyThreadState* __tstate = wxPyBeginAllowThreads();
18543 result = (bool)(arg1)->GetEvtHandlerEnabled();
18544 wxPyEndAllowThreads(__tstate);
18545 if (PyErr_Occurred()) SWIG_fail;
18546 }
18547 {
18548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18549 }
18550 return resultobj;
18551 fail:
18552 return NULL;
18553 }
18554
18555
18556 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18557 PyObject *resultobj = 0;
18558 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18559 bool arg2 ;
18560 void *argp1 = 0 ;
18561 int res1 = 0 ;
18562 bool val2 ;
18563 int ecode2 = 0 ;
18564 PyObject * obj0 = 0 ;
18565 PyObject * obj1 = 0 ;
18566 char * kwnames[] = {
18567 (char *) "self",(char *) "enabled", NULL
18568 };
18569
18570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18572 if (!SWIG_IsOK(res1)) {
18573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18574 }
18575 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18576 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18577 if (!SWIG_IsOK(ecode2)) {
18578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18579 }
18580 arg2 = static_cast< bool >(val2);
18581 {
18582 PyThreadState* __tstate = wxPyBeginAllowThreads();
18583 (arg1)->SetEvtHandlerEnabled(arg2);
18584 wxPyEndAllowThreads(__tstate);
18585 if (PyErr_Occurred()) SWIG_fail;
18586 }
18587 resultobj = SWIG_Py_Void();
18588 return resultobj;
18589 fail:
18590 return NULL;
18591 }
18592
18593
18594 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18595 PyObject *resultobj = 0;
18596 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18597 wxEvent *arg2 = 0 ;
18598 bool result;
18599 void *argp1 = 0 ;
18600 int res1 = 0 ;
18601 void *argp2 = 0 ;
18602 int res2 = 0 ;
18603 PyObject * obj0 = 0 ;
18604 PyObject * obj1 = 0 ;
18605 char * kwnames[] = {
18606 (char *) "self",(char *) "event", NULL
18607 };
18608
18609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18611 if (!SWIG_IsOK(res1)) {
18612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18613 }
18614 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18615 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18616 if (!SWIG_IsOK(res2)) {
18617 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18618 }
18619 if (!argp2) {
18620 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18621 }
18622 arg2 = reinterpret_cast< wxEvent * >(argp2);
18623 {
18624 PyThreadState* __tstate = wxPyBeginAllowThreads();
18625 result = (bool)(arg1)->ProcessEvent(*arg2);
18626 wxPyEndAllowThreads(__tstate);
18627 if (PyErr_Occurred()) SWIG_fail;
18628 }
18629 {
18630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18631 }
18632 return resultobj;
18633 fail:
18634 return NULL;
18635 }
18636
18637
18638 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18639 PyObject *resultobj = 0;
18640 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18641 wxEvent *arg2 = 0 ;
18642 void *argp1 = 0 ;
18643 int res1 = 0 ;
18644 void *argp2 = 0 ;
18645 int res2 = 0 ;
18646 PyObject * obj0 = 0 ;
18647 PyObject * obj1 = 0 ;
18648 char * kwnames[] = {
18649 (char *) "self",(char *) "event", NULL
18650 };
18651
18652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18654 if (!SWIG_IsOK(res1)) {
18655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18656 }
18657 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18658 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18659 if (!SWIG_IsOK(res2)) {
18660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18661 }
18662 if (!argp2) {
18663 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18664 }
18665 arg2 = reinterpret_cast< wxEvent * >(argp2);
18666 {
18667 PyThreadState* __tstate = wxPyBeginAllowThreads();
18668 (arg1)->AddPendingEvent(*arg2);
18669 wxPyEndAllowThreads(__tstate);
18670 if (PyErr_Occurred()) SWIG_fail;
18671 }
18672 resultobj = SWIG_Py_Void();
18673 return resultobj;
18674 fail:
18675 return NULL;
18676 }
18677
18678
18679 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18680 PyObject *resultobj = 0;
18681 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18682 void *argp1 = 0 ;
18683 int res1 = 0 ;
18684 PyObject *swig_obj[1] ;
18685
18686 if (!args) SWIG_fail;
18687 swig_obj[0] = args;
18688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18689 if (!SWIG_IsOK(res1)) {
18690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18691 }
18692 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18693 {
18694 PyThreadState* __tstate = wxPyBeginAllowThreads();
18695 (arg1)->ProcessPendingEvents();
18696 wxPyEndAllowThreads(__tstate);
18697 if (PyErr_Occurred()) SWIG_fail;
18698 }
18699 resultobj = SWIG_Py_Void();
18700 return resultobj;
18701 fail:
18702 return NULL;
18703 }
18704
18705
18706 SWIGINTERN PyObject *_wrap_EvtHandler_AllowReentrance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18707 PyObject *resultobj = 0;
18708 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18709 bool arg2 = (bool) true ;
18710 void *argp1 = 0 ;
18711 int res1 = 0 ;
18712 bool val2 ;
18713 int ecode2 = 0 ;
18714 PyObject * obj0 = 0 ;
18715 PyObject * obj1 = 0 ;
18716 char * kwnames[] = {
18717 (char *) "self",(char *) "allow", NULL
18718 };
18719
18720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EvtHandler_AllowReentrance",kwnames,&obj0,&obj1)) SWIG_fail;
18721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18722 if (!SWIG_IsOK(res1)) {
18723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18724 }
18725 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18726 if (obj1) {
18727 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18728 if (!SWIG_IsOK(ecode2)) {
18729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "2"" of type '" "bool""'");
18730 }
18731 arg2 = static_cast< bool >(val2);
18732 }
18733 {
18734 PyThreadState* __tstate = wxPyBeginAllowThreads();
18735 (arg1)->AllowReentrance(arg2);
18736 wxPyEndAllowThreads(__tstate);
18737 if (PyErr_Occurred()) SWIG_fail;
18738 }
18739 resultobj = SWIG_Py_Void();
18740 return resultobj;
18741 fail:
18742 return NULL;
18743 }
18744
18745
18746 SWIGINTERN PyObject *_wrap_EvtHandler_IsReentranceAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18747 PyObject *resultobj = 0;
18748 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18749 bool result;
18750 void *argp1 = 0 ;
18751 int res1 = 0 ;
18752 PyObject *swig_obj[1] ;
18753
18754 if (!args) SWIG_fail;
18755 swig_obj[0] = args;
18756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18757 if (!SWIG_IsOK(res1)) {
18758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsReentranceAllowed" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18759 }
18760 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18761 {
18762 PyThreadState* __tstate = wxPyBeginAllowThreads();
18763 result = (bool)(arg1)->IsReentranceAllowed();
18764 wxPyEndAllowThreads(__tstate);
18765 if (PyErr_Occurred()) SWIG_fail;
18766 }
18767 {
18768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18769 }
18770 return resultobj;
18771 fail:
18772 return NULL;
18773 }
18774
18775
18776 SWIGINTERN PyObject *_wrap_EvtHandler_IsEventHandlingInProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18777 PyObject *resultobj = 0;
18778 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18779 bool result;
18780 void *argp1 = 0 ;
18781 int res1 = 0 ;
18782 PyObject *swig_obj[1] ;
18783
18784 if (!args) SWIG_fail;
18785 swig_obj[0] = args;
18786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18787 if (!SWIG_IsOK(res1)) {
18788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsEventHandlingInProgress" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18789 }
18790 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18791 {
18792 PyThreadState* __tstate = wxPyBeginAllowThreads();
18793 result = (bool)(arg1)->IsEventHandlingInProgress();
18794 wxPyEndAllowThreads(__tstate);
18795 if (PyErr_Occurred()) SWIG_fail;
18796 }
18797 {
18798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18799 }
18800 return resultobj;
18801 fail:
18802 return NULL;
18803 }
18804
18805
18806 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18807 PyObject *resultobj = 0;
18808 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18809 int arg2 ;
18810 int arg3 ;
18811 int arg4 ;
18812 PyObject *arg5 = (PyObject *) 0 ;
18813 void *argp1 = 0 ;
18814 int res1 = 0 ;
18815 int val2 ;
18816 int ecode2 = 0 ;
18817 int val3 ;
18818 int ecode3 = 0 ;
18819 int val4 ;
18820 int ecode4 = 0 ;
18821 PyObject * obj0 = 0 ;
18822 PyObject * obj1 = 0 ;
18823 PyObject * obj2 = 0 ;
18824 PyObject * obj3 = 0 ;
18825 PyObject * obj4 = 0 ;
18826 char * kwnames[] = {
18827 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18828 };
18829
18830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18832 if (!SWIG_IsOK(res1)) {
18833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18834 }
18835 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18836 ecode2 = SWIG_AsVal_int(obj1, &val2);
18837 if (!SWIG_IsOK(ecode2)) {
18838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18839 }
18840 arg2 = static_cast< int >(val2);
18841 ecode3 = SWIG_AsVal_int(obj2, &val3);
18842 if (!SWIG_IsOK(ecode3)) {
18843 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18844 }
18845 arg3 = static_cast< int >(val3);
18846 ecode4 = SWIG_AsVal_int(obj3, &val4);
18847 if (!SWIG_IsOK(ecode4)) {
18848 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18849 }
18850 arg4 = static_cast< int >(val4);
18851 arg5 = obj4;
18852 {
18853 PyThreadState* __tstate = wxPyBeginAllowThreads();
18854 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18855 wxPyEndAllowThreads(__tstate);
18856 if (PyErr_Occurred()) SWIG_fail;
18857 }
18858 resultobj = SWIG_Py_Void();
18859 return resultobj;
18860 fail:
18861 return NULL;
18862 }
18863
18864
18865 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18866 PyObject *resultobj = 0;
18867 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18868 int arg2 ;
18869 int arg3 = (int) -1 ;
18870 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18871 bool result;
18872 void *argp1 = 0 ;
18873 int res1 = 0 ;
18874 int val2 ;
18875 int ecode2 = 0 ;
18876 int val3 ;
18877 int ecode3 = 0 ;
18878 int val4 ;
18879 int ecode4 = 0 ;
18880 PyObject * obj0 = 0 ;
18881 PyObject * obj1 = 0 ;
18882 PyObject * obj2 = 0 ;
18883 PyObject * obj3 = 0 ;
18884 char * kwnames[] = {
18885 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18886 };
18887
18888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18890 if (!SWIG_IsOK(res1)) {
18891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18892 }
18893 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18894 ecode2 = SWIG_AsVal_int(obj1, &val2);
18895 if (!SWIG_IsOK(ecode2)) {
18896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18897 }
18898 arg2 = static_cast< int >(val2);
18899 if (obj2) {
18900 ecode3 = SWIG_AsVal_int(obj2, &val3);
18901 if (!SWIG_IsOK(ecode3)) {
18902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18903 }
18904 arg3 = static_cast< int >(val3);
18905 }
18906 if (obj3) {
18907 ecode4 = SWIG_AsVal_int(obj3, &val4);
18908 if (!SWIG_IsOK(ecode4)) {
18909 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18910 }
18911 arg4 = static_cast< wxEventType >(val4);
18912 }
18913 {
18914 PyThreadState* __tstate = wxPyBeginAllowThreads();
18915 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18916 wxPyEndAllowThreads(__tstate);
18917 if (PyErr_Occurred()) SWIG_fail;
18918 }
18919 {
18920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18921 }
18922 return resultobj;
18923 fail:
18924 return NULL;
18925 }
18926
18927
18928 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18929 PyObject *resultobj = 0;
18930 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18931 PyObject *arg2 = (PyObject *) 0 ;
18932 bool arg3 = (bool) true ;
18933 void *argp1 = 0 ;
18934 int res1 = 0 ;
18935 bool val3 ;
18936 int ecode3 = 0 ;
18937 PyObject * obj0 = 0 ;
18938 PyObject * obj1 = 0 ;
18939 PyObject * obj2 = 0 ;
18940 char * kwnames[] = {
18941 (char *) "self",(char *) "_self",(char *) "incref", NULL
18942 };
18943
18944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18946 if (!SWIG_IsOK(res1)) {
18947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18948 }
18949 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18950 arg2 = obj1;
18951 if (obj2) {
18952 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18953 if (!SWIG_IsOK(ecode3)) {
18954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18955 }
18956 arg3 = static_cast< bool >(val3);
18957 }
18958 {
18959 PyThreadState* __tstate = wxPyBeginAllowThreads();
18960 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18961 wxPyEndAllowThreads(__tstate);
18962 if (PyErr_Occurred()) SWIG_fail;
18963 }
18964 resultobj = SWIG_Py_Void();
18965 return resultobj;
18966 fail:
18967 return NULL;
18968 }
18969
18970
18971 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18972 PyObject *obj;
18973 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18974 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18975 return SWIG_Py_Void();
18976 }
18977
18978 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18979 return SWIG_Python_InitShadowInstance(args);
18980 }
18981
18982 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18983 PyObject *resultobj = 0;
18984 wxEventType result;
18985
18986 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18987 {
18988 PyThreadState* __tstate = wxPyBeginAllowThreads();
18989 result = (wxEventType)wxNewEventType();
18990 wxPyEndAllowThreads(__tstate);
18991 if (PyErr_Occurred()) SWIG_fail;
18992 }
18993 resultobj = SWIG_From_int(static_cast< int >(result));
18994 return resultobj;
18995 fail:
18996 return NULL;
18997 }
18998
18999
19000 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19001 PyObject *resultobj = 0;
19002 wxEvent *arg1 = (wxEvent *) 0 ;
19003 void *argp1 = 0 ;
19004 int res1 = 0 ;
19005 PyObject *swig_obj[1] ;
19006
19007 if (!args) SWIG_fail;
19008 swig_obj[0] = args;
19009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
19010 if (!SWIG_IsOK(res1)) {
19011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
19012 }
19013 arg1 = reinterpret_cast< wxEvent * >(argp1);
19014 {
19015 PyThreadState* __tstate = wxPyBeginAllowThreads();
19016 delete arg1;
19017
19018 wxPyEndAllowThreads(__tstate);
19019 if (PyErr_Occurred()) SWIG_fail;
19020 }
19021 resultobj = SWIG_Py_Void();
19022 return resultobj;
19023 fail:
19024 return NULL;
19025 }
19026
19027
19028 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19029 PyObject *resultobj = 0;
19030 wxEvent *arg1 = (wxEvent *) 0 ;
19031 wxEventType arg2 ;
19032 void *argp1 = 0 ;
19033 int res1 = 0 ;
19034 int val2 ;
19035 int ecode2 = 0 ;
19036 PyObject * obj0 = 0 ;
19037 PyObject * obj1 = 0 ;
19038 char * kwnames[] = {
19039 (char *) "self",(char *) "typ", NULL
19040 };
19041
19042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
19043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19044 if (!SWIG_IsOK(res1)) {
19045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
19046 }
19047 arg1 = reinterpret_cast< wxEvent * >(argp1);
19048 ecode2 = SWIG_AsVal_int(obj1, &val2);
19049 if (!SWIG_IsOK(ecode2)) {
19050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
19051 }
19052 arg2 = static_cast< wxEventType >(val2);
19053 {
19054 PyThreadState* __tstate = wxPyBeginAllowThreads();
19055 (arg1)->SetEventType(arg2);
19056 wxPyEndAllowThreads(__tstate);
19057 if (PyErr_Occurred()) SWIG_fail;
19058 }
19059 resultobj = SWIG_Py_Void();
19060 return resultobj;
19061 fail:
19062 return NULL;
19063 }
19064
19065
19066 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19067 PyObject *resultobj = 0;
19068 wxEvent *arg1 = (wxEvent *) 0 ;
19069 wxEventType result;
19070 void *argp1 = 0 ;
19071 int res1 = 0 ;
19072 PyObject *swig_obj[1] ;
19073
19074 if (!args) SWIG_fail;
19075 swig_obj[0] = args;
19076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19077 if (!SWIG_IsOK(res1)) {
19078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
19079 }
19080 arg1 = reinterpret_cast< wxEvent * >(argp1);
19081 {
19082 PyThreadState* __tstate = wxPyBeginAllowThreads();
19083 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
19084 wxPyEndAllowThreads(__tstate);
19085 if (PyErr_Occurred()) SWIG_fail;
19086 }
19087 resultobj = SWIG_From_int(static_cast< int >(result));
19088 return resultobj;
19089 fail:
19090 return NULL;
19091 }
19092
19093
19094 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19095 PyObject *resultobj = 0;
19096 wxEvent *arg1 = (wxEvent *) 0 ;
19097 wxObject *result = 0 ;
19098 void *argp1 = 0 ;
19099 int res1 = 0 ;
19100 PyObject *swig_obj[1] ;
19101
19102 if (!args) SWIG_fail;
19103 swig_obj[0] = args;
19104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19105 if (!SWIG_IsOK(res1)) {
19106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
19107 }
19108 arg1 = reinterpret_cast< wxEvent * >(argp1);
19109 {
19110 PyThreadState* __tstate = wxPyBeginAllowThreads();
19111 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
19112 wxPyEndAllowThreads(__tstate);
19113 if (PyErr_Occurred()) SWIG_fail;
19114 }
19115 {
19116 resultobj = wxPyMake_wxObject(result, (bool)0);
19117 }
19118 return resultobj;
19119 fail:
19120 return NULL;
19121 }
19122
19123
19124 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19125 PyObject *resultobj = 0;
19126 wxEvent *arg1 = (wxEvent *) 0 ;
19127 wxObject *arg2 = (wxObject *) 0 ;
19128 void *argp1 = 0 ;
19129 int res1 = 0 ;
19130 void *argp2 = 0 ;
19131 int res2 = 0 ;
19132 PyObject * obj0 = 0 ;
19133 PyObject * obj1 = 0 ;
19134 char * kwnames[] = {
19135 (char *) "self",(char *) "obj", NULL
19136 };
19137
19138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
19139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19140 if (!SWIG_IsOK(res1)) {
19141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
19142 }
19143 arg1 = reinterpret_cast< wxEvent * >(argp1);
19144 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
19145 if (!SWIG_IsOK(res2)) {
19146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
19147 }
19148 arg2 = reinterpret_cast< wxObject * >(argp2);
19149 {
19150 PyThreadState* __tstate = wxPyBeginAllowThreads();
19151 (arg1)->SetEventObject(arg2);
19152 wxPyEndAllowThreads(__tstate);
19153 if (PyErr_Occurred()) SWIG_fail;
19154 }
19155 resultobj = SWIG_Py_Void();
19156 return resultobj;
19157 fail:
19158 return NULL;
19159 }
19160
19161
19162 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19163 PyObject *resultobj = 0;
19164 wxEvent *arg1 = (wxEvent *) 0 ;
19165 long result;
19166 void *argp1 = 0 ;
19167 int res1 = 0 ;
19168 PyObject *swig_obj[1] ;
19169
19170 if (!args) SWIG_fail;
19171 swig_obj[0] = args;
19172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19173 if (!SWIG_IsOK(res1)) {
19174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
19175 }
19176 arg1 = reinterpret_cast< wxEvent * >(argp1);
19177 {
19178 PyThreadState* __tstate = wxPyBeginAllowThreads();
19179 result = (long)((wxEvent const *)arg1)->GetTimestamp();
19180 wxPyEndAllowThreads(__tstate);
19181 if (PyErr_Occurred()) SWIG_fail;
19182 }
19183 resultobj = SWIG_From_long(static_cast< long >(result));
19184 return resultobj;
19185 fail:
19186 return NULL;
19187 }
19188
19189
19190 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19191 PyObject *resultobj = 0;
19192 wxEvent *arg1 = (wxEvent *) 0 ;
19193 long arg2 = (long) 0 ;
19194 void *argp1 = 0 ;
19195 int res1 = 0 ;
19196 long val2 ;
19197 int ecode2 = 0 ;
19198 PyObject * obj0 = 0 ;
19199 PyObject * obj1 = 0 ;
19200 char * kwnames[] = {
19201 (char *) "self",(char *) "ts", NULL
19202 };
19203
19204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
19205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19206 if (!SWIG_IsOK(res1)) {
19207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
19208 }
19209 arg1 = reinterpret_cast< wxEvent * >(argp1);
19210 if (obj1) {
19211 ecode2 = SWIG_AsVal_long(obj1, &val2);
19212 if (!SWIG_IsOK(ecode2)) {
19213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
19214 }
19215 arg2 = static_cast< long >(val2);
19216 }
19217 {
19218 PyThreadState* __tstate = wxPyBeginAllowThreads();
19219 (arg1)->SetTimestamp(arg2);
19220 wxPyEndAllowThreads(__tstate);
19221 if (PyErr_Occurred()) SWIG_fail;
19222 }
19223 resultobj = SWIG_Py_Void();
19224 return resultobj;
19225 fail:
19226 return NULL;
19227 }
19228
19229
19230 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19231 PyObject *resultobj = 0;
19232 wxEvent *arg1 = (wxEvent *) 0 ;
19233 int result;
19234 void *argp1 = 0 ;
19235 int res1 = 0 ;
19236 PyObject *swig_obj[1] ;
19237
19238 if (!args) SWIG_fail;
19239 swig_obj[0] = args;
19240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19241 if (!SWIG_IsOK(res1)) {
19242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
19243 }
19244 arg1 = reinterpret_cast< wxEvent * >(argp1);
19245 {
19246 PyThreadState* __tstate = wxPyBeginAllowThreads();
19247 result = (int)((wxEvent const *)arg1)->GetId();
19248 wxPyEndAllowThreads(__tstate);
19249 if (PyErr_Occurred()) SWIG_fail;
19250 }
19251 resultobj = SWIG_From_int(static_cast< int >(result));
19252 return resultobj;
19253 fail:
19254 return NULL;
19255 }
19256
19257
19258 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19259 PyObject *resultobj = 0;
19260 wxEvent *arg1 = (wxEvent *) 0 ;
19261 int arg2 ;
19262 void *argp1 = 0 ;
19263 int res1 = 0 ;
19264 int val2 ;
19265 int ecode2 = 0 ;
19266 PyObject * obj0 = 0 ;
19267 PyObject * obj1 = 0 ;
19268 char * kwnames[] = {
19269 (char *) "self",(char *) "Id", NULL
19270 };
19271
19272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
19273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19274 if (!SWIG_IsOK(res1)) {
19275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
19276 }
19277 arg1 = reinterpret_cast< wxEvent * >(argp1);
19278 ecode2 = SWIG_AsVal_int(obj1, &val2);
19279 if (!SWIG_IsOK(ecode2)) {
19280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
19281 }
19282 arg2 = static_cast< int >(val2);
19283 {
19284 PyThreadState* __tstate = wxPyBeginAllowThreads();
19285 (arg1)->SetId(arg2);
19286 wxPyEndAllowThreads(__tstate);
19287 if (PyErr_Occurred()) SWIG_fail;
19288 }
19289 resultobj = SWIG_Py_Void();
19290 return resultobj;
19291 fail:
19292 return NULL;
19293 }
19294
19295
19296 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19297 PyObject *resultobj = 0;
19298 wxEvent *arg1 = (wxEvent *) 0 ;
19299 bool result;
19300 void *argp1 = 0 ;
19301 int res1 = 0 ;
19302 PyObject *swig_obj[1] ;
19303
19304 if (!args) SWIG_fail;
19305 swig_obj[0] = args;
19306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19307 if (!SWIG_IsOK(res1)) {
19308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
19309 }
19310 arg1 = reinterpret_cast< wxEvent * >(argp1);
19311 {
19312 PyThreadState* __tstate = wxPyBeginAllowThreads();
19313 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
19314 wxPyEndAllowThreads(__tstate);
19315 if (PyErr_Occurred()) SWIG_fail;
19316 }
19317 {
19318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19319 }
19320 return resultobj;
19321 fail:
19322 return NULL;
19323 }
19324
19325
19326 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19327 PyObject *resultobj = 0;
19328 wxEvent *arg1 = (wxEvent *) 0 ;
19329 bool arg2 = (bool) true ;
19330 void *argp1 = 0 ;
19331 int res1 = 0 ;
19332 bool val2 ;
19333 int ecode2 = 0 ;
19334 PyObject * obj0 = 0 ;
19335 PyObject * obj1 = 0 ;
19336 char * kwnames[] = {
19337 (char *) "self",(char *) "skip", NULL
19338 };
19339
19340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
19341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19342 if (!SWIG_IsOK(res1)) {
19343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
19344 }
19345 arg1 = reinterpret_cast< wxEvent * >(argp1);
19346 if (obj1) {
19347 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19348 if (!SWIG_IsOK(ecode2)) {
19349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
19350 }
19351 arg2 = static_cast< bool >(val2);
19352 }
19353 {
19354 PyThreadState* __tstate = wxPyBeginAllowThreads();
19355 (arg1)->Skip(arg2);
19356 wxPyEndAllowThreads(__tstate);
19357 if (PyErr_Occurred()) SWIG_fail;
19358 }
19359 resultobj = SWIG_Py_Void();
19360 return resultobj;
19361 fail:
19362 return NULL;
19363 }
19364
19365
19366 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19367 PyObject *resultobj = 0;
19368 wxEvent *arg1 = (wxEvent *) 0 ;
19369 bool result;
19370 void *argp1 = 0 ;
19371 int res1 = 0 ;
19372 PyObject *swig_obj[1] ;
19373
19374 if (!args) SWIG_fail;
19375 swig_obj[0] = args;
19376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19377 if (!SWIG_IsOK(res1)) {
19378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
19379 }
19380 arg1 = reinterpret_cast< wxEvent * >(argp1);
19381 {
19382 PyThreadState* __tstate = wxPyBeginAllowThreads();
19383 result = (bool)((wxEvent const *)arg1)->GetSkipped();
19384 wxPyEndAllowThreads(__tstate);
19385 if (PyErr_Occurred()) SWIG_fail;
19386 }
19387 {
19388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19389 }
19390 return resultobj;
19391 fail:
19392 return NULL;
19393 }
19394
19395
19396 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19397 PyObject *resultobj = 0;
19398 wxEvent *arg1 = (wxEvent *) 0 ;
19399 bool result;
19400 void *argp1 = 0 ;
19401 int res1 = 0 ;
19402 PyObject *swig_obj[1] ;
19403
19404 if (!args) SWIG_fail;
19405 swig_obj[0] = args;
19406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19407 if (!SWIG_IsOK(res1)) {
19408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
19409 }
19410 arg1 = reinterpret_cast< wxEvent * >(argp1);
19411 {
19412 PyThreadState* __tstate = wxPyBeginAllowThreads();
19413 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
19414 wxPyEndAllowThreads(__tstate);
19415 if (PyErr_Occurred()) SWIG_fail;
19416 }
19417 {
19418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19419 }
19420 return resultobj;
19421 fail:
19422 return NULL;
19423 }
19424
19425
19426 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19427 PyObject *resultobj = 0;
19428 wxEvent *arg1 = (wxEvent *) 0 ;
19429 int result;
19430 void *argp1 = 0 ;
19431 int res1 = 0 ;
19432 PyObject *swig_obj[1] ;
19433
19434 if (!args) SWIG_fail;
19435 swig_obj[0] = args;
19436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19437 if (!SWIG_IsOK(res1)) {
19438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19439 }
19440 arg1 = reinterpret_cast< wxEvent * >(argp1);
19441 {
19442 PyThreadState* __tstate = wxPyBeginAllowThreads();
19443 result = (int)(arg1)->StopPropagation();
19444 wxPyEndAllowThreads(__tstate);
19445 if (PyErr_Occurred()) SWIG_fail;
19446 }
19447 resultobj = SWIG_From_int(static_cast< int >(result));
19448 return resultobj;
19449 fail:
19450 return NULL;
19451 }
19452
19453
19454 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19455 PyObject *resultobj = 0;
19456 wxEvent *arg1 = (wxEvent *) 0 ;
19457 int arg2 ;
19458 void *argp1 = 0 ;
19459 int res1 = 0 ;
19460 int val2 ;
19461 int ecode2 = 0 ;
19462 PyObject * obj0 = 0 ;
19463 PyObject * obj1 = 0 ;
19464 char * kwnames[] = {
19465 (char *) "self",(char *) "propagationLevel", NULL
19466 };
19467
19468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
19469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19470 if (!SWIG_IsOK(res1)) {
19471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19472 }
19473 arg1 = reinterpret_cast< wxEvent * >(argp1);
19474 ecode2 = SWIG_AsVal_int(obj1, &val2);
19475 if (!SWIG_IsOK(ecode2)) {
19476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
19477 }
19478 arg2 = static_cast< int >(val2);
19479 {
19480 PyThreadState* __tstate = wxPyBeginAllowThreads();
19481 (arg1)->ResumePropagation(arg2);
19482 wxPyEndAllowThreads(__tstate);
19483 if (PyErr_Occurred()) SWIG_fail;
19484 }
19485 resultobj = SWIG_Py_Void();
19486 return resultobj;
19487 fail:
19488 return NULL;
19489 }
19490
19491
19492 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19493 PyObject *resultobj = 0;
19494 wxEvent *arg1 = (wxEvent *) 0 ;
19495 wxEvent *result = 0 ;
19496 void *argp1 = 0 ;
19497 int res1 = 0 ;
19498 PyObject *swig_obj[1] ;
19499
19500 if (!args) SWIG_fail;
19501 swig_obj[0] = args;
19502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19503 if (!SWIG_IsOK(res1)) {
19504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
19505 }
19506 arg1 = reinterpret_cast< wxEvent * >(argp1);
19507 {
19508 PyThreadState* __tstate = wxPyBeginAllowThreads();
19509 result = (wxEvent *)(arg1)->Clone();
19510 wxPyEndAllowThreads(__tstate);
19511 if (PyErr_Occurred()) SWIG_fail;
19512 }
19513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19514 return resultobj;
19515 fail:
19516 return NULL;
19517 }
19518
19519
19520 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19521 PyObject *obj;
19522 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19523 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
19524 return SWIG_Py_Void();
19525 }
19526
19527 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19528 PyObject *resultobj = 0;
19529 wxEvent *arg1 = 0 ;
19530 wxPropagationDisabler *result = 0 ;
19531 void *argp1 = 0 ;
19532 int res1 = 0 ;
19533 PyObject * obj0 = 0 ;
19534 char * kwnames[] = {
19535 (char *) "event", NULL
19536 };
19537
19538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
19539 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19540 if (!SWIG_IsOK(res1)) {
19541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19542 }
19543 if (!argp1) {
19544 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19545 }
19546 arg1 = reinterpret_cast< wxEvent * >(argp1);
19547 {
19548 PyThreadState* __tstate = wxPyBeginAllowThreads();
19549 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
19550 wxPyEndAllowThreads(__tstate);
19551 if (PyErr_Occurred()) SWIG_fail;
19552 }
19553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
19554 return resultobj;
19555 fail:
19556 return NULL;
19557 }
19558
19559
19560 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19561 PyObject *resultobj = 0;
19562 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
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_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
19570 if (!SWIG_IsOK(res1)) {
19571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
19572 }
19573 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
19574 {
19575 PyThreadState* __tstate = wxPyBeginAllowThreads();
19576 delete arg1;
19577
19578 wxPyEndAllowThreads(__tstate);
19579 if (PyErr_Occurred()) SWIG_fail;
19580 }
19581 resultobj = SWIG_Py_Void();
19582 return resultobj;
19583 fail:
19584 return NULL;
19585 }
19586
19587
19588 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19589 PyObject *obj;
19590 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19591 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
19592 return SWIG_Py_Void();
19593 }
19594
19595 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19596 return SWIG_Python_InitShadowInstance(args);
19597 }
19598
19599 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19600 PyObject *resultobj = 0;
19601 wxEvent *arg1 = 0 ;
19602 wxPropagateOnce *result = 0 ;
19603 void *argp1 = 0 ;
19604 int res1 = 0 ;
19605 PyObject * obj0 = 0 ;
19606 char * kwnames[] = {
19607 (char *) "event", NULL
19608 };
19609
19610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
19611 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19612 if (!SWIG_IsOK(res1)) {
19613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19614 }
19615 if (!argp1) {
19616 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19617 }
19618 arg1 = reinterpret_cast< wxEvent * >(argp1);
19619 {
19620 PyThreadState* __tstate = wxPyBeginAllowThreads();
19621 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
19622 wxPyEndAllowThreads(__tstate);
19623 if (PyErr_Occurred()) SWIG_fail;
19624 }
19625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
19626 return resultobj;
19627 fail:
19628 return NULL;
19629 }
19630
19631
19632 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19633 PyObject *resultobj = 0;
19634 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
19635 void *argp1 = 0 ;
19636 int res1 = 0 ;
19637 PyObject *swig_obj[1] ;
19638
19639 if (!args) SWIG_fail;
19640 swig_obj[0] = args;
19641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
19642 if (!SWIG_IsOK(res1)) {
19643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19644 }
19645 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19646 {
19647 PyThreadState* __tstate = wxPyBeginAllowThreads();
19648 delete arg1;
19649
19650 wxPyEndAllowThreads(__tstate);
19651 if (PyErr_Occurred()) SWIG_fail;
19652 }
19653 resultobj = SWIG_Py_Void();
19654 return resultobj;
19655 fail:
19656 return NULL;
19657 }
19658
19659
19660 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19661 PyObject *obj;
19662 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19663 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19664 return SWIG_Py_Void();
19665 }
19666
19667 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19668 return SWIG_Python_InitShadowInstance(args);
19669 }
19670
19671 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19672 PyObject *resultobj = 0;
19673 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19674 int arg2 = (int) 0 ;
19675 wxCommandEvent *result = 0 ;
19676 int val1 ;
19677 int ecode1 = 0 ;
19678 int val2 ;
19679 int ecode2 = 0 ;
19680 PyObject * obj0 = 0 ;
19681 PyObject * obj1 = 0 ;
19682 char * kwnames[] = {
19683 (char *) "commandType",(char *) "winid", NULL
19684 };
19685
19686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19687 if (obj0) {
19688 ecode1 = SWIG_AsVal_int(obj0, &val1);
19689 if (!SWIG_IsOK(ecode1)) {
19690 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19691 }
19692 arg1 = static_cast< wxEventType >(val1);
19693 }
19694 if (obj1) {
19695 ecode2 = SWIG_AsVal_int(obj1, &val2);
19696 if (!SWIG_IsOK(ecode2)) {
19697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19698 }
19699 arg2 = static_cast< int >(val2);
19700 }
19701 {
19702 PyThreadState* __tstate = wxPyBeginAllowThreads();
19703 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19704 wxPyEndAllowThreads(__tstate);
19705 if (PyErr_Occurred()) SWIG_fail;
19706 }
19707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19708 return resultobj;
19709 fail:
19710 return NULL;
19711 }
19712
19713
19714 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19715 PyObject *resultobj = 0;
19716 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19717 int result;
19718 void *argp1 = 0 ;
19719 int res1 = 0 ;
19720 PyObject *swig_obj[1] ;
19721
19722 if (!args) SWIG_fail;
19723 swig_obj[0] = args;
19724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19725 if (!SWIG_IsOK(res1)) {
19726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19727 }
19728 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19729 {
19730 PyThreadState* __tstate = wxPyBeginAllowThreads();
19731 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19732 wxPyEndAllowThreads(__tstate);
19733 if (PyErr_Occurred()) SWIG_fail;
19734 }
19735 resultobj = SWIG_From_int(static_cast< int >(result));
19736 return resultobj;
19737 fail:
19738 return NULL;
19739 }
19740
19741
19742 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19743 PyObject *resultobj = 0;
19744 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19745 wxString *arg2 = 0 ;
19746 void *argp1 = 0 ;
19747 int res1 = 0 ;
19748 bool temp2 = false ;
19749 PyObject * obj0 = 0 ;
19750 PyObject * obj1 = 0 ;
19751 char * kwnames[] = {
19752 (char *) "self",(char *) "s", NULL
19753 };
19754
19755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19757 if (!SWIG_IsOK(res1)) {
19758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19759 }
19760 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19761 {
19762 arg2 = wxString_in_helper(obj1);
19763 if (arg2 == NULL) SWIG_fail;
19764 temp2 = true;
19765 }
19766 {
19767 PyThreadState* __tstate = wxPyBeginAllowThreads();
19768 (arg1)->SetString((wxString const &)*arg2);
19769 wxPyEndAllowThreads(__tstate);
19770 if (PyErr_Occurred()) SWIG_fail;
19771 }
19772 resultobj = SWIG_Py_Void();
19773 {
19774 if (temp2)
19775 delete arg2;
19776 }
19777 return resultobj;
19778 fail:
19779 {
19780 if (temp2)
19781 delete arg2;
19782 }
19783 return NULL;
19784 }
19785
19786
19787 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19788 PyObject *resultobj = 0;
19789 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19790 wxString result;
19791 void *argp1 = 0 ;
19792 int res1 = 0 ;
19793 PyObject *swig_obj[1] ;
19794
19795 if (!args) SWIG_fail;
19796 swig_obj[0] = args;
19797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19798 if (!SWIG_IsOK(res1)) {
19799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19800 }
19801 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19802 {
19803 PyThreadState* __tstate = wxPyBeginAllowThreads();
19804 result = ((wxCommandEvent const *)arg1)->GetString();
19805 wxPyEndAllowThreads(__tstate);
19806 if (PyErr_Occurred()) SWIG_fail;
19807 }
19808 {
19809 #if wxUSE_UNICODE
19810 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19811 #else
19812 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19813 #endif
19814 }
19815 return resultobj;
19816 fail:
19817 return NULL;
19818 }
19819
19820
19821 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19822 PyObject *resultobj = 0;
19823 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19824 bool result;
19825 void *argp1 = 0 ;
19826 int res1 = 0 ;
19827 PyObject *swig_obj[1] ;
19828
19829 if (!args) SWIG_fail;
19830 swig_obj[0] = args;
19831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19832 if (!SWIG_IsOK(res1)) {
19833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19834 }
19835 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19836 {
19837 PyThreadState* __tstate = wxPyBeginAllowThreads();
19838 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19839 wxPyEndAllowThreads(__tstate);
19840 if (PyErr_Occurred()) SWIG_fail;
19841 }
19842 {
19843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19844 }
19845 return resultobj;
19846 fail:
19847 return NULL;
19848 }
19849
19850
19851 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19852 PyObject *resultobj = 0;
19853 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19854 bool result;
19855 void *argp1 = 0 ;
19856 int res1 = 0 ;
19857 PyObject *swig_obj[1] ;
19858
19859 if (!args) SWIG_fail;
19860 swig_obj[0] = args;
19861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19862 if (!SWIG_IsOK(res1)) {
19863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19864 }
19865 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19866 {
19867 PyThreadState* __tstate = wxPyBeginAllowThreads();
19868 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19869 wxPyEndAllowThreads(__tstate);
19870 if (PyErr_Occurred()) SWIG_fail;
19871 }
19872 {
19873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19874 }
19875 return resultobj;
19876 fail:
19877 return NULL;
19878 }
19879
19880
19881 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19882 PyObject *resultobj = 0;
19883 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19884 long arg2 ;
19885 void *argp1 = 0 ;
19886 int res1 = 0 ;
19887 long val2 ;
19888 int ecode2 = 0 ;
19889 PyObject * obj0 = 0 ;
19890 PyObject * obj1 = 0 ;
19891 char * kwnames[] = {
19892 (char *) "self",(char *) "extraLong", NULL
19893 };
19894
19895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19897 if (!SWIG_IsOK(res1)) {
19898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19899 }
19900 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19901 ecode2 = SWIG_AsVal_long(obj1, &val2);
19902 if (!SWIG_IsOK(ecode2)) {
19903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19904 }
19905 arg2 = static_cast< long >(val2);
19906 {
19907 PyThreadState* __tstate = wxPyBeginAllowThreads();
19908 (arg1)->SetExtraLong(arg2);
19909 wxPyEndAllowThreads(__tstate);
19910 if (PyErr_Occurred()) SWIG_fail;
19911 }
19912 resultobj = SWIG_Py_Void();
19913 return resultobj;
19914 fail:
19915 return NULL;
19916 }
19917
19918
19919 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19920 PyObject *resultobj = 0;
19921 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19922 long result;
19923 void *argp1 = 0 ;
19924 int res1 = 0 ;
19925 PyObject *swig_obj[1] ;
19926
19927 if (!args) SWIG_fail;
19928 swig_obj[0] = args;
19929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19930 if (!SWIG_IsOK(res1)) {
19931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19932 }
19933 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19934 {
19935 PyThreadState* __tstate = wxPyBeginAllowThreads();
19936 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19937 wxPyEndAllowThreads(__tstate);
19938 if (PyErr_Occurred()) SWIG_fail;
19939 }
19940 resultobj = SWIG_From_long(static_cast< long >(result));
19941 return resultobj;
19942 fail:
19943 return NULL;
19944 }
19945
19946
19947 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19948 PyObject *resultobj = 0;
19949 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19950 int arg2 ;
19951 void *argp1 = 0 ;
19952 int res1 = 0 ;
19953 int val2 ;
19954 int ecode2 = 0 ;
19955 PyObject * obj0 = 0 ;
19956 PyObject * obj1 = 0 ;
19957 char * kwnames[] = {
19958 (char *) "self",(char *) "i", NULL
19959 };
19960
19961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19963 if (!SWIG_IsOK(res1)) {
19964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19965 }
19966 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19967 ecode2 = SWIG_AsVal_int(obj1, &val2);
19968 if (!SWIG_IsOK(ecode2)) {
19969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19970 }
19971 arg2 = static_cast< int >(val2);
19972 {
19973 PyThreadState* __tstate = wxPyBeginAllowThreads();
19974 (arg1)->SetInt(arg2);
19975 wxPyEndAllowThreads(__tstate);
19976 if (PyErr_Occurred()) SWIG_fail;
19977 }
19978 resultobj = SWIG_Py_Void();
19979 return resultobj;
19980 fail:
19981 return NULL;
19982 }
19983
19984
19985 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19986 PyObject *resultobj = 0;
19987 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19988 int result;
19989 void *argp1 = 0 ;
19990 int res1 = 0 ;
19991 PyObject *swig_obj[1] ;
19992
19993 if (!args) SWIG_fail;
19994 swig_obj[0] = args;
19995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19996 if (!SWIG_IsOK(res1)) {
19997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19998 }
19999 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20000 {
20001 PyThreadState* __tstate = wxPyBeginAllowThreads();
20002 result = (int)((wxCommandEvent const *)arg1)->GetInt();
20003 wxPyEndAllowThreads(__tstate);
20004 if (PyErr_Occurred()) SWIG_fail;
20005 }
20006 resultobj = SWIG_From_int(static_cast< int >(result));
20007 return resultobj;
20008 fail:
20009 return NULL;
20010 }
20011
20012
20013 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20014 PyObject *resultobj = 0;
20015 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20016 PyObject *result = 0 ;
20017 void *argp1 = 0 ;
20018 int res1 = 0 ;
20019 PyObject *swig_obj[1] ;
20020
20021 if (!args) SWIG_fail;
20022 swig_obj[0] = args;
20023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20024 if (!SWIG_IsOK(res1)) {
20025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
20026 }
20027 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20028 {
20029 PyThreadState* __tstate = wxPyBeginAllowThreads();
20030 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
20031 wxPyEndAllowThreads(__tstate);
20032 if (PyErr_Occurred()) SWIG_fail;
20033 }
20034 resultobj = result;
20035 return resultobj;
20036 fail:
20037 return NULL;
20038 }
20039
20040
20041 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20042 PyObject *resultobj = 0;
20043 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20044 PyObject *arg2 = (PyObject *) 0 ;
20045 void *argp1 = 0 ;
20046 int res1 = 0 ;
20047 PyObject * obj0 = 0 ;
20048 PyObject * obj1 = 0 ;
20049 char * kwnames[] = {
20050 (char *) "self",(char *) "clientData", NULL
20051 };
20052
20053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
20054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20055 if (!SWIG_IsOK(res1)) {
20056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
20057 }
20058 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20059 arg2 = obj1;
20060 {
20061 PyThreadState* __tstate = wxPyBeginAllowThreads();
20062 wxCommandEvent_SetClientData(arg1,arg2);
20063 wxPyEndAllowThreads(__tstate);
20064 if (PyErr_Occurred()) SWIG_fail;
20065 }
20066 resultobj = SWIG_Py_Void();
20067 return resultobj;
20068 fail:
20069 return NULL;
20070 }
20071
20072
20073 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20074 PyObject *resultobj = 0;
20075 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20076 wxEvent *result = 0 ;
20077 void *argp1 = 0 ;
20078 int res1 = 0 ;
20079 PyObject *swig_obj[1] ;
20080
20081 if (!args) SWIG_fail;
20082 swig_obj[0] = args;
20083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20084 if (!SWIG_IsOK(res1)) {
20085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
20086 }
20087 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20088 {
20089 PyThreadState* __tstate = wxPyBeginAllowThreads();
20090 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
20091 wxPyEndAllowThreads(__tstate);
20092 if (PyErr_Occurred()) SWIG_fail;
20093 }
20094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
20095 return resultobj;
20096 fail:
20097 return NULL;
20098 }
20099
20100
20101 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20102 PyObject *obj;
20103 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20104 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
20105 return SWIG_Py_Void();
20106 }
20107
20108 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20109 return SWIG_Python_InitShadowInstance(args);
20110 }
20111
20112 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20113 PyObject *resultobj = 0;
20114 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20115 int arg2 = (int) 0 ;
20116 wxNotifyEvent *result = 0 ;
20117 int val1 ;
20118 int ecode1 = 0 ;
20119 int val2 ;
20120 int ecode2 = 0 ;
20121 PyObject * obj0 = 0 ;
20122 PyObject * obj1 = 0 ;
20123 char * kwnames[] = {
20124 (char *) "commandType",(char *) "winid", NULL
20125 };
20126
20127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20128 if (obj0) {
20129 ecode1 = SWIG_AsVal_int(obj0, &val1);
20130 if (!SWIG_IsOK(ecode1)) {
20131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20132 }
20133 arg1 = static_cast< wxEventType >(val1);
20134 }
20135 if (obj1) {
20136 ecode2 = SWIG_AsVal_int(obj1, &val2);
20137 if (!SWIG_IsOK(ecode2)) {
20138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
20139 }
20140 arg2 = static_cast< int >(val2);
20141 }
20142 {
20143 PyThreadState* __tstate = wxPyBeginAllowThreads();
20144 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
20145 wxPyEndAllowThreads(__tstate);
20146 if (PyErr_Occurred()) SWIG_fail;
20147 }
20148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
20149 return resultobj;
20150 fail:
20151 return NULL;
20152 }
20153
20154
20155 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20156 PyObject *resultobj = 0;
20157 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20158 void *argp1 = 0 ;
20159 int res1 = 0 ;
20160 PyObject *swig_obj[1] ;
20161
20162 if (!args) SWIG_fail;
20163 swig_obj[0] = args;
20164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20165 if (!SWIG_IsOK(res1)) {
20166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20167 }
20168 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20169 {
20170 PyThreadState* __tstate = wxPyBeginAllowThreads();
20171 (arg1)->Veto();
20172 wxPyEndAllowThreads(__tstate);
20173 if (PyErr_Occurred()) SWIG_fail;
20174 }
20175 resultobj = SWIG_Py_Void();
20176 return resultobj;
20177 fail:
20178 return NULL;
20179 }
20180
20181
20182 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20183 PyObject *resultobj = 0;
20184 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20185 void *argp1 = 0 ;
20186 int res1 = 0 ;
20187 PyObject *swig_obj[1] ;
20188
20189 if (!args) SWIG_fail;
20190 swig_obj[0] = args;
20191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20192 if (!SWIG_IsOK(res1)) {
20193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20194 }
20195 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20196 {
20197 PyThreadState* __tstate = wxPyBeginAllowThreads();
20198 (arg1)->Allow();
20199 wxPyEndAllowThreads(__tstate);
20200 if (PyErr_Occurred()) SWIG_fail;
20201 }
20202 resultobj = SWIG_Py_Void();
20203 return resultobj;
20204 fail:
20205 return NULL;
20206 }
20207
20208
20209 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20210 PyObject *resultobj = 0;
20211 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20212 bool result;
20213 void *argp1 = 0 ;
20214 int res1 = 0 ;
20215 PyObject *swig_obj[1] ;
20216
20217 if (!args) SWIG_fail;
20218 swig_obj[0] = args;
20219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20220 if (!SWIG_IsOK(res1)) {
20221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20222 }
20223 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20224 {
20225 PyThreadState* __tstate = wxPyBeginAllowThreads();
20226 result = (bool)(arg1)->IsAllowed();
20227 wxPyEndAllowThreads(__tstate);
20228 if (PyErr_Occurred()) SWIG_fail;
20229 }
20230 {
20231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20232 }
20233 return resultobj;
20234 fail:
20235 return NULL;
20236 }
20237
20238
20239 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20240 PyObject *obj;
20241 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20242 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
20243 return SWIG_Py_Void();
20244 }
20245
20246 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20247 return SWIG_Python_InitShadowInstance(args);
20248 }
20249
20250 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20251 PyObject *resultobj = 0;
20252 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20253 int arg2 = (int) 0 ;
20254 int arg3 = (int) 0 ;
20255 int arg4 = (int) 0 ;
20256 wxScrollEvent *result = 0 ;
20257 int val1 ;
20258 int ecode1 = 0 ;
20259 int val2 ;
20260 int ecode2 = 0 ;
20261 int val3 ;
20262 int ecode3 = 0 ;
20263 int val4 ;
20264 int ecode4 = 0 ;
20265 PyObject * obj0 = 0 ;
20266 PyObject * obj1 = 0 ;
20267 PyObject * obj2 = 0 ;
20268 PyObject * obj3 = 0 ;
20269 char * kwnames[] = {
20270 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
20271 };
20272
20273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20274 if (obj0) {
20275 ecode1 = SWIG_AsVal_int(obj0, &val1);
20276 if (!SWIG_IsOK(ecode1)) {
20277 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20278 }
20279 arg1 = static_cast< wxEventType >(val1);
20280 }
20281 if (obj1) {
20282 ecode2 = SWIG_AsVal_int(obj1, &val2);
20283 if (!SWIG_IsOK(ecode2)) {
20284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
20285 }
20286 arg2 = static_cast< int >(val2);
20287 }
20288 if (obj2) {
20289 ecode3 = SWIG_AsVal_int(obj2, &val3);
20290 if (!SWIG_IsOK(ecode3)) {
20291 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
20292 }
20293 arg3 = static_cast< int >(val3);
20294 }
20295 if (obj3) {
20296 ecode4 = SWIG_AsVal_int(obj3, &val4);
20297 if (!SWIG_IsOK(ecode4)) {
20298 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
20299 }
20300 arg4 = static_cast< int >(val4);
20301 }
20302 {
20303 PyThreadState* __tstate = wxPyBeginAllowThreads();
20304 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
20305 wxPyEndAllowThreads(__tstate);
20306 if (PyErr_Occurred()) SWIG_fail;
20307 }
20308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
20309 return resultobj;
20310 fail:
20311 return NULL;
20312 }
20313
20314
20315 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20316 PyObject *resultobj = 0;
20317 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20318 int result;
20319 void *argp1 = 0 ;
20320 int res1 = 0 ;
20321 PyObject *swig_obj[1] ;
20322
20323 if (!args) SWIG_fail;
20324 swig_obj[0] = args;
20325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20326 if (!SWIG_IsOK(res1)) {
20327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
20328 }
20329 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20330 {
20331 PyThreadState* __tstate = wxPyBeginAllowThreads();
20332 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
20333 wxPyEndAllowThreads(__tstate);
20334 if (PyErr_Occurred()) SWIG_fail;
20335 }
20336 resultobj = SWIG_From_int(static_cast< int >(result));
20337 return resultobj;
20338 fail:
20339 return NULL;
20340 }
20341
20342
20343 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20344 PyObject *resultobj = 0;
20345 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20346 int result;
20347 void *argp1 = 0 ;
20348 int res1 = 0 ;
20349 PyObject *swig_obj[1] ;
20350
20351 if (!args) SWIG_fail;
20352 swig_obj[0] = args;
20353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20354 if (!SWIG_IsOK(res1)) {
20355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
20356 }
20357 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20358 {
20359 PyThreadState* __tstate = wxPyBeginAllowThreads();
20360 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
20361 wxPyEndAllowThreads(__tstate);
20362 if (PyErr_Occurred()) SWIG_fail;
20363 }
20364 resultobj = SWIG_From_int(static_cast< int >(result));
20365 return resultobj;
20366 fail:
20367 return NULL;
20368 }
20369
20370
20371 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20372 PyObject *resultobj = 0;
20373 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20374 int arg2 ;
20375 void *argp1 = 0 ;
20376 int res1 = 0 ;
20377 int val2 ;
20378 int ecode2 = 0 ;
20379 PyObject * obj0 = 0 ;
20380 PyObject * obj1 = 0 ;
20381 char * kwnames[] = {
20382 (char *) "self",(char *) "orient", NULL
20383 };
20384
20385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20387 if (!SWIG_IsOK(res1)) {
20388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
20389 }
20390 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20391 ecode2 = SWIG_AsVal_int(obj1, &val2);
20392 if (!SWIG_IsOK(ecode2)) {
20393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20394 }
20395 arg2 = static_cast< int >(val2);
20396 {
20397 PyThreadState* __tstate = wxPyBeginAllowThreads();
20398 (arg1)->SetOrientation(arg2);
20399 wxPyEndAllowThreads(__tstate);
20400 if (PyErr_Occurred()) SWIG_fail;
20401 }
20402 resultobj = SWIG_Py_Void();
20403 return resultobj;
20404 fail:
20405 return NULL;
20406 }
20407
20408
20409 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20410 PyObject *resultobj = 0;
20411 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20412 int arg2 ;
20413 void *argp1 = 0 ;
20414 int res1 = 0 ;
20415 int val2 ;
20416 int ecode2 = 0 ;
20417 PyObject * obj0 = 0 ;
20418 PyObject * obj1 = 0 ;
20419 char * kwnames[] = {
20420 (char *) "self",(char *) "pos", NULL
20421 };
20422
20423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20425 if (!SWIG_IsOK(res1)) {
20426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
20427 }
20428 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20429 ecode2 = SWIG_AsVal_int(obj1, &val2);
20430 if (!SWIG_IsOK(ecode2)) {
20431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20432 }
20433 arg2 = static_cast< int >(val2);
20434 {
20435 PyThreadState* __tstate = wxPyBeginAllowThreads();
20436 (arg1)->SetPosition(arg2);
20437 wxPyEndAllowThreads(__tstate);
20438 if (PyErr_Occurred()) SWIG_fail;
20439 }
20440 resultobj = SWIG_Py_Void();
20441 return resultobj;
20442 fail:
20443 return NULL;
20444 }
20445
20446
20447 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20448 PyObject *obj;
20449 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20450 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
20451 return SWIG_Py_Void();
20452 }
20453
20454 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20455 return SWIG_Python_InitShadowInstance(args);
20456 }
20457
20458 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20459 PyObject *resultobj = 0;
20460 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20461 int arg2 = (int) 0 ;
20462 int arg3 = (int) 0 ;
20463 wxScrollWinEvent *result = 0 ;
20464 int val1 ;
20465 int ecode1 = 0 ;
20466 int val2 ;
20467 int ecode2 = 0 ;
20468 int val3 ;
20469 int ecode3 = 0 ;
20470 PyObject * obj0 = 0 ;
20471 PyObject * obj1 = 0 ;
20472 PyObject * obj2 = 0 ;
20473 char * kwnames[] = {
20474 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
20475 };
20476
20477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20478 if (obj0) {
20479 ecode1 = SWIG_AsVal_int(obj0, &val1);
20480 if (!SWIG_IsOK(ecode1)) {
20481 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20482 }
20483 arg1 = static_cast< wxEventType >(val1);
20484 }
20485 if (obj1) {
20486 ecode2 = SWIG_AsVal_int(obj1, &val2);
20487 if (!SWIG_IsOK(ecode2)) {
20488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
20489 }
20490 arg2 = static_cast< int >(val2);
20491 }
20492 if (obj2) {
20493 ecode3 = SWIG_AsVal_int(obj2, &val3);
20494 if (!SWIG_IsOK(ecode3)) {
20495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
20496 }
20497 arg3 = static_cast< int >(val3);
20498 }
20499 {
20500 PyThreadState* __tstate = wxPyBeginAllowThreads();
20501 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
20502 wxPyEndAllowThreads(__tstate);
20503 if (PyErr_Occurred()) SWIG_fail;
20504 }
20505 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
20506 return resultobj;
20507 fail:
20508 return NULL;
20509 }
20510
20511
20512 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20513 PyObject *resultobj = 0;
20514 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20515 int result;
20516 void *argp1 = 0 ;
20517 int res1 = 0 ;
20518 PyObject *swig_obj[1] ;
20519
20520 if (!args) SWIG_fail;
20521 swig_obj[0] = args;
20522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20523 if (!SWIG_IsOK(res1)) {
20524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20525 }
20526 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20527 {
20528 PyThreadState* __tstate = wxPyBeginAllowThreads();
20529 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
20530 wxPyEndAllowThreads(__tstate);
20531 if (PyErr_Occurred()) SWIG_fail;
20532 }
20533 resultobj = SWIG_From_int(static_cast< int >(result));
20534 return resultobj;
20535 fail:
20536 return NULL;
20537 }
20538
20539
20540 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20541 PyObject *resultobj = 0;
20542 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20543 int result;
20544 void *argp1 = 0 ;
20545 int res1 = 0 ;
20546 PyObject *swig_obj[1] ;
20547
20548 if (!args) SWIG_fail;
20549 swig_obj[0] = args;
20550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20551 if (!SWIG_IsOK(res1)) {
20552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20553 }
20554 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20555 {
20556 PyThreadState* __tstate = wxPyBeginAllowThreads();
20557 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
20558 wxPyEndAllowThreads(__tstate);
20559 if (PyErr_Occurred()) SWIG_fail;
20560 }
20561 resultobj = SWIG_From_int(static_cast< int >(result));
20562 return resultobj;
20563 fail:
20564 return NULL;
20565 }
20566
20567
20568 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20569 PyObject *resultobj = 0;
20570 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20571 int arg2 ;
20572 void *argp1 = 0 ;
20573 int res1 = 0 ;
20574 int val2 ;
20575 int ecode2 = 0 ;
20576 PyObject * obj0 = 0 ;
20577 PyObject * obj1 = 0 ;
20578 char * kwnames[] = {
20579 (char *) "self",(char *) "orient", NULL
20580 };
20581
20582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20584 if (!SWIG_IsOK(res1)) {
20585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20586 }
20587 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20588 ecode2 = SWIG_AsVal_int(obj1, &val2);
20589 if (!SWIG_IsOK(ecode2)) {
20590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20591 }
20592 arg2 = static_cast< int >(val2);
20593 {
20594 PyThreadState* __tstate = wxPyBeginAllowThreads();
20595 (arg1)->SetOrientation(arg2);
20596 wxPyEndAllowThreads(__tstate);
20597 if (PyErr_Occurred()) SWIG_fail;
20598 }
20599 resultobj = SWIG_Py_Void();
20600 return resultobj;
20601 fail:
20602 return NULL;
20603 }
20604
20605
20606 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20607 PyObject *resultobj = 0;
20608 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20609 int arg2 ;
20610 void *argp1 = 0 ;
20611 int res1 = 0 ;
20612 int val2 ;
20613 int ecode2 = 0 ;
20614 PyObject * obj0 = 0 ;
20615 PyObject * obj1 = 0 ;
20616 char * kwnames[] = {
20617 (char *) "self",(char *) "pos", NULL
20618 };
20619
20620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20622 if (!SWIG_IsOK(res1)) {
20623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20624 }
20625 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20626 ecode2 = SWIG_AsVal_int(obj1, &val2);
20627 if (!SWIG_IsOK(ecode2)) {
20628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20629 }
20630 arg2 = static_cast< int >(val2);
20631 {
20632 PyThreadState* __tstate = wxPyBeginAllowThreads();
20633 (arg1)->SetPosition(arg2);
20634 wxPyEndAllowThreads(__tstate);
20635 if (PyErr_Occurred()) SWIG_fail;
20636 }
20637 resultobj = SWIG_Py_Void();
20638 return resultobj;
20639 fail:
20640 return NULL;
20641 }
20642
20643
20644 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20645 PyObject *obj;
20646 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20647 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20648 return SWIG_Py_Void();
20649 }
20650
20651 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20652 return SWIG_Python_InitShadowInstance(args);
20653 }
20654
20655 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20656 PyObject *resultobj = 0;
20657 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20658 wxMouseEvent *result = 0 ;
20659 int val1 ;
20660 int ecode1 = 0 ;
20661 PyObject * obj0 = 0 ;
20662 char * kwnames[] = {
20663 (char *) "mouseType", NULL
20664 };
20665
20666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20667 if (obj0) {
20668 ecode1 = SWIG_AsVal_int(obj0, &val1);
20669 if (!SWIG_IsOK(ecode1)) {
20670 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20671 }
20672 arg1 = static_cast< wxEventType >(val1);
20673 }
20674 {
20675 PyThreadState* __tstate = wxPyBeginAllowThreads();
20676 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20677 wxPyEndAllowThreads(__tstate);
20678 if (PyErr_Occurred()) SWIG_fail;
20679 }
20680 {
20681 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20682 }
20683 return resultobj;
20684 fail:
20685 return NULL;
20686 }
20687
20688
20689 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20690 PyObject *resultobj = 0;
20691 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20692 bool result;
20693 void *argp1 = 0 ;
20694 int res1 = 0 ;
20695 PyObject *swig_obj[1] ;
20696
20697 if (!args) SWIG_fail;
20698 swig_obj[0] = args;
20699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20700 if (!SWIG_IsOK(res1)) {
20701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20702 }
20703 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20704 {
20705 PyThreadState* __tstate = wxPyBeginAllowThreads();
20706 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20707 wxPyEndAllowThreads(__tstate);
20708 if (PyErr_Occurred()) SWIG_fail;
20709 }
20710 {
20711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20712 }
20713 return resultobj;
20714 fail:
20715 return NULL;
20716 }
20717
20718
20719 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20720 PyObject *resultobj = 0;
20721 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20722 int arg2 = (int) wxMOUSE_BTN_ANY ;
20723 bool result;
20724 void *argp1 = 0 ;
20725 int res1 = 0 ;
20726 int val2 ;
20727 int ecode2 = 0 ;
20728 PyObject * obj0 = 0 ;
20729 PyObject * obj1 = 0 ;
20730 char * kwnames[] = {
20731 (char *) "self",(char *) "but", NULL
20732 };
20733
20734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20736 if (!SWIG_IsOK(res1)) {
20737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20738 }
20739 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20740 if (obj1) {
20741 ecode2 = SWIG_AsVal_int(obj1, &val2);
20742 if (!SWIG_IsOK(ecode2)) {
20743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20744 }
20745 arg2 = static_cast< int >(val2);
20746 }
20747 {
20748 PyThreadState* __tstate = wxPyBeginAllowThreads();
20749 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20750 wxPyEndAllowThreads(__tstate);
20751 if (PyErr_Occurred()) SWIG_fail;
20752 }
20753 {
20754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20755 }
20756 return resultobj;
20757 fail:
20758 return NULL;
20759 }
20760
20761
20762 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20763 PyObject *resultobj = 0;
20764 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20765 int arg2 = (int) wxMOUSE_BTN_ANY ;
20766 bool result;
20767 void *argp1 = 0 ;
20768 int res1 = 0 ;
20769 int val2 ;
20770 int ecode2 = 0 ;
20771 PyObject * obj0 = 0 ;
20772 PyObject * obj1 = 0 ;
20773 char * kwnames[] = {
20774 (char *) "self",(char *) "but", NULL
20775 };
20776
20777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20779 if (!SWIG_IsOK(res1)) {
20780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20781 }
20782 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20783 if (obj1) {
20784 ecode2 = SWIG_AsVal_int(obj1, &val2);
20785 if (!SWIG_IsOK(ecode2)) {
20786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20787 }
20788 arg2 = static_cast< int >(val2);
20789 }
20790 {
20791 PyThreadState* __tstate = wxPyBeginAllowThreads();
20792 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20793 wxPyEndAllowThreads(__tstate);
20794 if (PyErr_Occurred()) SWIG_fail;
20795 }
20796 {
20797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20798 }
20799 return resultobj;
20800 fail:
20801 return NULL;
20802 }
20803
20804
20805 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20806 PyObject *resultobj = 0;
20807 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20808 int arg2 = (int) wxMOUSE_BTN_ANY ;
20809 bool result;
20810 void *argp1 = 0 ;
20811 int res1 = 0 ;
20812 int val2 ;
20813 int ecode2 = 0 ;
20814 PyObject * obj0 = 0 ;
20815 PyObject * obj1 = 0 ;
20816 char * kwnames[] = {
20817 (char *) "self",(char *) "but", NULL
20818 };
20819
20820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20822 if (!SWIG_IsOK(res1)) {
20823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20824 }
20825 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20826 if (obj1) {
20827 ecode2 = SWIG_AsVal_int(obj1, &val2);
20828 if (!SWIG_IsOK(ecode2)) {
20829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20830 }
20831 arg2 = static_cast< int >(val2);
20832 }
20833 {
20834 PyThreadState* __tstate = wxPyBeginAllowThreads();
20835 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20836 wxPyEndAllowThreads(__tstate);
20837 if (PyErr_Occurred()) SWIG_fail;
20838 }
20839 {
20840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20841 }
20842 return resultobj;
20843 fail:
20844 return NULL;
20845 }
20846
20847
20848 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20849 PyObject *resultobj = 0;
20850 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20851 int arg2 ;
20852 bool result;
20853 void *argp1 = 0 ;
20854 int res1 = 0 ;
20855 int val2 ;
20856 int ecode2 = 0 ;
20857 PyObject * obj0 = 0 ;
20858 PyObject * obj1 = 0 ;
20859 char * kwnames[] = {
20860 (char *) "self",(char *) "button", NULL
20861 };
20862
20863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20865 if (!SWIG_IsOK(res1)) {
20866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20867 }
20868 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20869 ecode2 = SWIG_AsVal_int(obj1, &val2);
20870 if (!SWIG_IsOK(ecode2)) {
20871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20872 }
20873 arg2 = static_cast< int >(val2);
20874 {
20875 PyThreadState* __tstate = wxPyBeginAllowThreads();
20876 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20877 wxPyEndAllowThreads(__tstate);
20878 if (PyErr_Occurred()) SWIG_fail;
20879 }
20880 {
20881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20882 }
20883 return resultobj;
20884 fail:
20885 return NULL;
20886 }
20887
20888
20889 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20890 PyObject *resultobj = 0;
20891 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20892 int arg2 ;
20893 bool result;
20894 void *argp1 = 0 ;
20895 int res1 = 0 ;
20896 int val2 ;
20897 int ecode2 = 0 ;
20898 PyObject * obj0 = 0 ;
20899 PyObject * obj1 = 0 ;
20900 char * kwnames[] = {
20901 (char *) "self",(char *) "but", NULL
20902 };
20903
20904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20906 if (!SWIG_IsOK(res1)) {
20907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20908 }
20909 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20910 ecode2 = SWIG_AsVal_int(obj1, &val2);
20911 if (!SWIG_IsOK(ecode2)) {
20912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20913 }
20914 arg2 = static_cast< int >(val2);
20915 {
20916 PyThreadState* __tstate = wxPyBeginAllowThreads();
20917 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20918 wxPyEndAllowThreads(__tstate);
20919 if (PyErr_Occurred()) SWIG_fail;
20920 }
20921 {
20922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20923 }
20924 return resultobj;
20925 fail:
20926 return NULL;
20927 }
20928
20929
20930 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20931 PyObject *resultobj = 0;
20932 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20933 int result;
20934 void *argp1 = 0 ;
20935 int res1 = 0 ;
20936 PyObject *swig_obj[1] ;
20937
20938 if (!args) SWIG_fail;
20939 swig_obj[0] = args;
20940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20941 if (!SWIG_IsOK(res1)) {
20942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20943 }
20944 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20945 {
20946 PyThreadState* __tstate = wxPyBeginAllowThreads();
20947 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20948 wxPyEndAllowThreads(__tstate);
20949 if (PyErr_Occurred()) SWIG_fail;
20950 }
20951 resultobj = SWIG_From_int(static_cast< int >(result));
20952 return resultobj;
20953 fail:
20954 return NULL;
20955 }
20956
20957
20958 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20959 PyObject *resultobj = 0;
20960 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20961 bool result;
20962 void *argp1 = 0 ;
20963 int res1 = 0 ;
20964 PyObject *swig_obj[1] ;
20965
20966 if (!args) SWIG_fail;
20967 swig_obj[0] = args;
20968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20969 if (!SWIG_IsOK(res1)) {
20970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20971 }
20972 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20973 {
20974 PyThreadState* __tstate = wxPyBeginAllowThreads();
20975 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20976 wxPyEndAllowThreads(__tstate);
20977 if (PyErr_Occurred()) SWIG_fail;
20978 }
20979 {
20980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20981 }
20982 return resultobj;
20983 fail:
20984 return NULL;
20985 }
20986
20987
20988 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20989 PyObject *resultobj = 0;
20990 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20991 bool result;
20992 void *argp1 = 0 ;
20993 int res1 = 0 ;
20994 PyObject *swig_obj[1] ;
20995
20996 if (!args) SWIG_fail;
20997 swig_obj[0] = args;
20998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20999 if (!SWIG_IsOK(res1)) {
21000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21001 }
21002 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21003 {
21004 PyThreadState* __tstate = wxPyBeginAllowThreads();
21005 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
21006 wxPyEndAllowThreads(__tstate);
21007 if (PyErr_Occurred()) SWIG_fail;
21008 }
21009 {
21010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21011 }
21012 return resultobj;
21013 fail:
21014 return NULL;
21015 }
21016
21017
21018 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21019 PyObject *resultobj = 0;
21020 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21021 bool result;
21022 void *argp1 = 0 ;
21023 int res1 = 0 ;
21024 PyObject *swig_obj[1] ;
21025
21026 if (!args) SWIG_fail;
21027 swig_obj[0] = args;
21028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21029 if (!SWIG_IsOK(res1)) {
21030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21031 }
21032 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21033 {
21034 PyThreadState* __tstate = wxPyBeginAllowThreads();
21035 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
21036 wxPyEndAllowThreads(__tstate);
21037 if (PyErr_Occurred()) SWIG_fail;
21038 }
21039 {
21040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21041 }
21042 return resultobj;
21043 fail:
21044 return NULL;
21045 }
21046
21047
21048 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21049 PyObject *resultobj = 0;
21050 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21051 bool result;
21052 void *argp1 = 0 ;
21053 int res1 = 0 ;
21054 PyObject *swig_obj[1] ;
21055
21056 if (!args) SWIG_fail;
21057 swig_obj[0] = args;
21058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21059 if (!SWIG_IsOK(res1)) {
21060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21061 }
21062 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21063 {
21064 PyThreadState* __tstate = wxPyBeginAllowThreads();
21065 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
21066 wxPyEndAllowThreads(__tstate);
21067 if (PyErr_Occurred()) SWIG_fail;
21068 }
21069 {
21070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21071 }
21072 return resultobj;
21073 fail:
21074 return NULL;
21075 }
21076
21077
21078 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21079 PyObject *resultobj = 0;
21080 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21081 bool result;
21082 void *argp1 = 0 ;
21083 int res1 = 0 ;
21084 PyObject *swig_obj[1] ;
21085
21086 if (!args) SWIG_fail;
21087 swig_obj[0] = args;
21088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21089 if (!SWIG_IsOK(res1)) {
21090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21091 }
21092 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21093 {
21094 PyThreadState* __tstate = wxPyBeginAllowThreads();
21095 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
21096 wxPyEndAllowThreads(__tstate);
21097 if (PyErr_Occurred()) SWIG_fail;
21098 }
21099 {
21100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21101 }
21102 return resultobj;
21103 fail:
21104 return NULL;
21105 }
21106
21107
21108 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21109 PyObject *resultobj = 0;
21110 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21111 bool result;
21112 void *argp1 = 0 ;
21113 int res1 = 0 ;
21114 PyObject *swig_obj[1] ;
21115
21116 if (!args) SWIG_fail;
21117 swig_obj[0] = args;
21118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21119 if (!SWIG_IsOK(res1)) {
21120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21121 }
21122 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21123 {
21124 PyThreadState* __tstate = wxPyBeginAllowThreads();
21125 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
21126 wxPyEndAllowThreads(__tstate);
21127 if (PyErr_Occurred()) SWIG_fail;
21128 }
21129 {
21130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21131 }
21132 return resultobj;
21133 fail:
21134 return NULL;
21135 }
21136
21137
21138 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21139 PyObject *resultobj = 0;
21140 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21141 bool result;
21142 void *argp1 = 0 ;
21143 int res1 = 0 ;
21144 PyObject *swig_obj[1] ;
21145
21146 if (!args) SWIG_fail;
21147 swig_obj[0] = args;
21148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21149 if (!SWIG_IsOK(res1)) {
21150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21151 }
21152 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21153 {
21154 PyThreadState* __tstate = wxPyBeginAllowThreads();
21155 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
21156 wxPyEndAllowThreads(__tstate);
21157 if (PyErr_Occurred()) SWIG_fail;
21158 }
21159 {
21160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21161 }
21162 return resultobj;
21163 fail:
21164 return NULL;
21165 }
21166
21167
21168 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21169 PyObject *resultobj = 0;
21170 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21171 bool result;
21172 void *argp1 = 0 ;
21173 int res1 = 0 ;
21174 PyObject *swig_obj[1] ;
21175
21176 if (!args) SWIG_fail;
21177 swig_obj[0] = args;
21178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21179 if (!SWIG_IsOK(res1)) {
21180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21181 }
21182 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21183 {
21184 PyThreadState* __tstate = wxPyBeginAllowThreads();
21185 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
21186 wxPyEndAllowThreads(__tstate);
21187 if (PyErr_Occurred()) SWIG_fail;
21188 }
21189 {
21190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21191 }
21192 return resultobj;
21193 fail:
21194 return NULL;
21195 }
21196
21197
21198 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21199 PyObject *resultobj = 0;
21200 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21201 bool result;
21202 void *argp1 = 0 ;
21203 int res1 = 0 ;
21204 PyObject *swig_obj[1] ;
21205
21206 if (!args) SWIG_fail;
21207 swig_obj[0] = args;
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_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21211 }
21212 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21213 {
21214 PyThreadState* __tstate = wxPyBeginAllowThreads();
21215 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
21216 wxPyEndAllowThreads(__tstate);
21217 if (PyErr_Occurred()) SWIG_fail;
21218 }
21219 {
21220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21221 }
21222 return resultobj;
21223 fail:
21224 return NULL;
21225 }
21226
21227
21228 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21229 PyObject *resultobj = 0;
21230 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21231 bool result;
21232 void *argp1 = 0 ;
21233 int res1 = 0 ;
21234 PyObject *swig_obj[1] ;
21235
21236 if (!args) SWIG_fail;
21237 swig_obj[0] = args;
21238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21239 if (!SWIG_IsOK(res1)) {
21240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21241 }
21242 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21243 {
21244 PyThreadState* __tstate = wxPyBeginAllowThreads();
21245 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
21246 wxPyEndAllowThreads(__tstate);
21247 if (PyErr_Occurred()) SWIG_fail;
21248 }
21249 {
21250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21251 }
21252 return resultobj;
21253 fail:
21254 return NULL;
21255 }
21256
21257
21258 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21259 PyObject *resultobj = 0;
21260 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21261 bool result;
21262 void *argp1 = 0 ;
21263 int res1 = 0 ;
21264 PyObject *swig_obj[1] ;
21265
21266 if (!args) SWIG_fail;
21267 swig_obj[0] = args;
21268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21269 if (!SWIG_IsOK(res1)) {
21270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21271 }
21272 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21273 {
21274 PyThreadState* __tstate = wxPyBeginAllowThreads();
21275 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
21276 wxPyEndAllowThreads(__tstate);
21277 if (PyErr_Occurred()) SWIG_fail;
21278 }
21279 {
21280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21281 }
21282 return resultobj;
21283 fail:
21284 return NULL;
21285 }
21286
21287
21288 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21289 PyObject *resultobj = 0;
21290 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21291 bool result;
21292 void *argp1 = 0 ;
21293 int res1 = 0 ;
21294 PyObject *swig_obj[1] ;
21295
21296 if (!args) SWIG_fail;
21297 swig_obj[0] = args;
21298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21299 if (!SWIG_IsOK(res1)) {
21300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21301 }
21302 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21303 {
21304 PyThreadState* __tstate = wxPyBeginAllowThreads();
21305 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
21306 wxPyEndAllowThreads(__tstate);
21307 if (PyErr_Occurred()) SWIG_fail;
21308 }
21309 {
21310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21311 }
21312 return resultobj;
21313 fail:
21314 return NULL;
21315 }
21316
21317
21318 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21319 PyObject *resultobj = 0;
21320 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21321 bool result;
21322 void *argp1 = 0 ;
21323 int res1 = 0 ;
21324 PyObject *swig_obj[1] ;
21325
21326 if (!args) SWIG_fail;
21327 swig_obj[0] = args;
21328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21329 if (!SWIG_IsOK(res1)) {
21330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21331 }
21332 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21333 {
21334 PyThreadState* __tstate = wxPyBeginAllowThreads();
21335 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
21336 wxPyEndAllowThreads(__tstate);
21337 if (PyErr_Occurred()) SWIG_fail;
21338 }
21339 {
21340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21341 }
21342 return resultobj;
21343 fail:
21344 return NULL;
21345 }
21346
21347
21348 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21349 PyObject *resultobj = 0;
21350 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21351 bool result;
21352 void *argp1 = 0 ;
21353 int res1 = 0 ;
21354 PyObject *swig_obj[1] ;
21355
21356 if (!args) SWIG_fail;
21357 swig_obj[0] = args;
21358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21359 if (!SWIG_IsOK(res1)) {
21360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21361 }
21362 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21363 {
21364 PyThreadState* __tstate = wxPyBeginAllowThreads();
21365 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
21366 wxPyEndAllowThreads(__tstate);
21367 if (PyErr_Occurred()) SWIG_fail;
21368 }
21369 {
21370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21371 }
21372 return resultobj;
21373 fail:
21374 return NULL;
21375 }
21376
21377
21378 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21379 PyObject *resultobj = 0;
21380 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21381 bool result;
21382 void *argp1 = 0 ;
21383 int res1 = 0 ;
21384 PyObject *swig_obj[1] ;
21385
21386 if (!args) SWIG_fail;
21387 swig_obj[0] = args;
21388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21389 if (!SWIG_IsOK(res1)) {
21390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21391 }
21392 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21393 {
21394 PyThreadState* __tstate = wxPyBeginAllowThreads();
21395 result = (bool)(arg1)->LeftIsDown();
21396 wxPyEndAllowThreads(__tstate);
21397 if (PyErr_Occurred()) SWIG_fail;
21398 }
21399 {
21400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21401 }
21402 return resultobj;
21403 fail:
21404 return NULL;
21405 }
21406
21407
21408 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21409 PyObject *resultobj = 0;
21410 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21411 bool result;
21412 void *argp1 = 0 ;
21413 int res1 = 0 ;
21414 PyObject *swig_obj[1] ;
21415
21416 if (!args) SWIG_fail;
21417 swig_obj[0] = args;
21418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21419 if (!SWIG_IsOK(res1)) {
21420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21421 }
21422 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21423 {
21424 PyThreadState* __tstate = wxPyBeginAllowThreads();
21425 result = (bool)(arg1)->MiddleIsDown();
21426 wxPyEndAllowThreads(__tstate);
21427 if (PyErr_Occurred()) SWIG_fail;
21428 }
21429 {
21430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21431 }
21432 return resultobj;
21433 fail:
21434 return NULL;
21435 }
21436
21437
21438 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21439 PyObject *resultobj = 0;
21440 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21441 bool result;
21442 void *argp1 = 0 ;
21443 int res1 = 0 ;
21444 PyObject *swig_obj[1] ;
21445
21446 if (!args) SWIG_fail;
21447 swig_obj[0] = args;
21448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21449 if (!SWIG_IsOK(res1)) {
21450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21451 }
21452 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21453 {
21454 PyThreadState* __tstate = wxPyBeginAllowThreads();
21455 result = (bool)(arg1)->RightIsDown();
21456 wxPyEndAllowThreads(__tstate);
21457 if (PyErr_Occurred()) SWIG_fail;
21458 }
21459 {
21460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21461 }
21462 return resultobj;
21463 fail:
21464 return NULL;
21465 }
21466
21467
21468 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21469 PyObject *resultobj = 0;
21470 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21471 bool result;
21472 void *argp1 = 0 ;
21473 int res1 = 0 ;
21474 PyObject *swig_obj[1] ;
21475
21476 if (!args) SWIG_fail;
21477 swig_obj[0] = args;
21478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21479 if (!SWIG_IsOK(res1)) {
21480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21481 }
21482 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21483 {
21484 PyThreadState* __tstate = wxPyBeginAllowThreads();
21485 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
21486 wxPyEndAllowThreads(__tstate);
21487 if (PyErr_Occurred()) SWIG_fail;
21488 }
21489 {
21490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21491 }
21492 return resultobj;
21493 fail:
21494 return NULL;
21495 }
21496
21497
21498 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21499 PyObject *resultobj = 0;
21500 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21501 bool result;
21502 void *argp1 = 0 ;
21503 int res1 = 0 ;
21504 PyObject *swig_obj[1] ;
21505
21506 if (!args) SWIG_fail;
21507 swig_obj[0] = args;
21508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21509 if (!SWIG_IsOK(res1)) {
21510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21511 }
21512 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21513 {
21514 PyThreadState* __tstate = wxPyBeginAllowThreads();
21515 result = (bool)((wxMouseEvent const *)arg1)->Moving();
21516 wxPyEndAllowThreads(__tstate);
21517 if (PyErr_Occurred()) SWIG_fail;
21518 }
21519 {
21520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21521 }
21522 return resultobj;
21523 fail:
21524 return NULL;
21525 }
21526
21527
21528 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21529 PyObject *resultobj = 0;
21530 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21531 bool result;
21532 void *argp1 = 0 ;
21533 int res1 = 0 ;
21534 PyObject *swig_obj[1] ;
21535
21536 if (!args) SWIG_fail;
21537 swig_obj[0] = args;
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_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21541 }
21542 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21543 {
21544 PyThreadState* __tstate = wxPyBeginAllowThreads();
21545 result = (bool)((wxMouseEvent const *)arg1)->Entering();
21546 wxPyEndAllowThreads(__tstate);
21547 if (PyErr_Occurred()) SWIG_fail;
21548 }
21549 {
21550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21551 }
21552 return resultobj;
21553 fail:
21554 return NULL;
21555 }
21556
21557
21558 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21559 PyObject *resultobj = 0;
21560 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21561 bool result;
21562 void *argp1 = 0 ;
21563 int res1 = 0 ;
21564 PyObject *swig_obj[1] ;
21565
21566 if (!args) SWIG_fail;
21567 swig_obj[0] = args;
21568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21569 if (!SWIG_IsOK(res1)) {
21570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21571 }
21572 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21573 {
21574 PyThreadState* __tstate = wxPyBeginAllowThreads();
21575 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
21576 wxPyEndAllowThreads(__tstate);
21577 if (PyErr_Occurred()) SWIG_fail;
21578 }
21579 {
21580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21581 }
21582 return resultobj;
21583 fail:
21584 return NULL;
21585 }
21586
21587
21588 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21589 PyObject *resultobj = 0;
21590 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21591 wxPoint result;
21592 void *argp1 = 0 ;
21593 int res1 = 0 ;
21594 PyObject *swig_obj[1] ;
21595
21596 if (!args) SWIG_fail;
21597 swig_obj[0] = args;
21598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21599 if (!SWIG_IsOK(res1)) {
21600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21601 }
21602 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21603 {
21604 PyThreadState* __tstate = wxPyBeginAllowThreads();
21605 result = (arg1)->GetPosition();
21606 wxPyEndAllowThreads(__tstate);
21607 if (PyErr_Occurred()) SWIG_fail;
21608 }
21609 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21610 return resultobj;
21611 fail:
21612 return NULL;
21613 }
21614
21615
21616 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21617 PyObject *resultobj = 0;
21618 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21619 long *arg2 = (long *) 0 ;
21620 long *arg3 = (long *) 0 ;
21621 void *argp1 = 0 ;
21622 int res1 = 0 ;
21623 long temp2 ;
21624 int res2 = SWIG_TMPOBJ ;
21625 long temp3 ;
21626 int res3 = SWIG_TMPOBJ ;
21627 PyObject *swig_obj[1] ;
21628
21629 arg2 = &temp2;
21630 arg3 = &temp3;
21631 if (!args) SWIG_fail;
21632 swig_obj[0] = args;
21633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21634 if (!SWIG_IsOK(res1)) {
21635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21636 }
21637 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21638 {
21639 PyThreadState* __tstate = wxPyBeginAllowThreads();
21640 (arg1)->GetPosition(arg2,arg3);
21641 wxPyEndAllowThreads(__tstate);
21642 if (PyErr_Occurred()) SWIG_fail;
21643 }
21644 resultobj = SWIG_Py_Void();
21645 if (SWIG_IsTmpObj(res2)) {
21646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21647 } else {
21648 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21650 }
21651 if (SWIG_IsTmpObj(res3)) {
21652 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21653 } else {
21654 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21655 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21656 }
21657 return resultobj;
21658 fail:
21659 return NULL;
21660 }
21661
21662
21663 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21664 PyObject *resultobj = 0;
21665 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21666 wxDC *arg2 = 0 ;
21667 wxPoint result;
21668 void *argp1 = 0 ;
21669 int res1 = 0 ;
21670 void *argp2 = 0 ;
21671 int res2 = 0 ;
21672 PyObject * obj0 = 0 ;
21673 PyObject * obj1 = 0 ;
21674 char * kwnames[] = {
21675 (char *) "self",(char *) "dc", NULL
21676 };
21677
21678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21680 if (!SWIG_IsOK(res1)) {
21681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21682 }
21683 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21684 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21685 if (!SWIG_IsOK(res2)) {
21686 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21687 }
21688 if (!argp2) {
21689 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21690 }
21691 arg2 = reinterpret_cast< wxDC * >(argp2);
21692 {
21693 PyThreadState* __tstate = wxPyBeginAllowThreads();
21694 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21695 wxPyEndAllowThreads(__tstate);
21696 if (PyErr_Occurred()) SWIG_fail;
21697 }
21698 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21699 return resultobj;
21700 fail:
21701 return NULL;
21702 }
21703
21704
21705 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21706 PyObject *resultobj = 0;
21707 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21708 int result;
21709 void *argp1 = 0 ;
21710 int res1 = 0 ;
21711 PyObject *swig_obj[1] ;
21712
21713 if (!args) SWIG_fail;
21714 swig_obj[0] = args;
21715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21716 if (!SWIG_IsOK(res1)) {
21717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21718 }
21719 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21720 {
21721 PyThreadState* __tstate = wxPyBeginAllowThreads();
21722 result = (int)((wxMouseEvent const *)arg1)->GetX();
21723 wxPyEndAllowThreads(__tstate);
21724 if (PyErr_Occurred()) SWIG_fail;
21725 }
21726 resultobj = SWIG_From_int(static_cast< int >(result));
21727 return resultobj;
21728 fail:
21729 return NULL;
21730 }
21731
21732
21733 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21734 PyObject *resultobj = 0;
21735 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21736 int result;
21737 void *argp1 = 0 ;
21738 int res1 = 0 ;
21739 PyObject *swig_obj[1] ;
21740
21741 if (!args) SWIG_fail;
21742 swig_obj[0] = args;
21743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21744 if (!SWIG_IsOK(res1)) {
21745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21746 }
21747 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21748 {
21749 PyThreadState* __tstate = wxPyBeginAllowThreads();
21750 result = (int)((wxMouseEvent const *)arg1)->GetY();
21751 wxPyEndAllowThreads(__tstate);
21752 if (PyErr_Occurred()) SWIG_fail;
21753 }
21754 resultobj = SWIG_From_int(static_cast< int >(result));
21755 return resultobj;
21756 fail:
21757 return NULL;
21758 }
21759
21760
21761 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21762 PyObject *resultobj = 0;
21763 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21764 int result;
21765 void *argp1 = 0 ;
21766 int res1 = 0 ;
21767 PyObject *swig_obj[1] ;
21768
21769 if (!args) SWIG_fail;
21770 swig_obj[0] = args;
21771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21772 if (!SWIG_IsOK(res1)) {
21773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21774 }
21775 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21776 {
21777 PyThreadState* __tstate = wxPyBeginAllowThreads();
21778 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21779 wxPyEndAllowThreads(__tstate);
21780 if (PyErr_Occurred()) SWIG_fail;
21781 }
21782 resultobj = SWIG_From_int(static_cast< int >(result));
21783 return resultobj;
21784 fail:
21785 return NULL;
21786 }
21787
21788
21789 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21790 PyObject *resultobj = 0;
21791 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21792 int result;
21793 void *argp1 = 0 ;
21794 int res1 = 0 ;
21795 PyObject *swig_obj[1] ;
21796
21797 if (!args) SWIG_fail;
21798 swig_obj[0] = args;
21799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21800 if (!SWIG_IsOK(res1)) {
21801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21802 }
21803 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21804 {
21805 PyThreadState* __tstate = wxPyBeginAllowThreads();
21806 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21807 wxPyEndAllowThreads(__tstate);
21808 if (PyErr_Occurred()) SWIG_fail;
21809 }
21810 resultobj = SWIG_From_int(static_cast< int >(result));
21811 return resultobj;
21812 fail:
21813 return NULL;
21814 }
21815
21816
21817 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21818 PyObject *resultobj = 0;
21819 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21820 int result;
21821 void *argp1 = 0 ;
21822 int res1 = 0 ;
21823 PyObject *swig_obj[1] ;
21824
21825 if (!args) SWIG_fail;
21826 swig_obj[0] = args;
21827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21828 if (!SWIG_IsOK(res1)) {
21829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21830 }
21831 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21832 {
21833 PyThreadState* __tstate = wxPyBeginAllowThreads();
21834 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21835 wxPyEndAllowThreads(__tstate);
21836 if (PyErr_Occurred()) SWIG_fail;
21837 }
21838 resultobj = SWIG_From_int(static_cast< int >(result));
21839 return resultobj;
21840 fail:
21841 return NULL;
21842 }
21843
21844
21845 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21846 PyObject *resultobj = 0;
21847 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21848 bool result;
21849 void *argp1 = 0 ;
21850 int res1 = 0 ;
21851 PyObject *swig_obj[1] ;
21852
21853 if (!args) SWIG_fail;
21854 swig_obj[0] = args;
21855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21856 if (!SWIG_IsOK(res1)) {
21857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21858 }
21859 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21860 {
21861 PyThreadState* __tstate = wxPyBeginAllowThreads();
21862 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21863 wxPyEndAllowThreads(__tstate);
21864 if (PyErr_Occurred()) SWIG_fail;
21865 }
21866 {
21867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21868 }
21869 return resultobj;
21870 fail:
21871 return NULL;
21872 }
21873
21874
21875 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21876 PyObject *resultobj = 0;
21877 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21878 int arg2 ;
21879 void *argp1 = 0 ;
21880 int res1 = 0 ;
21881 int val2 ;
21882 int ecode2 = 0 ;
21883 PyObject *swig_obj[2] ;
21884
21885 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21887 if (!SWIG_IsOK(res1)) {
21888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21889 }
21890 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21891 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21892 if (!SWIG_IsOK(ecode2)) {
21893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21894 }
21895 arg2 = static_cast< int >(val2);
21896 if (arg1) (arg1)->m_x = arg2;
21897
21898 resultobj = SWIG_Py_Void();
21899 return resultobj;
21900 fail:
21901 return NULL;
21902 }
21903
21904
21905 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21906 PyObject *resultobj = 0;
21907 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21908 int result;
21909 void *argp1 = 0 ;
21910 int res1 = 0 ;
21911 PyObject *swig_obj[1] ;
21912
21913 if (!args) SWIG_fail;
21914 swig_obj[0] = args;
21915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21916 if (!SWIG_IsOK(res1)) {
21917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21918 }
21919 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21920 result = (int) ((arg1)->m_x);
21921 resultobj = SWIG_From_int(static_cast< int >(result));
21922 return resultobj;
21923 fail:
21924 return NULL;
21925 }
21926
21927
21928 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21929 PyObject *resultobj = 0;
21930 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21931 int arg2 ;
21932 void *argp1 = 0 ;
21933 int res1 = 0 ;
21934 int val2 ;
21935 int ecode2 = 0 ;
21936 PyObject *swig_obj[2] ;
21937
21938 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21940 if (!SWIG_IsOK(res1)) {
21941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21942 }
21943 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21944 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21945 if (!SWIG_IsOK(ecode2)) {
21946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21947 }
21948 arg2 = static_cast< int >(val2);
21949 if (arg1) (arg1)->m_y = arg2;
21950
21951 resultobj = SWIG_Py_Void();
21952 return resultobj;
21953 fail:
21954 return NULL;
21955 }
21956
21957
21958 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21959 PyObject *resultobj = 0;
21960 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21961 int result;
21962 void *argp1 = 0 ;
21963 int res1 = 0 ;
21964 PyObject *swig_obj[1] ;
21965
21966 if (!args) SWIG_fail;
21967 swig_obj[0] = args;
21968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21969 if (!SWIG_IsOK(res1)) {
21970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21971 }
21972 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21973 result = (int) ((arg1)->m_y);
21974 resultobj = SWIG_From_int(static_cast< int >(result));
21975 return resultobj;
21976 fail:
21977 return NULL;
21978 }
21979
21980
21981 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21982 PyObject *resultobj = 0;
21983 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21984 bool arg2 ;
21985 void *argp1 = 0 ;
21986 int res1 = 0 ;
21987 bool val2 ;
21988 int ecode2 = 0 ;
21989 PyObject *swig_obj[2] ;
21990
21991 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21993 if (!SWIG_IsOK(res1)) {
21994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21995 }
21996 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21997 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21998 if (!SWIG_IsOK(ecode2)) {
21999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
22000 }
22001 arg2 = static_cast< bool >(val2);
22002 if (arg1) (arg1)->m_leftDown = arg2;
22003
22004 resultobj = SWIG_Py_Void();
22005 return resultobj;
22006 fail:
22007 return NULL;
22008 }
22009
22010
22011 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22012 PyObject *resultobj = 0;
22013 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22014 bool result;
22015 void *argp1 = 0 ;
22016 int res1 = 0 ;
22017 PyObject *swig_obj[1] ;
22018
22019 if (!args) SWIG_fail;
22020 swig_obj[0] = args;
22021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22022 if (!SWIG_IsOK(res1)) {
22023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22024 }
22025 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22026 result = (bool) ((arg1)->m_leftDown);
22027 {
22028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22029 }
22030 return resultobj;
22031 fail:
22032 return NULL;
22033 }
22034
22035
22036 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22037 PyObject *resultobj = 0;
22038 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22039 bool arg2 ;
22040 void *argp1 = 0 ;
22041 int res1 = 0 ;
22042 bool val2 ;
22043 int ecode2 = 0 ;
22044 PyObject *swig_obj[2] ;
22045
22046 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
22047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22048 if (!SWIG_IsOK(res1)) {
22049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22050 }
22051 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22052 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22053 if (!SWIG_IsOK(ecode2)) {
22054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
22055 }
22056 arg2 = static_cast< bool >(val2);
22057 if (arg1) (arg1)->m_middleDown = arg2;
22058
22059 resultobj = SWIG_Py_Void();
22060 return resultobj;
22061 fail:
22062 return NULL;
22063 }
22064
22065
22066 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22067 PyObject *resultobj = 0;
22068 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22069 bool result;
22070 void *argp1 = 0 ;
22071 int res1 = 0 ;
22072 PyObject *swig_obj[1] ;
22073
22074 if (!args) SWIG_fail;
22075 swig_obj[0] = args;
22076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22077 if (!SWIG_IsOK(res1)) {
22078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22079 }
22080 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22081 result = (bool) ((arg1)->m_middleDown);
22082 {
22083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22084 }
22085 return resultobj;
22086 fail:
22087 return NULL;
22088 }
22089
22090
22091 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22092 PyObject *resultobj = 0;
22093 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22094 bool arg2 ;
22095 void *argp1 = 0 ;
22096 int res1 = 0 ;
22097 bool val2 ;
22098 int ecode2 = 0 ;
22099 PyObject *swig_obj[2] ;
22100
22101 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
22102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22103 if (!SWIG_IsOK(res1)) {
22104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22105 }
22106 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22107 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22108 if (!SWIG_IsOK(ecode2)) {
22109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
22110 }
22111 arg2 = static_cast< bool >(val2);
22112 if (arg1) (arg1)->m_rightDown = arg2;
22113
22114 resultobj = SWIG_Py_Void();
22115 return resultobj;
22116 fail:
22117 return NULL;
22118 }
22119
22120
22121 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22122 PyObject *resultobj = 0;
22123 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22124 bool result;
22125 void *argp1 = 0 ;
22126 int res1 = 0 ;
22127 PyObject *swig_obj[1] ;
22128
22129 if (!args) SWIG_fail;
22130 swig_obj[0] = args;
22131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22132 if (!SWIG_IsOK(res1)) {
22133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22134 }
22135 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22136 result = (bool) ((arg1)->m_rightDown);
22137 {
22138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22139 }
22140 return resultobj;
22141 fail:
22142 return NULL;
22143 }
22144
22145
22146 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22147 PyObject *resultobj = 0;
22148 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22149 bool arg2 ;
22150 void *argp1 = 0 ;
22151 int res1 = 0 ;
22152 bool val2 ;
22153 int ecode2 = 0 ;
22154 PyObject *swig_obj[2] ;
22155
22156 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22158 if (!SWIG_IsOK(res1)) {
22159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22160 }
22161 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22162 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22163 if (!SWIG_IsOK(ecode2)) {
22164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22165 }
22166 arg2 = static_cast< bool >(val2);
22167 if (arg1) (arg1)->m_controlDown = arg2;
22168
22169 resultobj = SWIG_Py_Void();
22170 return resultobj;
22171 fail:
22172 return NULL;
22173 }
22174
22175
22176 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22177 PyObject *resultobj = 0;
22178 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22179 bool result;
22180 void *argp1 = 0 ;
22181 int res1 = 0 ;
22182 PyObject *swig_obj[1] ;
22183
22184 if (!args) SWIG_fail;
22185 swig_obj[0] = args;
22186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22187 if (!SWIG_IsOK(res1)) {
22188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22189 }
22190 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22191 result = (bool) ((arg1)->m_controlDown);
22192 {
22193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22194 }
22195 return resultobj;
22196 fail:
22197 return NULL;
22198 }
22199
22200
22201 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22202 PyObject *resultobj = 0;
22203 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22204 bool arg2 ;
22205 void *argp1 = 0 ;
22206 int res1 = 0 ;
22207 bool val2 ;
22208 int ecode2 = 0 ;
22209 PyObject *swig_obj[2] ;
22210
22211 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22213 if (!SWIG_IsOK(res1)) {
22214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22215 }
22216 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22217 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22218 if (!SWIG_IsOK(ecode2)) {
22219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22220 }
22221 arg2 = static_cast< bool >(val2);
22222 if (arg1) (arg1)->m_shiftDown = arg2;
22223
22224 resultobj = SWIG_Py_Void();
22225 return resultobj;
22226 fail:
22227 return NULL;
22228 }
22229
22230
22231 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22232 PyObject *resultobj = 0;
22233 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22234 bool result;
22235 void *argp1 = 0 ;
22236 int res1 = 0 ;
22237 PyObject *swig_obj[1] ;
22238
22239 if (!args) SWIG_fail;
22240 swig_obj[0] = args;
22241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22242 if (!SWIG_IsOK(res1)) {
22243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22244 }
22245 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22246 result = (bool) ((arg1)->m_shiftDown);
22247 {
22248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22249 }
22250 return resultobj;
22251 fail:
22252 return NULL;
22253 }
22254
22255
22256 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22257 PyObject *resultobj = 0;
22258 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22259 bool arg2 ;
22260 void *argp1 = 0 ;
22261 int res1 = 0 ;
22262 bool val2 ;
22263 int ecode2 = 0 ;
22264 PyObject *swig_obj[2] ;
22265
22266 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22268 if (!SWIG_IsOK(res1)) {
22269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22270 }
22271 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22272 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22273 if (!SWIG_IsOK(ecode2)) {
22274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22275 }
22276 arg2 = static_cast< bool >(val2);
22277 if (arg1) (arg1)->m_altDown = arg2;
22278
22279 resultobj = SWIG_Py_Void();
22280 return resultobj;
22281 fail:
22282 return NULL;
22283 }
22284
22285
22286 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22287 PyObject *resultobj = 0;
22288 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22289 bool result;
22290 void *argp1 = 0 ;
22291 int res1 = 0 ;
22292 PyObject *swig_obj[1] ;
22293
22294 if (!args) SWIG_fail;
22295 swig_obj[0] = args;
22296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22297 if (!SWIG_IsOK(res1)) {
22298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22299 }
22300 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22301 result = (bool) ((arg1)->m_altDown);
22302 {
22303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22304 }
22305 return resultobj;
22306 fail:
22307 return NULL;
22308 }
22309
22310
22311 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22312 PyObject *resultobj = 0;
22313 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22314 bool arg2 ;
22315 void *argp1 = 0 ;
22316 int res1 = 0 ;
22317 bool val2 ;
22318 int ecode2 = 0 ;
22319 PyObject *swig_obj[2] ;
22320
22321 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22323 if (!SWIG_IsOK(res1)) {
22324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22325 }
22326 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22327 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22328 if (!SWIG_IsOK(ecode2)) {
22329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22330 }
22331 arg2 = static_cast< bool >(val2);
22332 if (arg1) (arg1)->m_metaDown = arg2;
22333
22334 resultobj = SWIG_Py_Void();
22335 return resultobj;
22336 fail:
22337 return NULL;
22338 }
22339
22340
22341 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22342 PyObject *resultobj = 0;
22343 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22344 bool result;
22345 void *argp1 = 0 ;
22346 int res1 = 0 ;
22347 PyObject *swig_obj[1] ;
22348
22349 if (!args) SWIG_fail;
22350 swig_obj[0] = args;
22351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22352 if (!SWIG_IsOK(res1)) {
22353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22354 }
22355 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22356 result = (bool) ((arg1)->m_metaDown);
22357 {
22358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22359 }
22360 return resultobj;
22361 fail:
22362 return NULL;
22363 }
22364
22365
22366 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22367 PyObject *resultobj = 0;
22368 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22369 int arg2 ;
22370 void *argp1 = 0 ;
22371 int res1 = 0 ;
22372 int val2 ;
22373 int ecode2 = 0 ;
22374 PyObject *swig_obj[2] ;
22375
22376 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
22377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22378 if (!SWIG_IsOK(res1)) {
22379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22380 }
22381 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22382 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22383 if (!SWIG_IsOK(ecode2)) {
22384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
22385 }
22386 arg2 = static_cast< int >(val2);
22387 if (arg1) (arg1)->m_wheelRotation = arg2;
22388
22389 resultobj = SWIG_Py_Void();
22390 return resultobj;
22391 fail:
22392 return NULL;
22393 }
22394
22395
22396 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22397 PyObject *resultobj = 0;
22398 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22399 int result;
22400 void *argp1 = 0 ;
22401 int res1 = 0 ;
22402 PyObject *swig_obj[1] ;
22403
22404 if (!args) SWIG_fail;
22405 swig_obj[0] = args;
22406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22407 if (!SWIG_IsOK(res1)) {
22408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22409 }
22410 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22411 result = (int) ((arg1)->m_wheelRotation);
22412 resultobj = SWIG_From_int(static_cast< int >(result));
22413 return resultobj;
22414 fail:
22415 return NULL;
22416 }
22417
22418
22419 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22420 PyObject *resultobj = 0;
22421 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22422 int arg2 ;
22423 void *argp1 = 0 ;
22424 int res1 = 0 ;
22425 int val2 ;
22426 int ecode2 = 0 ;
22427 PyObject *swig_obj[2] ;
22428
22429 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
22430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22431 if (!SWIG_IsOK(res1)) {
22432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22433 }
22434 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22435 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22436 if (!SWIG_IsOK(ecode2)) {
22437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
22438 }
22439 arg2 = static_cast< int >(val2);
22440 if (arg1) (arg1)->m_wheelDelta = arg2;
22441
22442 resultobj = SWIG_Py_Void();
22443 return resultobj;
22444 fail:
22445 return NULL;
22446 }
22447
22448
22449 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22450 PyObject *resultobj = 0;
22451 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22452 int result;
22453 void *argp1 = 0 ;
22454 int res1 = 0 ;
22455 PyObject *swig_obj[1] ;
22456
22457 if (!args) SWIG_fail;
22458 swig_obj[0] = args;
22459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22460 if (!SWIG_IsOK(res1)) {
22461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22462 }
22463 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22464 result = (int) ((arg1)->m_wheelDelta);
22465 resultobj = SWIG_From_int(static_cast< int >(result));
22466 return resultobj;
22467 fail:
22468 return NULL;
22469 }
22470
22471
22472 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22473 PyObject *resultobj = 0;
22474 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22475 int arg2 ;
22476 void *argp1 = 0 ;
22477 int res1 = 0 ;
22478 int val2 ;
22479 int ecode2 = 0 ;
22480 PyObject *swig_obj[2] ;
22481
22482 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
22483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22484 if (!SWIG_IsOK(res1)) {
22485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22486 }
22487 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22488 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22489 if (!SWIG_IsOK(ecode2)) {
22490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
22491 }
22492 arg2 = static_cast< int >(val2);
22493 if (arg1) (arg1)->m_linesPerAction = arg2;
22494
22495 resultobj = SWIG_Py_Void();
22496 return resultobj;
22497 fail:
22498 return NULL;
22499 }
22500
22501
22502 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22503 PyObject *resultobj = 0;
22504 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22505 int result;
22506 void *argp1 = 0 ;
22507 int res1 = 0 ;
22508 PyObject *swig_obj[1] ;
22509
22510 if (!args) SWIG_fail;
22511 swig_obj[0] = args;
22512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22513 if (!SWIG_IsOK(res1)) {
22514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22515 }
22516 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22517 result = (int) ((arg1)->m_linesPerAction);
22518 resultobj = SWIG_From_int(static_cast< int >(result));
22519 return resultobj;
22520 fail:
22521 return NULL;
22522 }
22523
22524
22525 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22526 PyObject *obj;
22527 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22528 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
22529 return SWIG_Py_Void();
22530 }
22531
22532 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22533 return SWIG_Python_InitShadowInstance(args);
22534 }
22535
22536 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22537 PyObject *resultobj = 0;
22538 int arg1 = (int) 0 ;
22539 int arg2 = (int) 0 ;
22540 wxSetCursorEvent *result = 0 ;
22541 int val1 ;
22542 int ecode1 = 0 ;
22543 int val2 ;
22544 int ecode2 = 0 ;
22545 PyObject * obj0 = 0 ;
22546 PyObject * obj1 = 0 ;
22547 char * kwnames[] = {
22548 (char *) "x",(char *) "y", NULL
22549 };
22550
22551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22552 if (obj0) {
22553 ecode1 = SWIG_AsVal_int(obj0, &val1);
22554 if (!SWIG_IsOK(ecode1)) {
22555 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
22556 }
22557 arg1 = static_cast< int >(val1);
22558 }
22559 if (obj1) {
22560 ecode2 = SWIG_AsVal_int(obj1, &val2);
22561 if (!SWIG_IsOK(ecode2)) {
22562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
22563 }
22564 arg2 = static_cast< int >(val2);
22565 }
22566 {
22567 PyThreadState* __tstate = wxPyBeginAllowThreads();
22568 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
22569 wxPyEndAllowThreads(__tstate);
22570 if (PyErr_Occurred()) SWIG_fail;
22571 }
22572 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
22573 return resultobj;
22574 fail:
22575 return NULL;
22576 }
22577
22578
22579 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22580 PyObject *resultobj = 0;
22581 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22582 int result;
22583 void *argp1 = 0 ;
22584 int res1 = 0 ;
22585 PyObject *swig_obj[1] ;
22586
22587 if (!args) SWIG_fail;
22588 swig_obj[0] = args;
22589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22590 if (!SWIG_IsOK(res1)) {
22591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22592 }
22593 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22594 {
22595 PyThreadState* __tstate = wxPyBeginAllowThreads();
22596 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
22597 wxPyEndAllowThreads(__tstate);
22598 if (PyErr_Occurred()) SWIG_fail;
22599 }
22600 resultobj = SWIG_From_int(static_cast< int >(result));
22601 return resultobj;
22602 fail:
22603 return NULL;
22604 }
22605
22606
22607 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22608 PyObject *resultobj = 0;
22609 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22610 int result;
22611 void *argp1 = 0 ;
22612 int res1 = 0 ;
22613 PyObject *swig_obj[1] ;
22614
22615 if (!args) SWIG_fail;
22616 swig_obj[0] = args;
22617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22618 if (!SWIG_IsOK(res1)) {
22619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22620 }
22621 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22622 {
22623 PyThreadState* __tstate = wxPyBeginAllowThreads();
22624 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
22625 wxPyEndAllowThreads(__tstate);
22626 if (PyErr_Occurred()) SWIG_fail;
22627 }
22628 resultobj = SWIG_From_int(static_cast< int >(result));
22629 return resultobj;
22630 fail:
22631 return NULL;
22632 }
22633
22634
22635 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22636 PyObject *resultobj = 0;
22637 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22638 wxCursor *arg2 = 0 ;
22639 void *argp1 = 0 ;
22640 int res1 = 0 ;
22641 void *argp2 = 0 ;
22642 int res2 = 0 ;
22643 PyObject * obj0 = 0 ;
22644 PyObject * obj1 = 0 ;
22645 char * kwnames[] = {
22646 (char *) "self",(char *) "cursor", NULL
22647 };
22648
22649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22651 if (!SWIG_IsOK(res1)) {
22652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22653 }
22654 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22655 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22656 if (!SWIG_IsOK(res2)) {
22657 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22658 }
22659 if (!argp2) {
22660 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22661 }
22662 arg2 = reinterpret_cast< wxCursor * >(argp2);
22663 {
22664 PyThreadState* __tstate = wxPyBeginAllowThreads();
22665 (arg1)->SetCursor((wxCursor const &)*arg2);
22666 wxPyEndAllowThreads(__tstate);
22667 if (PyErr_Occurred()) SWIG_fail;
22668 }
22669 resultobj = SWIG_Py_Void();
22670 return resultobj;
22671 fail:
22672 return NULL;
22673 }
22674
22675
22676 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22677 PyObject *resultobj = 0;
22678 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22679 wxCursor *result = 0 ;
22680 void *argp1 = 0 ;
22681 int res1 = 0 ;
22682 PyObject *swig_obj[1] ;
22683
22684 if (!args) SWIG_fail;
22685 swig_obj[0] = args;
22686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22687 if (!SWIG_IsOK(res1)) {
22688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22689 }
22690 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22691 {
22692 PyThreadState* __tstate = wxPyBeginAllowThreads();
22693 {
22694 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22695 result = (wxCursor *) &_result_ref;
22696 }
22697 wxPyEndAllowThreads(__tstate);
22698 if (PyErr_Occurred()) SWIG_fail;
22699 }
22700 {
22701 wxCursor* resultptr = new wxCursor(*result);
22702 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22703 }
22704 return resultobj;
22705 fail:
22706 return NULL;
22707 }
22708
22709
22710 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22711 PyObject *resultobj = 0;
22712 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22713 bool result;
22714 void *argp1 = 0 ;
22715 int res1 = 0 ;
22716 PyObject *swig_obj[1] ;
22717
22718 if (!args) SWIG_fail;
22719 swig_obj[0] = args;
22720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22721 if (!SWIG_IsOK(res1)) {
22722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22723 }
22724 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22725 {
22726 PyThreadState* __tstate = wxPyBeginAllowThreads();
22727 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22728 wxPyEndAllowThreads(__tstate);
22729 if (PyErr_Occurred()) SWIG_fail;
22730 }
22731 {
22732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22733 }
22734 return resultobj;
22735 fail:
22736 return NULL;
22737 }
22738
22739
22740 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22741 PyObject *obj;
22742 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22743 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22744 return SWIG_Py_Void();
22745 }
22746
22747 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22748 return SWIG_Python_InitShadowInstance(args);
22749 }
22750
22751 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22752 PyObject *resultobj = 0;
22753 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22754 wxKeyEvent *result = 0 ;
22755 int val1 ;
22756 int ecode1 = 0 ;
22757 PyObject * obj0 = 0 ;
22758 char * kwnames[] = {
22759 (char *) "eventType", NULL
22760 };
22761
22762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22763 if (obj0) {
22764 ecode1 = SWIG_AsVal_int(obj0, &val1);
22765 if (!SWIG_IsOK(ecode1)) {
22766 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22767 }
22768 arg1 = static_cast< wxEventType >(val1);
22769 }
22770 {
22771 PyThreadState* __tstate = wxPyBeginAllowThreads();
22772 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22773 wxPyEndAllowThreads(__tstate);
22774 if (PyErr_Occurred()) SWIG_fail;
22775 }
22776 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22777 return resultobj;
22778 fail:
22779 return NULL;
22780 }
22781
22782
22783 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22784 PyObject *resultobj = 0;
22785 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22786 int result;
22787 void *argp1 = 0 ;
22788 int res1 = 0 ;
22789 PyObject *swig_obj[1] ;
22790
22791 if (!args) SWIG_fail;
22792 swig_obj[0] = args;
22793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22794 if (!SWIG_IsOK(res1)) {
22795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22796 }
22797 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22798 {
22799 PyThreadState* __tstate = wxPyBeginAllowThreads();
22800 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22801 wxPyEndAllowThreads(__tstate);
22802 if (PyErr_Occurred()) SWIG_fail;
22803 }
22804 resultobj = SWIG_From_int(static_cast< int >(result));
22805 return resultobj;
22806 fail:
22807 return NULL;
22808 }
22809
22810
22811 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22812 PyObject *resultobj = 0;
22813 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22814 bool result;
22815 void *argp1 = 0 ;
22816 int res1 = 0 ;
22817 PyObject *swig_obj[1] ;
22818
22819 if (!args) SWIG_fail;
22820 swig_obj[0] = args;
22821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22822 if (!SWIG_IsOK(res1)) {
22823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22824 }
22825 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22826 {
22827 PyThreadState* __tstate = wxPyBeginAllowThreads();
22828 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22829 wxPyEndAllowThreads(__tstate);
22830 if (PyErr_Occurred()) SWIG_fail;
22831 }
22832 {
22833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22834 }
22835 return resultobj;
22836 fail:
22837 return NULL;
22838 }
22839
22840
22841 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22842 PyObject *resultobj = 0;
22843 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22844 bool result;
22845 void *argp1 = 0 ;
22846 int res1 = 0 ;
22847 PyObject *swig_obj[1] ;
22848
22849 if (!args) SWIG_fail;
22850 swig_obj[0] = args;
22851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22852 if (!SWIG_IsOK(res1)) {
22853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22854 }
22855 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22856 {
22857 PyThreadState* __tstate = wxPyBeginAllowThreads();
22858 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22859 wxPyEndAllowThreads(__tstate);
22860 if (PyErr_Occurred()) SWIG_fail;
22861 }
22862 {
22863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22864 }
22865 return resultobj;
22866 fail:
22867 return NULL;
22868 }
22869
22870
22871 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22872 PyObject *resultobj = 0;
22873 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22874 bool result;
22875 void *argp1 = 0 ;
22876 int res1 = 0 ;
22877 PyObject *swig_obj[1] ;
22878
22879 if (!args) SWIG_fail;
22880 swig_obj[0] = args;
22881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22882 if (!SWIG_IsOK(res1)) {
22883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22884 }
22885 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22886 {
22887 PyThreadState* __tstate = wxPyBeginAllowThreads();
22888 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22889 wxPyEndAllowThreads(__tstate);
22890 if (PyErr_Occurred()) SWIG_fail;
22891 }
22892 {
22893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22894 }
22895 return resultobj;
22896 fail:
22897 return NULL;
22898 }
22899
22900
22901 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22902 PyObject *resultobj = 0;
22903 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22904 bool result;
22905 void *argp1 = 0 ;
22906 int res1 = 0 ;
22907 PyObject *swig_obj[1] ;
22908
22909 if (!args) SWIG_fail;
22910 swig_obj[0] = args;
22911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22912 if (!SWIG_IsOK(res1)) {
22913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22914 }
22915 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22916 {
22917 PyThreadState* __tstate = wxPyBeginAllowThreads();
22918 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22919 wxPyEndAllowThreads(__tstate);
22920 if (PyErr_Occurred()) SWIG_fail;
22921 }
22922 {
22923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22924 }
22925 return resultobj;
22926 fail:
22927 return NULL;
22928 }
22929
22930
22931 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22932 PyObject *resultobj = 0;
22933 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22934 bool result;
22935 void *argp1 = 0 ;
22936 int res1 = 0 ;
22937 PyObject *swig_obj[1] ;
22938
22939 if (!args) SWIG_fail;
22940 swig_obj[0] = args;
22941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22942 if (!SWIG_IsOK(res1)) {
22943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22944 }
22945 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22946 {
22947 PyThreadState* __tstate = wxPyBeginAllowThreads();
22948 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22949 wxPyEndAllowThreads(__tstate);
22950 if (PyErr_Occurred()) SWIG_fail;
22951 }
22952 {
22953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22954 }
22955 return resultobj;
22956 fail:
22957 return NULL;
22958 }
22959
22960
22961 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22962 PyObject *resultobj = 0;
22963 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22964 bool result;
22965 void *argp1 = 0 ;
22966 int res1 = 0 ;
22967 PyObject *swig_obj[1] ;
22968
22969 if (!args) SWIG_fail;
22970 swig_obj[0] = args;
22971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22972 if (!SWIG_IsOK(res1)) {
22973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22974 }
22975 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22976 {
22977 PyThreadState* __tstate = wxPyBeginAllowThreads();
22978 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22979 wxPyEndAllowThreads(__tstate);
22980 if (PyErr_Occurred()) SWIG_fail;
22981 }
22982 {
22983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22984 }
22985 return resultobj;
22986 fail:
22987 return NULL;
22988 }
22989
22990
22991 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22992 PyObject *resultobj = 0;
22993 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22994 int result;
22995 void *argp1 = 0 ;
22996 int res1 = 0 ;
22997 PyObject *swig_obj[1] ;
22998
22999 if (!args) SWIG_fail;
23000 swig_obj[0] = args;
23001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23002 if (!SWIG_IsOK(res1)) {
23003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23004 }
23005 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23006 {
23007 PyThreadState* __tstate = wxPyBeginAllowThreads();
23008 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
23009 wxPyEndAllowThreads(__tstate);
23010 if (PyErr_Occurred()) SWIG_fail;
23011 }
23012 resultobj = SWIG_From_int(static_cast< int >(result));
23013 return resultobj;
23014 fail:
23015 return NULL;
23016 }
23017
23018
23019 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23020 PyObject *resultobj = 0;
23021 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23022 int result;
23023 void *argp1 = 0 ;
23024 int res1 = 0 ;
23025 PyObject *swig_obj[1] ;
23026
23027 if (!args) SWIG_fail;
23028 swig_obj[0] = args;
23029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23030 if (!SWIG_IsOK(res1)) {
23031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23032 }
23033 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23034 {
23035 PyThreadState* __tstate = wxPyBeginAllowThreads();
23036 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
23037 wxPyEndAllowThreads(__tstate);
23038 if (PyErr_Occurred()) SWIG_fail;
23039 }
23040 resultobj = SWIG_From_int(static_cast< int >(result));
23041 return resultobj;
23042 fail:
23043 return NULL;
23044 }
23045
23046
23047 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23048 PyObject *resultobj = 0;
23049 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23050 int arg2 ;
23051 void *argp1 = 0 ;
23052 int res1 = 0 ;
23053 int val2 ;
23054 int ecode2 = 0 ;
23055 PyObject * obj0 = 0 ;
23056 PyObject * obj1 = 0 ;
23057 char * kwnames[] = {
23058 (char *) "self",(char *) "uniChar", NULL
23059 };
23060
23061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
23062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23063 if (!SWIG_IsOK(res1)) {
23064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23065 }
23066 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23067 ecode2 = SWIG_AsVal_int(obj1, &val2);
23068 if (!SWIG_IsOK(ecode2)) {
23069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
23070 }
23071 arg2 = static_cast< int >(val2);
23072 {
23073 PyThreadState* __tstate = wxPyBeginAllowThreads();
23074 wxKeyEvent_SetUnicodeKey(arg1,arg2);
23075 wxPyEndAllowThreads(__tstate);
23076 if (PyErr_Occurred()) SWIG_fail;
23077 }
23078 resultobj = SWIG_Py_Void();
23079 return resultobj;
23080 fail:
23081 return NULL;
23082 }
23083
23084
23085 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23086 PyObject *resultobj = 0;
23087 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23088 unsigned int result;
23089 void *argp1 = 0 ;
23090 int res1 = 0 ;
23091 PyObject *swig_obj[1] ;
23092
23093 if (!args) SWIG_fail;
23094 swig_obj[0] = args;
23095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23096 if (!SWIG_IsOK(res1)) {
23097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23098 }
23099 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23100 {
23101 PyThreadState* __tstate = wxPyBeginAllowThreads();
23102 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
23103 wxPyEndAllowThreads(__tstate);
23104 if (PyErr_Occurred()) SWIG_fail;
23105 }
23106 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23107 return resultobj;
23108 fail:
23109 return NULL;
23110 }
23111
23112
23113 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23114 PyObject *resultobj = 0;
23115 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23116 unsigned int result;
23117 void *argp1 = 0 ;
23118 int res1 = 0 ;
23119 PyObject *swig_obj[1] ;
23120
23121 if (!args) SWIG_fail;
23122 swig_obj[0] = args;
23123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23124 if (!SWIG_IsOK(res1)) {
23125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23126 }
23127 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23128 {
23129 PyThreadState* __tstate = wxPyBeginAllowThreads();
23130 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
23131 wxPyEndAllowThreads(__tstate);
23132 if (PyErr_Occurred()) SWIG_fail;
23133 }
23134 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23135 return resultobj;
23136 fail:
23137 return NULL;
23138 }
23139
23140
23141 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23142 PyObject *resultobj = 0;
23143 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23144 wxPoint result;
23145 void *argp1 = 0 ;
23146 int res1 = 0 ;
23147 PyObject *swig_obj[1] ;
23148
23149 if (!args) SWIG_fail;
23150 swig_obj[0] = args;
23151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23152 if (!SWIG_IsOK(res1)) {
23153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23154 }
23155 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23156 {
23157 PyThreadState* __tstate = wxPyBeginAllowThreads();
23158 result = (arg1)->GetPosition();
23159 wxPyEndAllowThreads(__tstate);
23160 if (PyErr_Occurred()) SWIG_fail;
23161 }
23162 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23163 return resultobj;
23164 fail:
23165 return NULL;
23166 }
23167
23168
23169 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23170 PyObject *resultobj = 0;
23171 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23172 long *arg2 = (long *) 0 ;
23173 long *arg3 = (long *) 0 ;
23174 void *argp1 = 0 ;
23175 int res1 = 0 ;
23176 long temp2 ;
23177 int res2 = SWIG_TMPOBJ ;
23178 long temp3 ;
23179 int res3 = SWIG_TMPOBJ ;
23180 PyObject *swig_obj[1] ;
23181
23182 arg2 = &temp2;
23183 arg3 = &temp3;
23184 if (!args) SWIG_fail;
23185 swig_obj[0] = args;
23186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23187 if (!SWIG_IsOK(res1)) {
23188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23189 }
23190 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23191 {
23192 PyThreadState* __tstate = wxPyBeginAllowThreads();
23193 (arg1)->GetPosition(arg2,arg3);
23194 wxPyEndAllowThreads(__tstate);
23195 if (PyErr_Occurred()) SWIG_fail;
23196 }
23197 resultobj = SWIG_Py_Void();
23198 if (SWIG_IsTmpObj(res2)) {
23199 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23200 } else {
23201 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23202 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23203 }
23204 if (SWIG_IsTmpObj(res3)) {
23205 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23206 } else {
23207 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23208 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23209 }
23210 return resultobj;
23211 fail:
23212 return NULL;
23213 }
23214
23215
23216 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23217 PyObject *resultobj = 0;
23218 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23219 int result;
23220 void *argp1 = 0 ;
23221 int res1 = 0 ;
23222 PyObject *swig_obj[1] ;
23223
23224 if (!args) SWIG_fail;
23225 swig_obj[0] = args;
23226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23227 if (!SWIG_IsOK(res1)) {
23228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23229 }
23230 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23231 {
23232 PyThreadState* __tstate = wxPyBeginAllowThreads();
23233 result = (int)((wxKeyEvent const *)arg1)->GetX();
23234 wxPyEndAllowThreads(__tstate);
23235 if (PyErr_Occurred()) SWIG_fail;
23236 }
23237 resultobj = SWIG_From_int(static_cast< int >(result));
23238 return resultobj;
23239 fail:
23240 return NULL;
23241 }
23242
23243
23244 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23245 PyObject *resultobj = 0;
23246 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23247 int result;
23248 void *argp1 = 0 ;
23249 int res1 = 0 ;
23250 PyObject *swig_obj[1] ;
23251
23252 if (!args) SWIG_fail;
23253 swig_obj[0] = args;
23254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23255 if (!SWIG_IsOK(res1)) {
23256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23257 }
23258 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23259 {
23260 PyThreadState* __tstate = wxPyBeginAllowThreads();
23261 result = (int)((wxKeyEvent const *)arg1)->GetY();
23262 wxPyEndAllowThreads(__tstate);
23263 if (PyErr_Occurred()) SWIG_fail;
23264 }
23265 resultobj = SWIG_From_int(static_cast< int >(result));
23266 return resultobj;
23267 fail:
23268 return NULL;
23269 }
23270
23271
23272 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23273 PyObject *resultobj = 0;
23274 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23275 int arg2 ;
23276 void *argp1 = 0 ;
23277 int res1 = 0 ;
23278 int val2 ;
23279 int ecode2 = 0 ;
23280 PyObject *swig_obj[2] ;
23281
23282 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23284 if (!SWIG_IsOK(res1)) {
23285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23286 }
23287 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23288 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23289 if (!SWIG_IsOK(ecode2)) {
23290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23291 }
23292 arg2 = static_cast< int >(val2);
23293 if (arg1) (arg1)->m_x = arg2;
23294
23295 resultobj = SWIG_Py_Void();
23296 return resultobj;
23297 fail:
23298 return NULL;
23299 }
23300
23301
23302 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23303 PyObject *resultobj = 0;
23304 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23305 int result;
23306 void *argp1 = 0 ;
23307 int res1 = 0 ;
23308 PyObject *swig_obj[1] ;
23309
23310 if (!args) SWIG_fail;
23311 swig_obj[0] = args;
23312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23313 if (!SWIG_IsOK(res1)) {
23314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23315 }
23316 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23317 result = (int) ((arg1)->m_x);
23318 resultobj = SWIG_From_int(static_cast< int >(result));
23319 return resultobj;
23320 fail:
23321 return NULL;
23322 }
23323
23324
23325 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23326 PyObject *resultobj = 0;
23327 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23328 int arg2 ;
23329 void *argp1 = 0 ;
23330 int res1 = 0 ;
23331 int val2 ;
23332 int ecode2 = 0 ;
23333 PyObject *swig_obj[2] ;
23334
23335 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
23336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23337 if (!SWIG_IsOK(res1)) {
23338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23339 }
23340 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23341 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23342 if (!SWIG_IsOK(ecode2)) {
23343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
23344 }
23345 arg2 = static_cast< int >(val2);
23346 if (arg1) (arg1)->m_y = arg2;
23347
23348 resultobj = SWIG_Py_Void();
23349 return resultobj;
23350 fail:
23351 return NULL;
23352 }
23353
23354
23355 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23356 PyObject *resultobj = 0;
23357 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23358 int result;
23359 void *argp1 = 0 ;
23360 int res1 = 0 ;
23361 PyObject *swig_obj[1] ;
23362
23363 if (!args) SWIG_fail;
23364 swig_obj[0] = args;
23365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23366 if (!SWIG_IsOK(res1)) {
23367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23368 }
23369 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23370 result = (int) ((arg1)->m_y);
23371 resultobj = SWIG_From_int(static_cast< int >(result));
23372 return resultobj;
23373 fail:
23374 return NULL;
23375 }
23376
23377
23378 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23379 PyObject *resultobj = 0;
23380 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23381 long arg2 ;
23382 void *argp1 = 0 ;
23383 int res1 = 0 ;
23384 long val2 ;
23385 int ecode2 = 0 ;
23386 PyObject *swig_obj[2] ;
23387
23388 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
23389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23390 if (!SWIG_IsOK(res1)) {
23391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23392 }
23393 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23394 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
23395 if (!SWIG_IsOK(ecode2)) {
23396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
23397 }
23398 arg2 = static_cast< long >(val2);
23399 if (arg1) (arg1)->m_keyCode = arg2;
23400
23401 resultobj = SWIG_Py_Void();
23402 return resultobj;
23403 fail:
23404 return NULL;
23405 }
23406
23407
23408 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23409 PyObject *resultobj = 0;
23410 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23411 long result;
23412 void *argp1 = 0 ;
23413 int res1 = 0 ;
23414 PyObject *swig_obj[1] ;
23415
23416 if (!args) SWIG_fail;
23417 swig_obj[0] = args;
23418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23419 if (!SWIG_IsOK(res1)) {
23420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23421 }
23422 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23423 result = (long) ((arg1)->m_keyCode);
23424 resultobj = SWIG_From_long(static_cast< long >(result));
23425 return resultobj;
23426 fail:
23427 return NULL;
23428 }
23429
23430
23431 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23432 PyObject *resultobj = 0;
23433 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23434 bool arg2 ;
23435 void *argp1 = 0 ;
23436 int res1 = 0 ;
23437 bool val2 ;
23438 int ecode2 = 0 ;
23439 PyObject *swig_obj[2] ;
23440
23441 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
23442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23443 if (!SWIG_IsOK(res1)) {
23444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23445 }
23446 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23447 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23448 if (!SWIG_IsOK(ecode2)) {
23449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
23450 }
23451 arg2 = static_cast< bool >(val2);
23452 if (arg1) (arg1)->m_controlDown = arg2;
23453
23454 resultobj = SWIG_Py_Void();
23455 return resultobj;
23456 fail:
23457 return NULL;
23458 }
23459
23460
23461 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23462 PyObject *resultobj = 0;
23463 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23464 bool result;
23465 void *argp1 = 0 ;
23466 int res1 = 0 ;
23467 PyObject *swig_obj[1] ;
23468
23469 if (!args) SWIG_fail;
23470 swig_obj[0] = args;
23471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23472 if (!SWIG_IsOK(res1)) {
23473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23474 }
23475 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23476 result = (bool) ((arg1)->m_controlDown);
23477 {
23478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23479 }
23480 return resultobj;
23481 fail:
23482 return NULL;
23483 }
23484
23485
23486 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23487 PyObject *resultobj = 0;
23488 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23489 bool arg2 ;
23490 void *argp1 = 0 ;
23491 int res1 = 0 ;
23492 bool val2 ;
23493 int ecode2 = 0 ;
23494 PyObject *swig_obj[2] ;
23495
23496 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
23497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23498 if (!SWIG_IsOK(res1)) {
23499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23500 }
23501 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23502 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23503 if (!SWIG_IsOK(ecode2)) {
23504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
23505 }
23506 arg2 = static_cast< bool >(val2);
23507 if (arg1) (arg1)->m_shiftDown = arg2;
23508
23509 resultobj = SWIG_Py_Void();
23510 return resultobj;
23511 fail:
23512 return NULL;
23513 }
23514
23515
23516 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23517 PyObject *resultobj = 0;
23518 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23519 bool result;
23520 void *argp1 = 0 ;
23521 int res1 = 0 ;
23522 PyObject *swig_obj[1] ;
23523
23524 if (!args) SWIG_fail;
23525 swig_obj[0] = args;
23526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23527 if (!SWIG_IsOK(res1)) {
23528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23529 }
23530 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23531 result = (bool) ((arg1)->m_shiftDown);
23532 {
23533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23534 }
23535 return resultobj;
23536 fail:
23537 return NULL;
23538 }
23539
23540
23541 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23542 PyObject *resultobj = 0;
23543 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23544 bool arg2 ;
23545 void *argp1 = 0 ;
23546 int res1 = 0 ;
23547 bool val2 ;
23548 int ecode2 = 0 ;
23549 PyObject *swig_obj[2] ;
23550
23551 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
23552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23553 if (!SWIG_IsOK(res1)) {
23554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23555 }
23556 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23557 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23558 if (!SWIG_IsOK(ecode2)) {
23559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
23560 }
23561 arg2 = static_cast< bool >(val2);
23562 if (arg1) (arg1)->m_altDown = arg2;
23563
23564 resultobj = SWIG_Py_Void();
23565 return resultobj;
23566 fail:
23567 return NULL;
23568 }
23569
23570
23571 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23572 PyObject *resultobj = 0;
23573 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23574 bool result;
23575 void *argp1 = 0 ;
23576 int res1 = 0 ;
23577 PyObject *swig_obj[1] ;
23578
23579 if (!args) SWIG_fail;
23580 swig_obj[0] = args;
23581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23582 if (!SWIG_IsOK(res1)) {
23583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23584 }
23585 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23586 result = (bool) ((arg1)->m_altDown);
23587 {
23588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23589 }
23590 return resultobj;
23591 fail:
23592 return NULL;
23593 }
23594
23595
23596 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23597 PyObject *resultobj = 0;
23598 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23599 bool arg2 ;
23600 void *argp1 = 0 ;
23601 int res1 = 0 ;
23602 bool val2 ;
23603 int ecode2 = 0 ;
23604 PyObject *swig_obj[2] ;
23605
23606 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
23607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23608 if (!SWIG_IsOK(res1)) {
23609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23610 }
23611 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23612 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23613 if (!SWIG_IsOK(ecode2)) {
23614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
23615 }
23616 arg2 = static_cast< bool >(val2);
23617 if (arg1) (arg1)->m_metaDown = arg2;
23618
23619 resultobj = SWIG_Py_Void();
23620 return resultobj;
23621 fail:
23622 return NULL;
23623 }
23624
23625
23626 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23627 PyObject *resultobj = 0;
23628 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23629 bool result;
23630 void *argp1 = 0 ;
23631 int res1 = 0 ;
23632 PyObject *swig_obj[1] ;
23633
23634 if (!args) SWIG_fail;
23635 swig_obj[0] = args;
23636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23637 if (!SWIG_IsOK(res1)) {
23638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23639 }
23640 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23641 result = (bool) ((arg1)->m_metaDown);
23642 {
23643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23644 }
23645 return resultobj;
23646 fail:
23647 return NULL;
23648 }
23649
23650
23651 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23652 PyObject *resultobj = 0;
23653 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23654 bool arg2 ;
23655 void *argp1 = 0 ;
23656 int res1 = 0 ;
23657 bool val2 ;
23658 int ecode2 = 0 ;
23659 PyObject *swig_obj[2] ;
23660
23661 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23663 if (!SWIG_IsOK(res1)) {
23664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23665 }
23666 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23667 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23668 if (!SWIG_IsOK(ecode2)) {
23669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23670 }
23671 arg2 = static_cast< bool >(val2);
23672 if (arg1) (arg1)->m_scanCode = arg2;
23673
23674 resultobj = SWIG_Py_Void();
23675 return resultobj;
23676 fail:
23677 return NULL;
23678 }
23679
23680
23681 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23682 PyObject *resultobj = 0;
23683 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23684 bool result;
23685 void *argp1 = 0 ;
23686 int res1 = 0 ;
23687 PyObject *swig_obj[1] ;
23688
23689 if (!args) SWIG_fail;
23690 swig_obj[0] = args;
23691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23692 if (!SWIG_IsOK(res1)) {
23693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23694 }
23695 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23696 result = (bool) ((arg1)->m_scanCode);
23697 {
23698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23699 }
23700 return resultobj;
23701 fail:
23702 return NULL;
23703 }
23704
23705
23706 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23707 PyObject *resultobj = 0;
23708 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23709 unsigned int arg2 ;
23710 void *argp1 = 0 ;
23711 int res1 = 0 ;
23712 unsigned int val2 ;
23713 int ecode2 = 0 ;
23714 PyObject *swig_obj[2] ;
23715
23716 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23718 if (!SWIG_IsOK(res1)) {
23719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23720 }
23721 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23722 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23723 if (!SWIG_IsOK(ecode2)) {
23724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23725 }
23726 arg2 = static_cast< unsigned int >(val2);
23727 if (arg1) (arg1)->m_rawCode = arg2;
23728
23729 resultobj = SWIG_Py_Void();
23730 return resultobj;
23731 fail:
23732 return NULL;
23733 }
23734
23735
23736 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23737 PyObject *resultobj = 0;
23738 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23739 unsigned int result;
23740 void *argp1 = 0 ;
23741 int res1 = 0 ;
23742 PyObject *swig_obj[1] ;
23743
23744 if (!args) SWIG_fail;
23745 swig_obj[0] = args;
23746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23747 if (!SWIG_IsOK(res1)) {
23748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23749 }
23750 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23751 result = (unsigned int) ((arg1)->m_rawCode);
23752 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23753 return resultobj;
23754 fail:
23755 return NULL;
23756 }
23757
23758
23759 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23760 PyObject *resultobj = 0;
23761 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23762 unsigned int arg2 ;
23763 void *argp1 = 0 ;
23764 int res1 = 0 ;
23765 unsigned int val2 ;
23766 int ecode2 = 0 ;
23767 PyObject *swig_obj[2] ;
23768
23769 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23771 if (!SWIG_IsOK(res1)) {
23772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23773 }
23774 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23775 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23776 if (!SWIG_IsOK(ecode2)) {
23777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23778 }
23779 arg2 = static_cast< unsigned int >(val2);
23780 if (arg1) (arg1)->m_rawFlags = arg2;
23781
23782 resultobj = SWIG_Py_Void();
23783 return resultobj;
23784 fail:
23785 return NULL;
23786 }
23787
23788
23789 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23790 PyObject *resultobj = 0;
23791 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23792 unsigned int result;
23793 void *argp1 = 0 ;
23794 int res1 = 0 ;
23795 PyObject *swig_obj[1] ;
23796
23797 if (!args) SWIG_fail;
23798 swig_obj[0] = args;
23799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23800 if (!SWIG_IsOK(res1)) {
23801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23802 }
23803 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23804 result = (unsigned int) ((arg1)->m_rawFlags);
23805 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23806 return resultobj;
23807 fail:
23808 return NULL;
23809 }
23810
23811
23812 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23813 PyObject *obj;
23814 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23815 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23816 return SWIG_Py_Void();
23817 }
23818
23819 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23820 return SWIG_Python_InitShadowInstance(args);
23821 }
23822
23823 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23824 PyObject *resultobj = 0;
23825 wxSize const &arg1_defvalue = wxDefaultSize ;
23826 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23827 int arg2 = (int) 0 ;
23828 wxSizeEvent *result = 0 ;
23829 wxSize temp1 ;
23830 int val2 ;
23831 int ecode2 = 0 ;
23832 PyObject * obj0 = 0 ;
23833 PyObject * obj1 = 0 ;
23834 char * kwnames[] = {
23835 (char *) "sz",(char *) "winid", NULL
23836 };
23837
23838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23839 if (obj0) {
23840 {
23841 arg1 = &temp1;
23842 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23843 }
23844 }
23845 if (obj1) {
23846 ecode2 = SWIG_AsVal_int(obj1, &val2);
23847 if (!SWIG_IsOK(ecode2)) {
23848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23849 }
23850 arg2 = static_cast< int >(val2);
23851 }
23852 {
23853 PyThreadState* __tstate = wxPyBeginAllowThreads();
23854 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23855 wxPyEndAllowThreads(__tstate);
23856 if (PyErr_Occurred()) SWIG_fail;
23857 }
23858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23859 return resultobj;
23860 fail:
23861 return NULL;
23862 }
23863
23864
23865 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23866 PyObject *resultobj = 0;
23867 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23868 wxSize result;
23869 void *argp1 = 0 ;
23870 int res1 = 0 ;
23871 PyObject *swig_obj[1] ;
23872
23873 if (!args) SWIG_fail;
23874 swig_obj[0] = args;
23875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23876 if (!SWIG_IsOK(res1)) {
23877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23878 }
23879 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23880 {
23881 PyThreadState* __tstate = wxPyBeginAllowThreads();
23882 result = ((wxSizeEvent const *)arg1)->GetSize();
23883 wxPyEndAllowThreads(__tstate);
23884 if (PyErr_Occurred()) SWIG_fail;
23885 }
23886 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23887 return resultobj;
23888 fail:
23889 return NULL;
23890 }
23891
23892
23893 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23894 PyObject *resultobj = 0;
23895 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23896 wxRect result;
23897 void *argp1 = 0 ;
23898 int res1 = 0 ;
23899 PyObject *swig_obj[1] ;
23900
23901 if (!args) SWIG_fail;
23902 swig_obj[0] = args;
23903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23904 if (!SWIG_IsOK(res1)) {
23905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23906 }
23907 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23908 {
23909 PyThreadState* __tstate = wxPyBeginAllowThreads();
23910 result = ((wxSizeEvent const *)arg1)->GetRect();
23911 wxPyEndAllowThreads(__tstate);
23912 if (PyErr_Occurred()) SWIG_fail;
23913 }
23914 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23915 return resultobj;
23916 fail:
23917 return NULL;
23918 }
23919
23920
23921 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23922 PyObject *resultobj = 0;
23923 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23924 wxRect arg2 ;
23925 void *argp1 = 0 ;
23926 int res1 = 0 ;
23927 void *argp2 ;
23928 int res2 = 0 ;
23929 PyObject * obj0 = 0 ;
23930 PyObject * obj1 = 0 ;
23931 char * kwnames[] = {
23932 (char *) "self",(char *) "rect", NULL
23933 };
23934
23935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23937 if (!SWIG_IsOK(res1)) {
23938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23939 }
23940 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23941 {
23942 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23943 if (!SWIG_IsOK(res2)) {
23944 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23945 }
23946 if (!argp2) {
23947 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23948 } else {
23949 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23950 arg2 = *temp;
23951 if (SWIG_IsNewObj(res2)) delete temp;
23952 }
23953 }
23954 {
23955 PyThreadState* __tstate = wxPyBeginAllowThreads();
23956 (arg1)->SetRect(arg2);
23957 wxPyEndAllowThreads(__tstate);
23958 if (PyErr_Occurred()) SWIG_fail;
23959 }
23960 resultobj = SWIG_Py_Void();
23961 return resultobj;
23962 fail:
23963 return NULL;
23964 }
23965
23966
23967 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23968 PyObject *resultobj = 0;
23969 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23970 wxSize arg2 ;
23971 void *argp1 = 0 ;
23972 int res1 = 0 ;
23973 void *argp2 ;
23974 int res2 = 0 ;
23975 PyObject * obj0 = 0 ;
23976 PyObject * obj1 = 0 ;
23977 char * kwnames[] = {
23978 (char *) "self",(char *) "size", NULL
23979 };
23980
23981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23983 if (!SWIG_IsOK(res1)) {
23984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23985 }
23986 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23987 {
23988 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23989 if (!SWIG_IsOK(res2)) {
23990 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23991 }
23992 if (!argp2) {
23993 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23994 } else {
23995 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23996 arg2 = *temp;
23997 if (SWIG_IsNewObj(res2)) delete temp;
23998 }
23999 }
24000 {
24001 PyThreadState* __tstate = wxPyBeginAllowThreads();
24002 wxSizeEvent_SetSize(arg1,arg2);
24003 wxPyEndAllowThreads(__tstate);
24004 if (PyErr_Occurred()) SWIG_fail;
24005 }
24006 resultobj = SWIG_Py_Void();
24007 return resultobj;
24008 fail:
24009 return NULL;
24010 }
24011
24012
24013 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24014 PyObject *resultobj = 0;
24015 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24016 wxSize *arg2 = (wxSize *) 0 ;
24017 void *argp1 = 0 ;
24018 int res1 = 0 ;
24019 void *argp2 = 0 ;
24020 int res2 = 0 ;
24021 PyObject *swig_obj[2] ;
24022
24023 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
24024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24025 if (!SWIG_IsOK(res1)) {
24026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24027 }
24028 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24029 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
24030 if (!SWIG_IsOK(res2)) {
24031 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
24032 }
24033 arg2 = reinterpret_cast< wxSize * >(argp2);
24034 if (arg1) (arg1)->m_size = *arg2;
24035
24036 resultobj = SWIG_Py_Void();
24037 return resultobj;
24038 fail:
24039 return NULL;
24040 }
24041
24042
24043 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24044 PyObject *resultobj = 0;
24045 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24046 wxSize *result = 0 ;
24047 void *argp1 = 0 ;
24048 int res1 = 0 ;
24049 PyObject *swig_obj[1] ;
24050
24051 if (!args) SWIG_fail;
24052 swig_obj[0] = args;
24053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24054 if (!SWIG_IsOK(res1)) {
24055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24056 }
24057 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24058 result = (wxSize *)& ((arg1)->m_size);
24059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
24060 return resultobj;
24061 fail:
24062 return NULL;
24063 }
24064
24065
24066 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24067 PyObject *resultobj = 0;
24068 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24069 wxRect *arg2 = (wxRect *) 0 ;
24070 void *argp1 = 0 ;
24071 int res1 = 0 ;
24072 void *argp2 = 0 ;
24073 int res2 = 0 ;
24074 PyObject *swig_obj[2] ;
24075
24076 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
24077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24078 if (!SWIG_IsOK(res1)) {
24079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24080 }
24081 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24082 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
24083 if (!SWIG_IsOK(res2)) {
24084 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
24085 }
24086 arg2 = reinterpret_cast< wxRect * >(argp2);
24087 if (arg1) (arg1)->m_rect = *arg2;
24088
24089 resultobj = SWIG_Py_Void();
24090 return resultobj;
24091 fail:
24092 return NULL;
24093 }
24094
24095
24096 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24097 PyObject *resultobj = 0;
24098 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24099 wxRect *result = 0 ;
24100 void *argp1 = 0 ;
24101 int res1 = 0 ;
24102 PyObject *swig_obj[1] ;
24103
24104 if (!args) SWIG_fail;
24105 swig_obj[0] = args;
24106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24107 if (!SWIG_IsOK(res1)) {
24108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24109 }
24110 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24111 result = (wxRect *)& ((arg1)->m_rect);
24112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
24113 return resultobj;
24114 fail:
24115 return NULL;
24116 }
24117
24118
24119 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24120 PyObject *obj;
24121 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24122 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
24123 return SWIG_Py_Void();
24124 }
24125
24126 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24127 return SWIG_Python_InitShadowInstance(args);
24128 }
24129
24130 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24131 PyObject *resultobj = 0;
24132 wxPoint const &arg1_defvalue = wxDefaultPosition ;
24133 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
24134 int arg2 = (int) 0 ;
24135 wxMoveEvent *result = 0 ;
24136 wxPoint temp1 ;
24137 int val2 ;
24138 int ecode2 = 0 ;
24139 PyObject * obj0 = 0 ;
24140 PyObject * obj1 = 0 ;
24141 char * kwnames[] = {
24142 (char *) "pos",(char *) "winid", NULL
24143 };
24144
24145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24146 if (obj0) {
24147 {
24148 arg1 = &temp1;
24149 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
24150 }
24151 }
24152 if (obj1) {
24153 ecode2 = SWIG_AsVal_int(obj1, &val2);
24154 if (!SWIG_IsOK(ecode2)) {
24155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
24156 }
24157 arg2 = static_cast< int >(val2);
24158 }
24159 {
24160 PyThreadState* __tstate = wxPyBeginAllowThreads();
24161 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
24162 wxPyEndAllowThreads(__tstate);
24163 if (PyErr_Occurred()) SWIG_fail;
24164 }
24165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
24166 return resultobj;
24167 fail:
24168 return NULL;
24169 }
24170
24171
24172 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24173 PyObject *resultobj = 0;
24174 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24175 wxPoint result;
24176 void *argp1 = 0 ;
24177 int res1 = 0 ;
24178 PyObject *swig_obj[1] ;
24179
24180 if (!args) SWIG_fail;
24181 swig_obj[0] = args;
24182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24183 if (!SWIG_IsOK(res1)) {
24184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
24185 }
24186 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24187 {
24188 PyThreadState* __tstate = wxPyBeginAllowThreads();
24189 result = ((wxMoveEvent const *)arg1)->GetPosition();
24190 wxPyEndAllowThreads(__tstate);
24191 if (PyErr_Occurred()) SWIG_fail;
24192 }
24193 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24194 return resultobj;
24195 fail:
24196 return NULL;
24197 }
24198
24199
24200 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24201 PyObject *resultobj = 0;
24202 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24203 wxRect result;
24204 void *argp1 = 0 ;
24205 int res1 = 0 ;
24206 PyObject *swig_obj[1] ;
24207
24208 if (!args) SWIG_fail;
24209 swig_obj[0] = args;
24210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24211 if (!SWIG_IsOK(res1)) {
24212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
24213 }
24214 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24215 {
24216 PyThreadState* __tstate = wxPyBeginAllowThreads();
24217 result = ((wxMoveEvent const *)arg1)->GetRect();
24218 wxPyEndAllowThreads(__tstate);
24219 if (PyErr_Occurred()) SWIG_fail;
24220 }
24221 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
24222 return resultobj;
24223 fail:
24224 return NULL;
24225 }
24226
24227
24228 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24229 PyObject *resultobj = 0;
24230 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24231 wxRect *arg2 = 0 ;
24232 void *argp1 = 0 ;
24233 int res1 = 0 ;
24234 wxRect temp2 ;
24235 PyObject * obj0 = 0 ;
24236 PyObject * obj1 = 0 ;
24237 char * kwnames[] = {
24238 (char *) "self",(char *) "rect", NULL
24239 };
24240
24241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
24242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24243 if (!SWIG_IsOK(res1)) {
24244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
24245 }
24246 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24247 {
24248 arg2 = &temp2;
24249 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
24250 }
24251 {
24252 PyThreadState* __tstate = wxPyBeginAllowThreads();
24253 (arg1)->SetRect((wxRect const &)*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_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24265 PyObject *resultobj = 0;
24266 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24267 wxPoint *arg2 = 0 ;
24268 void *argp1 = 0 ;
24269 int res1 = 0 ;
24270 wxPoint temp2 ;
24271 PyObject * obj0 = 0 ;
24272 PyObject * obj1 = 0 ;
24273 char * kwnames[] = {
24274 (char *) "self",(char *) "pos", NULL
24275 };
24276
24277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
24278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24279 if (!SWIG_IsOK(res1)) {
24280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
24281 }
24282 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24283 {
24284 arg2 = &temp2;
24285 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
24286 }
24287 {
24288 PyThreadState* __tstate = wxPyBeginAllowThreads();
24289 (arg1)->SetPosition((wxPoint const &)*arg2);
24290 wxPyEndAllowThreads(__tstate);
24291 if (PyErr_Occurred()) SWIG_fail;
24292 }
24293 resultobj = SWIG_Py_Void();
24294 return resultobj;
24295 fail:
24296 return NULL;
24297 }
24298
24299
24300 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24301 PyObject *obj;
24302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24303 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
24304 return SWIG_Py_Void();
24305 }
24306
24307 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24308 return SWIG_Python_InitShadowInstance(args);
24309 }
24310
24311 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24312 PyObject *resultobj = 0;
24313 int arg1 = (int) 0 ;
24314 wxPaintEvent *result = 0 ;
24315 int val1 ;
24316 int ecode1 = 0 ;
24317 PyObject * obj0 = 0 ;
24318 char * kwnames[] = {
24319 (char *) "Id", NULL
24320 };
24321
24322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
24323 if (obj0) {
24324 ecode1 = SWIG_AsVal_int(obj0, &val1);
24325 if (!SWIG_IsOK(ecode1)) {
24326 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
24327 }
24328 arg1 = static_cast< int >(val1);
24329 }
24330 {
24331 PyThreadState* __tstate = wxPyBeginAllowThreads();
24332 result = (wxPaintEvent *)new wxPaintEvent(arg1);
24333 wxPyEndAllowThreads(__tstate);
24334 if (PyErr_Occurred()) SWIG_fail;
24335 }
24336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
24337 return resultobj;
24338 fail:
24339 return NULL;
24340 }
24341
24342
24343 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24344 PyObject *obj;
24345 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24346 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
24347 return SWIG_Py_Void();
24348 }
24349
24350 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24351 return SWIG_Python_InitShadowInstance(args);
24352 }
24353
24354 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24355 PyObject *resultobj = 0;
24356 int arg1 = (int) 0 ;
24357 wxNcPaintEvent *result = 0 ;
24358 int val1 ;
24359 int ecode1 = 0 ;
24360 PyObject * obj0 = 0 ;
24361 char * kwnames[] = {
24362 (char *) "winid", NULL
24363 };
24364
24365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
24366 if (obj0) {
24367 ecode1 = SWIG_AsVal_int(obj0, &val1);
24368 if (!SWIG_IsOK(ecode1)) {
24369 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
24370 }
24371 arg1 = static_cast< int >(val1);
24372 }
24373 {
24374 PyThreadState* __tstate = wxPyBeginAllowThreads();
24375 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
24376 wxPyEndAllowThreads(__tstate);
24377 if (PyErr_Occurred()) SWIG_fail;
24378 }
24379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
24380 return resultobj;
24381 fail:
24382 return NULL;
24383 }
24384
24385
24386 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24387 PyObject *obj;
24388 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24389 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
24390 return SWIG_Py_Void();
24391 }
24392
24393 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24394 return SWIG_Python_InitShadowInstance(args);
24395 }
24396
24397 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24398 PyObject *resultobj = 0;
24399 int arg1 = (int) 0 ;
24400 wxDC *arg2 = (wxDC *) NULL ;
24401 wxEraseEvent *result = 0 ;
24402 int val1 ;
24403 int ecode1 = 0 ;
24404 void *argp2 = 0 ;
24405 int res2 = 0 ;
24406 PyObject * obj0 = 0 ;
24407 PyObject * obj1 = 0 ;
24408 char * kwnames[] = {
24409 (char *) "Id",(char *) "dc", NULL
24410 };
24411
24412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24413 if (obj0) {
24414 ecode1 = SWIG_AsVal_int(obj0, &val1);
24415 if (!SWIG_IsOK(ecode1)) {
24416 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
24417 }
24418 arg1 = static_cast< int >(val1);
24419 }
24420 if (obj1) {
24421 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
24422 if (!SWIG_IsOK(res2)) {
24423 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
24424 }
24425 arg2 = reinterpret_cast< wxDC * >(argp2);
24426 }
24427 {
24428 PyThreadState* __tstate = wxPyBeginAllowThreads();
24429 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
24430 wxPyEndAllowThreads(__tstate);
24431 if (PyErr_Occurred()) SWIG_fail;
24432 }
24433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
24434 return resultobj;
24435 fail:
24436 return NULL;
24437 }
24438
24439
24440 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24441 PyObject *resultobj = 0;
24442 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
24443 wxDC *result = 0 ;
24444 void *argp1 = 0 ;
24445 int res1 = 0 ;
24446 PyObject *swig_obj[1] ;
24447
24448 if (!args) SWIG_fail;
24449 swig_obj[0] = args;
24450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
24451 if (!SWIG_IsOK(res1)) {
24452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
24453 }
24454 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
24455 {
24456 PyThreadState* __tstate = wxPyBeginAllowThreads();
24457 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
24458 wxPyEndAllowThreads(__tstate);
24459 if (PyErr_Occurred()) SWIG_fail;
24460 }
24461 {
24462 resultobj = wxPyMake_wxObject(result, (bool)0);
24463 }
24464 return resultobj;
24465 fail:
24466 return NULL;
24467 }
24468
24469
24470 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24471 PyObject *obj;
24472 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24473 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
24474 return SWIG_Py_Void();
24475 }
24476
24477 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24478 return SWIG_Python_InitShadowInstance(args);
24479 }
24480
24481 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24482 PyObject *resultobj = 0;
24483 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24484 int arg2 = (int) 0 ;
24485 wxFocusEvent *result = 0 ;
24486 int val1 ;
24487 int ecode1 = 0 ;
24488 int val2 ;
24489 int ecode2 = 0 ;
24490 PyObject * obj0 = 0 ;
24491 PyObject * obj1 = 0 ;
24492 char * kwnames[] = {
24493 (char *) "type",(char *) "winid", NULL
24494 };
24495
24496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24497 if (obj0) {
24498 ecode1 = SWIG_AsVal_int(obj0, &val1);
24499 if (!SWIG_IsOK(ecode1)) {
24500 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24501 }
24502 arg1 = static_cast< wxEventType >(val1);
24503 }
24504 if (obj1) {
24505 ecode2 = SWIG_AsVal_int(obj1, &val2);
24506 if (!SWIG_IsOK(ecode2)) {
24507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
24508 }
24509 arg2 = static_cast< int >(val2);
24510 }
24511 {
24512 PyThreadState* __tstate = wxPyBeginAllowThreads();
24513 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
24514 wxPyEndAllowThreads(__tstate);
24515 if (PyErr_Occurred()) SWIG_fail;
24516 }
24517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
24518 return resultobj;
24519 fail:
24520 return NULL;
24521 }
24522
24523
24524 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24525 PyObject *resultobj = 0;
24526 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24527 wxWindow *result = 0 ;
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_wxFocusEvent, 0 | 0 );
24535 if (!SWIG_IsOK(res1)) {
24536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
24537 }
24538 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24539 {
24540 PyThreadState* __tstate = wxPyBeginAllowThreads();
24541 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
24542 wxPyEndAllowThreads(__tstate);
24543 if (PyErr_Occurred()) SWIG_fail;
24544 }
24545 {
24546 resultobj = wxPyMake_wxObject(result, (bool)0);
24547 }
24548 return resultobj;
24549 fail:
24550 return NULL;
24551 }
24552
24553
24554 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24555 PyObject *resultobj = 0;
24556 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24557 wxWindow *arg2 = (wxWindow *) 0 ;
24558 void *argp1 = 0 ;
24559 int res1 = 0 ;
24560 void *argp2 = 0 ;
24561 int res2 = 0 ;
24562 PyObject * obj0 = 0 ;
24563 PyObject * obj1 = 0 ;
24564 char * kwnames[] = {
24565 (char *) "self",(char *) "win", NULL
24566 };
24567
24568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
24569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24570 if (!SWIG_IsOK(res1)) {
24571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
24572 }
24573 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24574 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24575 if (!SWIG_IsOK(res2)) {
24576 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
24577 }
24578 arg2 = reinterpret_cast< wxWindow * >(argp2);
24579 {
24580 PyThreadState* __tstate = wxPyBeginAllowThreads();
24581 (arg1)->SetWindow(arg2);
24582 wxPyEndAllowThreads(__tstate);
24583 if (PyErr_Occurred()) SWIG_fail;
24584 }
24585 resultobj = SWIG_Py_Void();
24586 return resultobj;
24587 fail:
24588 return NULL;
24589 }
24590
24591
24592 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24593 PyObject *obj;
24594 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24595 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
24596 return SWIG_Py_Void();
24597 }
24598
24599 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24600 return SWIG_Python_InitShadowInstance(args);
24601 }
24602
24603 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24604 PyObject *resultobj = 0;
24605 wxWindow *arg1 = (wxWindow *) NULL ;
24606 wxChildFocusEvent *result = 0 ;
24607 void *argp1 = 0 ;
24608 int res1 = 0 ;
24609 PyObject * obj0 = 0 ;
24610 char * kwnames[] = {
24611 (char *) "win", NULL
24612 };
24613
24614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
24615 if (obj0) {
24616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24617 if (!SWIG_IsOK(res1)) {
24618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
24619 }
24620 arg1 = reinterpret_cast< wxWindow * >(argp1);
24621 }
24622 {
24623 PyThreadState* __tstate = wxPyBeginAllowThreads();
24624 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
24625 wxPyEndAllowThreads(__tstate);
24626 if (PyErr_Occurred()) SWIG_fail;
24627 }
24628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
24629 return resultobj;
24630 fail:
24631 return NULL;
24632 }
24633
24634
24635 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24636 PyObject *resultobj = 0;
24637 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
24638 wxWindow *result = 0 ;
24639 void *argp1 = 0 ;
24640 int res1 = 0 ;
24641 PyObject *swig_obj[1] ;
24642
24643 if (!args) SWIG_fail;
24644 swig_obj[0] = args;
24645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24646 if (!SWIG_IsOK(res1)) {
24647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24648 }
24649 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24650 {
24651 PyThreadState* __tstate = wxPyBeginAllowThreads();
24652 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24653 wxPyEndAllowThreads(__tstate);
24654 if (PyErr_Occurred()) SWIG_fail;
24655 }
24656 {
24657 resultobj = wxPyMake_wxObject(result, (bool)0);
24658 }
24659 return resultobj;
24660 fail:
24661 return NULL;
24662 }
24663
24664
24665 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24666 PyObject *obj;
24667 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24668 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24669 return SWIG_Py_Void();
24670 }
24671
24672 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24673 return SWIG_Python_InitShadowInstance(args);
24674 }
24675
24676 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24677 PyObject *resultobj = 0;
24678 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24679 bool arg2 = (bool) true ;
24680 int arg3 = (int) 0 ;
24681 wxActivateEvent *result = 0 ;
24682 int val1 ;
24683 int ecode1 = 0 ;
24684 bool val2 ;
24685 int ecode2 = 0 ;
24686 int val3 ;
24687 int ecode3 = 0 ;
24688 PyObject * obj0 = 0 ;
24689 PyObject * obj1 = 0 ;
24690 PyObject * obj2 = 0 ;
24691 char * kwnames[] = {
24692 (char *) "type",(char *) "active",(char *) "Id", NULL
24693 };
24694
24695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24696 if (obj0) {
24697 ecode1 = SWIG_AsVal_int(obj0, &val1);
24698 if (!SWIG_IsOK(ecode1)) {
24699 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24700 }
24701 arg1 = static_cast< wxEventType >(val1);
24702 }
24703 if (obj1) {
24704 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24705 if (!SWIG_IsOK(ecode2)) {
24706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24707 }
24708 arg2 = static_cast< bool >(val2);
24709 }
24710 if (obj2) {
24711 ecode3 = SWIG_AsVal_int(obj2, &val3);
24712 if (!SWIG_IsOK(ecode3)) {
24713 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24714 }
24715 arg3 = static_cast< int >(val3);
24716 }
24717 {
24718 PyThreadState* __tstate = wxPyBeginAllowThreads();
24719 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24720 wxPyEndAllowThreads(__tstate);
24721 if (PyErr_Occurred()) SWIG_fail;
24722 }
24723 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24724 return resultobj;
24725 fail:
24726 return NULL;
24727 }
24728
24729
24730 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24731 PyObject *resultobj = 0;
24732 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24733 bool result;
24734 void *argp1 = 0 ;
24735 int res1 = 0 ;
24736 PyObject *swig_obj[1] ;
24737
24738 if (!args) SWIG_fail;
24739 swig_obj[0] = args;
24740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24741 if (!SWIG_IsOK(res1)) {
24742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24743 }
24744 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24745 {
24746 PyThreadState* __tstate = wxPyBeginAllowThreads();
24747 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24748 wxPyEndAllowThreads(__tstate);
24749 if (PyErr_Occurred()) SWIG_fail;
24750 }
24751 {
24752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24753 }
24754 return resultobj;
24755 fail:
24756 return NULL;
24757 }
24758
24759
24760 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24761 PyObject *obj;
24762 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24763 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24764 return SWIG_Py_Void();
24765 }
24766
24767 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24768 return SWIG_Python_InitShadowInstance(args);
24769 }
24770
24771 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24772 PyObject *resultobj = 0;
24773 int arg1 = (int) 0 ;
24774 wxInitDialogEvent *result = 0 ;
24775 int val1 ;
24776 int ecode1 = 0 ;
24777 PyObject * obj0 = 0 ;
24778 char * kwnames[] = {
24779 (char *) "Id", NULL
24780 };
24781
24782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24783 if (obj0) {
24784 ecode1 = SWIG_AsVal_int(obj0, &val1);
24785 if (!SWIG_IsOK(ecode1)) {
24786 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24787 }
24788 arg1 = static_cast< int >(val1);
24789 }
24790 {
24791 PyThreadState* __tstate = wxPyBeginAllowThreads();
24792 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24793 wxPyEndAllowThreads(__tstate);
24794 if (PyErr_Occurred()) SWIG_fail;
24795 }
24796 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24797 return resultobj;
24798 fail:
24799 return NULL;
24800 }
24801
24802
24803 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24804 PyObject *obj;
24805 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24806 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24807 return SWIG_Py_Void();
24808 }
24809
24810 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24811 return SWIG_Python_InitShadowInstance(args);
24812 }
24813
24814 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24815 PyObject *resultobj = 0;
24816 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24817 int arg2 = (int) 0 ;
24818 wxMenu *arg3 = (wxMenu *) NULL ;
24819 wxMenuEvent *result = 0 ;
24820 int val1 ;
24821 int ecode1 = 0 ;
24822 int val2 ;
24823 int ecode2 = 0 ;
24824 void *argp3 = 0 ;
24825 int res3 = 0 ;
24826 PyObject * obj0 = 0 ;
24827 PyObject * obj1 = 0 ;
24828 PyObject * obj2 = 0 ;
24829 char * kwnames[] = {
24830 (char *) "type",(char *) "winid",(char *) "menu", NULL
24831 };
24832
24833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24834 if (obj0) {
24835 ecode1 = SWIG_AsVal_int(obj0, &val1);
24836 if (!SWIG_IsOK(ecode1)) {
24837 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24838 }
24839 arg1 = static_cast< wxEventType >(val1);
24840 }
24841 if (obj1) {
24842 ecode2 = SWIG_AsVal_int(obj1, &val2);
24843 if (!SWIG_IsOK(ecode2)) {
24844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24845 }
24846 arg2 = static_cast< int >(val2);
24847 }
24848 if (obj2) {
24849 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24850 if (!SWIG_IsOK(res3)) {
24851 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24852 }
24853 arg3 = reinterpret_cast< wxMenu * >(argp3);
24854 }
24855 {
24856 PyThreadState* __tstate = wxPyBeginAllowThreads();
24857 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24858 wxPyEndAllowThreads(__tstate);
24859 if (PyErr_Occurred()) SWIG_fail;
24860 }
24861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24862 return resultobj;
24863 fail:
24864 return NULL;
24865 }
24866
24867
24868 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24869 PyObject *resultobj = 0;
24870 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24871 int result;
24872 void *argp1 = 0 ;
24873 int res1 = 0 ;
24874 PyObject *swig_obj[1] ;
24875
24876 if (!args) SWIG_fail;
24877 swig_obj[0] = args;
24878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24879 if (!SWIG_IsOK(res1)) {
24880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24881 }
24882 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24883 {
24884 PyThreadState* __tstate = wxPyBeginAllowThreads();
24885 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24886 wxPyEndAllowThreads(__tstate);
24887 if (PyErr_Occurred()) SWIG_fail;
24888 }
24889 resultobj = SWIG_From_int(static_cast< int >(result));
24890 return resultobj;
24891 fail:
24892 return NULL;
24893 }
24894
24895
24896 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24897 PyObject *resultobj = 0;
24898 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24899 bool result;
24900 void *argp1 = 0 ;
24901 int res1 = 0 ;
24902 PyObject *swig_obj[1] ;
24903
24904 if (!args) SWIG_fail;
24905 swig_obj[0] = args;
24906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24907 if (!SWIG_IsOK(res1)) {
24908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24909 }
24910 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24911 {
24912 PyThreadState* __tstate = wxPyBeginAllowThreads();
24913 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24914 wxPyEndAllowThreads(__tstate);
24915 if (PyErr_Occurred()) SWIG_fail;
24916 }
24917 {
24918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24919 }
24920 return resultobj;
24921 fail:
24922 return NULL;
24923 }
24924
24925
24926 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24927 PyObject *resultobj = 0;
24928 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24929 wxMenu *result = 0 ;
24930 void *argp1 = 0 ;
24931 int res1 = 0 ;
24932 PyObject *swig_obj[1] ;
24933
24934 if (!args) SWIG_fail;
24935 swig_obj[0] = args;
24936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24937 if (!SWIG_IsOK(res1)) {
24938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24939 }
24940 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24941 {
24942 PyThreadState* __tstate = wxPyBeginAllowThreads();
24943 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24944 wxPyEndAllowThreads(__tstate);
24945 if (PyErr_Occurred()) SWIG_fail;
24946 }
24947 {
24948 resultobj = wxPyMake_wxObject(result, (bool)0);
24949 }
24950 return resultobj;
24951 fail:
24952 return NULL;
24953 }
24954
24955
24956 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24957 PyObject *obj;
24958 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24959 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24960 return SWIG_Py_Void();
24961 }
24962
24963 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24964 return SWIG_Python_InitShadowInstance(args);
24965 }
24966
24967 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24968 PyObject *resultobj = 0;
24969 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24970 int arg2 = (int) 0 ;
24971 wxCloseEvent *result = 0 ;
24972 int val1 ;
24973 int ecode1 = 0 ;
24974 int val2 ;
24975 int ecode2 = 0 ;
24976 PyObject * obj0 = 0 ;
24977 PyObject * obj1 = 0 ;
24978 char * kwnames[] = {
24979 (char *) "type",(char *) "winid", NULL
24980 };
24981
24982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24983 if (obj0) {
24984 ecode1 = SWIG_AsVal_int(obj0, &val1);
24985 if (!SWIG_IsOK(ecode1)) {
24986 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24987 }
24988 arg1 = static_cast< wxEventType >(val1);
24989 }
24990 if (obj1) {
24991 ecode2 = SWIG_AsVal_int(obj1, &val2);
24992 if (!SWIG_IsOK(ecode2)) {
24993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24994 }
24995 arg2 = static_cast< int >(val2);
24996 }
24997 {
24998 PyThreadState* __tstate = wxPyBeginAllowThreads();
24999 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
25000 wxPyEndAllowThreads(__tstate);
25001 if (PyErr_Occurred()) SWIG_fail;
25002 }
25003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
25004 return resultobj;
25005 fail:
25006 return NULL;
25007 }
25008
25009
25010 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25011 PyObject *resultobj = 0;
25012 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25013 bool arg2 ;
25014 void *argp1 = 0 ;
25015 int res1 = 0 ;
25016 bool val2 ;
25017 int ecode2 = 0 ;
25018 PyObject * obj0 = 0 ;
25019 PyObject * obj1 = 0 ;
25020 char * kwnames[] = {
25021 (char *) "self",(char *) "logOff", NULL
25022 };
25023
25024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
25025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25026 if (!SWIG_IsOK(res1)) {
25027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25028 }
25029 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25030 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25031 if (!SWIG_IsOK(ecode2)) {
25032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
25033 }
25034 arg2 = static_cast< bool >(val2);
25035 {
25036 PyThreadState* __tstate = wxPyBeginAllowThreads();
25037 (arg1)->SetLoggingOff(arg2);
25038 wxPyEndAllowThreads(__tstate);
25039 if (PyErr_Occurred()) SWIG_fail;
25040 }
25041 resultobj = SWIG_Py_Void();
25042 return resultobj;
25043 fail:
25044 return NULL;
25045 }
25046
25047
25048 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25049 PyObject *resultobj = 0;
25050 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25051 bool result;
25052 void *argp1 = 0 ;
25053 int res1 = 0 ;
25054 PyObject *swig_obj[1] ;
25055
25056 if (!args) SWIG_fail;
25057 swig_obj[0] = args;
25058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25059 if (!SWIG_IsOK(res1)) {
25060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25061 }
25062 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25063 {
25064 PyThreadState* __tstate = wxPyBeginAllowThreads();
25065 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
25066 wxPyEndAllowThreads(__tstate);
25067 if (PyErr_Occurred()) SWIG_fail;
25068 }
25069 {
25070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25071 }
25072 return resultobj;
25073 fail:
25074 return NULL;
25075 }
25076
25077
25078 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25079 PyObject *resultobj = 0;
25080 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25081 bool arg2 = (bool) true ;
25082 void *argp1 = 0 ;
25083 int res1 = 0 ;
25084 bool val2 ;
25085 int ecode2 = 0 ;
25086 PyObject * obj0 = 0 ;
25087 PyObject * obj1 = 0 ;
25088 char * kwnames[] = {
25089 (char *) "self",(char *) "veto", NULL
25090 };
25091
25092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
25093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25094 if (!SWIG_IsOK(res1)) {
25095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25096 }
25097 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25098 if (obj1) {
25099 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25100 if (!SWIG_IsOK(ecode2)) {
25101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
25102 }
25103 arg2 = static_cast< bool >(val2);
25104 }
25105 {
25106 PyThreadState* __tstate = wxPyBeginAllowThreads();
25107 (arg1)->Veto(arg2);
25108 wxPyEndAllowThreads(__tstate);
25109 if (PyErr_Occurred()) SWIG_fail;
25110 }
25111 resultobj = SWIG_Py_Void();
25112 return resultobj;
25113 fail:
25114 return NULL;
25115 }
25116
25117
25118 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25119 PyObject *resultobj = 0;
25120 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25121 bool result;
25122 void *argp1 = 0 ;
25123 int res1 = 0 ;
25124 PyObject *swig_obj[1] ;
25125
25126 if (!args) SWIG_fail;
25127 swig_obj[0] = args;
25128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25129 if (!SWIG_IsOK(res1)) {
25130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25131 }
25132 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25133 {
25134 PyThreadState* __tstate = wxPyBeginAllowThreads();
25135 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
25136 wxPyEndAllowThreads(__tstate);
25137 if (PyErr_Occurred()) SWIG_fail;
25138 }
25139 {
25140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25141 }
25142 return resultobj;
25143 fail:
25144 return NULL;
25145 }
25146
25147
25148 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25149 PyObject *resultobj = 0;
25150 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25151 bool arg2 ;
25152 void *argp1 = 0 ;
25153 int res1 = 0 ;
25154 bool val2 ;
25155 int ecode2 = 0 ;
25156 PyObject * obj0 = 0 ;
25157 PyObject * obj1 = 0 ;
25158 char * kwnames[] = {
25159 (char *) "self",(char *) "canVeto", NULL
25160 };
25161
25162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
25163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25164 if (!SWIG_IsOK(res1)) {
25165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25166 }
25167 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25168 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25169 if (!SWIG_IsOK(ecode2)) {
25170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
25171 }
25172 arg2 = static_cast< bool >(val2);
25173 {
25174 PyThreadState* __tstate = wxPyBeginAllowThreads();
25175 (arg1)->SetCanVeto(arg2);
25176 wxPyEndAllowThreads(__tstate);
25177 if (PyErr_Occurred()) SWIG_fail;
25178 }
25179 resultobj = SWIG_Py_Void();
25180 return resultobj;
25181 fail:
25182 return NULL;
25183 }
25184
25185
25186 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25187 PyObject *resultobj = 0;
25188 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25189 bool result;
25190 void *argp1 = 0 ;
25191 int res1 = 0 ;
25192 PyObject *swig_obj[1] ;
25193
25194 if (!args) SWIG_fail;
25195 swig_obj[0] = args;
25196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25197 if (!SWIG_IsOK(res1)) {
25198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25199 }
25200 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25201 {
25202 PyThreadState* __tstate = wxPyBeginAllowThreads();
25203 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
25204 wxPyEndAllowThreads(__tstate);
25205 if (PyErr_Occurred()) SWIG_fail;
25206 }
25207 {
25208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25209 }
25210 return resultobj;
25211 fail:
25212 return NULL;
25213 }
25214
25215
25216 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25217 PyObject *obj;
25218 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25219 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
25220 return SWIG_Py_Void();
25221 }
25222
25223 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25224 return SWIG_Python_InitShadowInstance(args);
25225 }
25226
25227 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25228 PyObject *resultobj = 0;
25229 int arg1 = (int) 0 ;
25230 bool arg2 = (bool) false ;
25231 wxShowEvent *result = 0 ;
25232 int val1 ;
25233 int ecode1 = 0 ;
25234 bool val2 ;
25235 int ecode2 = 0 ;
25236 PyObject * obj0 = 0 ;
25237 PyObject * obj1 = 0 ;
25238 char * kwnames[] = {
25239 (char *) "winid",(char *) "show", NULL
25240 };
25241
25242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25243 if (obj0) {
25244 ecode1 = SWIG_AsVal_int(obj0, &val1);
25245 if (!SWIG_IsOK(ecode1)) {
25246 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
25247 }
25248 arg1 = static_cast< int >(val1);
25249 }
25250 if (obj1) {
25251 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25252 if (!SWIG_IsOK(ecode2)) {
25253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
25254 }
25255 arg2 = static_cast< bool >(val2);
25256 }
25257 {
25258 PyThreadState* __tstate = wxPyBeginAllowThreads();
25259 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
25260 wxPyEndAllowThreads(__tstate);
25261 if (PyErr_Occurred()) SWIG_fail;
25262 }
25263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
25264 return resultobj;
25265 fail:
25266 return NULL;
25267 }
25268
25269
25270 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25271 PyObject *resultobj = 0;
25272 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
25273 bool arg2 ;
25274 void *argp1 = 0 ;
25275 int res1 = 0 ;
25276 bool val2 ;
25277 int ecode2 = 0 ;
25278 PyObject * obj0 = 0 ;
25279 PyObject * obj1 = 0 ;
25280 char * kwnames[] = {
25281 (char *) "self",(char *) "show", NULL
25282 };
25283
25284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
25285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
25286 if (!SWIG_IsOK(res1)) {
25287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
25288 }
25289 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
25290 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25291 if (!SWIG_IsOK(ecode2)) {
25292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
25293 }
25294 arg2 = static_cast< bool >(val2);
25295 {
25296 PyThreadState* __tstate = wxPyBeginAllowThreads();
25297 (arg1)->SetShow(arg2);
25298 wxPyEndAllowThreads(__tstate);
25299 if (PyErr_Occurred()) SWIG_fail;
25300 }
25301 resultobj = SWIG_Py_Void();
25302 return resultobj;
25303 fail:
25304 return NULL;
25305 }
25306
25307
25308 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25309 PyObject *resultobj = 0;
25310 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
25311 bool result;
25312 void *argp1 = 0 ;
25313 int res1 = 0 ;
25314 PyObject *swig_obj[1] ;
25315
25316 if (!args) SWIG_fail;
25317 swig_obj[0] = args;
25318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
25319 if (!SWIG_IsOK(res1)) {
25320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
25321 }
25322 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
25323 {
25324 PyThreadState* __tstate = wxPyBeginAllowThreads();
25325 result = (bool)((wxShowEvent const *)arg1)->GetShow();
25326 wxPyEndAllowThreads(__tstate);
25327 if (PyErr_Occurred()) SWIG_fail;
25328 }
25329 {
25330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25331 }
25332 return resultobj;
25333 fail:
25334 return NULL;
25335 }
25336
25337
25338 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25339 PyObject *obj;
25340 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25341 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
25342 return SWIG_Py_Void();
25343 }
25344
25345 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25346 return SWIG_Python_InitShadowInstance(args);
25347 }
25348
25349 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25350 PyObject *resultobj = 0;
25351 int arg1 = (int) 0 ;
25352 bool arg2 = (bool) true ;
25353 wxIconizeEvent *result = 0 ;
25354 int val1 ;
25355 int ecode1 = 0 ;
25356 bool val2 ;
25357 int ecode2 = 0 ;
25358 PyObject * obj0 = 0 ;
25359 PyObject * obj1 = 0 ;
25360 char * kwnames[] = {
25361 (char *) "id",(char *) "iconized", NULL
25362 };
25363
25364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25365 if (obj0) {
25366 ecode1 = SWIG_AsVal_int(obj0, &val1);
25367 if (!SWIG_IsOK(ecode1)) {
25368 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
25369 }
25370 arg1 = static_cast< int >(val1);
25371 }
25372 if (obj1) {
25373 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25374 if (!SWIG_IsOK(ecode2)) {
25375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
25376 }
25377 arg2 = static_cast< bool >(val2);
25378 }
25379 {
25380 PyThreadState* __tstate = wxPyBeginAllowThreads();
25381 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
25382 wxPyEndAllowThreads(__tstate);
25383 if (PyErr_Occurred()) SWIG_fail;
25384 }
25385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
25386 return resultobj;
25387 fail:
25388 return NULL;
25389 }
25390
25391
25392 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25393 PyObject *resultobj = 0;
25394 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
25395 bool result;
25396 void *argp1 = 0 ;
25397 int res1 = 0 ;
25398 PyObject *swig_obj[1] ;
25399
25400 if (!args) SWIG_fail;
25401 swig_obj[0] = args;
25402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
25403 if (!SWIG_IsOK(res1)) {
25404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
25405 }
25406 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
25407 {
25408 PyThreadState* __tstate = wxPyBeginAllowThreads();
25409 result = (bool)(arg1)->Iconized();
25410 wxPyEndAllowThreads(__tstate);
25411 if (PyErr_Occurred()) SWIG_fail;
25412 }
25413 {
25414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25415 }
25416 return resultobj;
25417 fail:
25418 return NULL;
25419 }
25420
25421
25422 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25423 PyObject *obj;
25424 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25425 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
25426 return SWIG_Py_Void();
25427 }
25428
25429 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25430 return SWIG_Python_InitShadowInstance(args);
25431 }
25432
25433 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25434 PyObject *resultobj = 0;
25435 int arg1 = (int) 0 ;
25436 wxMaximizeEvent *result = 0 ;
25437 int val1 ;
25438 int ecode1 = 0 ;
25439 PyObject * obj0 = 0 ;
25440 char * kwnames[] = {
25441 (char *) "id", NULL
25442 };
25443
25444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
25445 if (obj0) {
25446 ecode1 = SWIG_AsVal_int(obj0, &val1);
25447 if (!SWIG_IsOK(ecode1)) {
25448 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
25449 }
25450 arg1 = static_cast< int >(val1);
25451 }
25452 {
25453 PyThreadState* __tstate = wxPyBeginAllowThreads();
25454 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
25455 wxPyEndAllowThreads(__tstate);
25456 if (PyErr_Occurred()) SWIG_fail;
25457 }
25458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
25459 return resultobj;
25460 fail:
25461 return NULL;
25462 }
25463
25464
25465 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25466 PyObject *obj;
25467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25468 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
25469 return SWIG_Py_Void();
25470 }
25471
25472 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25473 return SWIG_Python_InitShadowInstance(args);
25474 }
25475
25476 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25477 PyObject *resultobj = 0;
25478 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25479 wxPoint result;
25480 void *argp1 = 0 ;
25481 int res1 = 0 ;
25482 PyObject *swig_obj[1] ;
25483
25484 if (!args) SWIG_fail;
25485 swig_obj[0] = args;
25486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25487 if (!SWIG_IsOK(res1)) {
25488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25489 }
25490 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25491 {
25492 PyThreadState* __tstate = wxPyBeginAllowThreads();
25493 result = (arg1)->GetPosition();
25494 wxPyEndAllowThreads(__tstate);
25495 if (PyErr_Occurred()) SWIG_fail;
25496 }
25497 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25498 return resultobj;
25499 fail:
25500 return NULL;
25501 }
25502
25503
25504 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25505 PyObject *resultobj = 0;
25506 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25507 int result;
25508 void *argp1 = 0 ;
25509 int res1 = 0 ;
25510 PyObject *swig_obj[1] ;
25511
25512 if (!args) SWIG_fail;
25513 swig_obj[0] = args;
25514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25515 if (!SWIG_IsOK(res1)) {
25516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25517 }
25518 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25519 {
25520 PyThreadState* __tstate = wxPyBeginAllowThreads();
25521 result = (int)(arg1)->GetNumberOfFiles();
25522 wxPyEndAllowThreads(__tstate);
25523 if (PyErr_Occurred()) SWIG_fail;
25524 }
25525 resultobj = SWIG_From_int(static_cast< int >(result));
25526 return resultobj;
25527 fail:
25528 return NULL;
25529 }
25530
25531
25532 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25533 PyObject *resultobj = 0;
25534 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25535 PyObject *result = 0 ;
25536 void *argp1 = 0 ;
25537 int res1 = 0 ;
25538 PyObject *swig_obj[1] ;
25539
25540 if (!args) SWIG_fail;
25541 swig_obj[0] = args;
25542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25543 if (!SWIG_IsOK(res1)) {
25544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25545 }
25546 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25547 {
25548 PyThreadState* __tstate = wxPyBeginAllowThreads();
25549 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
25550 wxPyEndAllowThreads(__tstate);
25551 if (PyErr_Occurred()) SWIG_fail;
25552 }
25553 resultobj = result;
25554 return resultobj;
25555 fail:
25556 return NULL;
25557 }
25558
25559
25560 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25561 PyObject *obj;
25562 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25563 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
25564 return SWIG_Py_Void();
25565 }
25566
25567 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25568 PyObject *resultobj = 0;
25569 int arg1 = (int) 0 ;
25570 wxUpdateUIEvent *result = 0 ;
25571 int val1 ;
25572 int ecode1 = 0 ;
25573 PyObject * obj0 = 0 ;
25574 char * kwnames[] = {
25575 (char *) "commandId", NULL
25576 };
25577
25578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
25579 if (obj0) {
25580 ecode1 = SWIG_AsVal_int(obj0, &val1);
25581 if (!SWIG_IsOK(ecode1)) {
25582 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
25583 }
25584 arg1 = static_cast< int >(val1);
25585 }
25586 {
25587 PyThreadState* __tstate = wxPyBeginAllowThreads();
25588 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
25589 wxPyEndAllowThreads(__tstate);
25590 if (PyErr_Occurred()) SWIG_fail;
25591 }
25592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
25593 return resultobj;
25594 fail:
25595 return NULL;
25596 }
25597
25598
25599 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25600 PyObject *resultobj = 0;
25601 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25602 bool result;
25603 void *argp1 = 0 ;
25604 int res1 = 0 ;
25605 PyObject *swig_obj[1] ;
25606
25607 if (!args) SWIG_fail;
25608 swig_obj[0] = args;
25609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25610 if (!SWIG_IsOK(res1)) {
25611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25612 }
25613 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25614 {
25615 PyThreadState* __tstate = wxPyBeginAllowThreads();
25616 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
25617 wxPyEndAllowThreads(__tstate);
25618 if (PyErr_Occurred()) SWIG_fail;
25619 }
25620 {
25621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25622 }
25623 return resultobj;
25624 fail:
25625 return NULL;
25626 }
25627
25628
25629 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25630 PyObject *resultobj = 0;
25631 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25632 bool result;
25633 void *argp1 = 0 ;
25634 int res1 = 0 ;
25635 PyObject *swig_obj[1] ;
25636
25637 if (!args) SWIG_fail;
25638 swig_obj[0] = args;
25639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25640 if (!SWIG_IsOK(res1)) {
25641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25642 }
25643 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25644 {
25645 PyThreadState* __tstate = wxPyBeginAllowThreads();
25646 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25647 wxPyEndAllowThreads(__tstate);
25648 if (PyErr_Occurred()) SWIG_fail;
25649 }
25650 {
25651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25652 }
25653 return resultobj;
25654 fail:
25655 return NULL;
25656 }
25657
25658
25659 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25660 PyObject *resultobj = 0;
25661 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25662 bool result;
25663 void *argp1 = 0 ;
25664 int res1 = 0 ;
25665 PyObject *swig_obj[1] ;
25666
25667 if (!args) SWIG_fail;
25668 swig_obj[0] = args;
25669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25670 if (!SWIG_IsOK(res1)) {
25671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25672 }
25673 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25674 {
25675 PyThreadState* __tstate = wxPyBeginAllowThreads();
25676 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25677 wxPyEndAllowThreads(__tstate);
25678 if (PyErr_Occurred()) SWIG_fail;
25679 }
25680 {
25681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25682 }
25683 return resultobj;
25684 fail:
25685 return NULL;
25686 }
25687
25688
25689 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25690 PyObject *resultobj = 0;
25691 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25692 wxString result;
25693 void *argp1 = 0 ;
25694 int res1 = 0 ;
25695 PyObject *swig_obj[1] ;
25696
25697 if (!args) SWIG_fail;
25698 swig_obj[0] = args;
25699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25700 if (!SWIG_IsOK(res1)) {
25701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25702 }
25703 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25704 {
25705 PyThreadState* __tstate = wxPyBeginAllowThreads();
25706 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25707 wxPyEndAllowThreads(__tstate);
25708 if (PyErr_Occurred()) SWIG_fail;
25709 }
25710 {
25711 #if wxUSE_UNICODE
25712 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25713 #else
25714 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25715 #endif
25716 }
25717 return resultobj;
25718 fail:
25719 return NULL;
25720 }
25721
25722
25723 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25724 PyObject *resultobj = 0;
25725 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25726 bool result;
25727 void *argp1 = 0 ;
25728 int res1 = 0 ;
25729 PyObject *swig_obj[1] ;
25730
25731 if (!args) SWIG_fail;
25732 swig_obj[0] = args;
25733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25734 if (!SWIG_IsOK(res1)) {
25735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25736 }
25737 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25738 {
25739 PyThreadState* __tstate = wxPyBeginAllowThreads();
25740 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25741 wxPyEndAllowThreads(__tstate);
25742 if (PyErr_Occurred()) SWIG_fail;
25743 }
25744 {
25745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25746 }
25747 return resultobj;
25748 fail:
25749 return NULL;
25750 }
25751
25752
25753 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25754 PyObject *resultobj = 0;
25755 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25756 bool result;
25757 void *argp1 = 0 ;
25758 int res1 = 0 ;
25759 PyObject *swig_obj[1] ;
25760
25761 if (!args) SWIG_fail;
25762 swig_obj[0] = args;
25763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25764 if (!SWIG_IsOK(res1)) {
25765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25766 }
25767 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25768 {
25769 PyThreadState* __tstate = wxPyBeginAllowThreads();
25770 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25771 wxPyEndAllowThreads(__tstate);
25772 if (PyErr_Occurred()) SWIG_fail;
25773 }
25774 {
25775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25776 }
25777 return resultobj;
25778 fail:
25779 return NULL;
25780 }
25781
25782
25783 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25784 PyObject *resultobj = 0;
25785 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25786 bool result;
25787 void *argp1 = 0 ;
25788 int res1 = 0 ;
25789 PyObject *swig_obj[1] ;
25790
25791 if (!args) SWIG_fail;
25792 swig_obj[0] = args;
25793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25794 if (!SWIG_IsOK(res1)) {
25795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25796 }
25797 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25798 {
25799 PyThreadState* __tstate = wxPyBeginAllowThreads();
25800 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25801 wxPyEndAllowThreads(__tstate);
25802 if (PyErr_Occurred()) SWIG_fail;
25803 }
25804 {
25805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25806 }
25807 return resultobj;
25808 fail:
25809 return NULL;
25810 }
25811
25812
25813 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25814 PyObject *resultobj = 0;
25815 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25816 bool result;
25817 void *argp1 = 0 ;
25818 int res1 = 0 ;
25819 PyObject *swig_obj[1] ;
25820
25821 if (!args) SWIG_fail;
25822 swig_obj[0] = args;
25823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25824 if (!SWIG_IsOK(res1)) {
25825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25826 }
25827 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25828 {
25829 PyThreadState* __tstate = wxPyBeginAllowThreads();
25830 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25831 wxPyEndAllowThreads(__tstate);
25832 if (PyErr_Occurred()) SWIG_fail;
25833 }
25834 {
25835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25836 }
25837 return resultobj;
25838 fail:
25839 return NULL;
25840 }
25841
25842
25843 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25844 PyObject *resultobj = 0;
25845 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25846 bool arg2 ;
25847 void *argp1 = 0 ;
25848 int res1 = 0 ;
25849 bool val2 ;
25850 int ecode2 = 0 ;
25851 PyObject * obj0 = 0 ;
25852 PyObject * obj1 = 0 ;
25853 char * kwnames[] = {
25854 (char *) "self",(char *) "check", NULL
25855 };
25856
25857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25859 if (!SWIG_IsOK(res1)) {
25860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25861 }
25862 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25863 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25864 if (!SWIG_IsOK(ecode2)) {
25865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25866 }
25867 arg2 = static_cast< bool >(val2);
25868 {
25869 PyThreadState* __tstate = wxPyBeginAllowThreads();
25870 (arg1)->Check(arg2);
25871 wxPyEndAllowThreads(__tstate);
25872 if (PyErr_Occurred()) SWIG_fail;
25873 }
25874 resultobj = SWIG_Py_Void();
25875 return resultobj;
25876 fail:
25877 return NULL;
25878 }
25879
25880
25881 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25882 PyObject *resultobj = 0;
25883 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25884 bool arg2 ;
25885 void *argp1 = 0 ;
25886 int res1 = 0 ;
25887 bool val2 ;
25888 int ecode2 = 0 ;
25889 PyObject * obj0 = 0 ;
25890 PyObject * obj1 = 0 ;
25891 char * kwnames[] = {
25892 (char *) "self",(char *) "enable", NULL
25893 };
25894
25895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25897 if (!SWIG_IsOK(res1)) {
25898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25899 }
25900 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25901 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25902 if (!SWIG_IsOK(ecode2)) {
25903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25904 }
25905 arg2 = static_cast< bool >(val2);
25906 {
25907 PyThreadState* __tstate = wxPyBeginAllowThreads();
25908 (arg1)->Enable(arg2);
25909 wxPyEndAllowThreads(__tstate);
25910 if (PyErr_Occurred()) SWIG_fail;
25911 }
25912 resultobj = SWIG_Py_Void();
25913 return resultobj;
25914 fail:
25915 return NULL;
25916 }
25917
25918
25919 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25920 PyObject *resultobj = 0;
25921 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25922 bool arg2 ;
25923 void *argp1 = 0 ;
25924 int res1 = 0 ;
25925 bool val2 ;
25926 int ecode2 = 0 ;
25927 PyObject * obj0 = 0 ;
25928 PyObject * obj1 = 0 ;
25929 char * kwnames[] = {
25930 (char *) "self",(char *) "show", NULL
25931 };
25932
25933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25935 if (!SWIG_IsOK(res1)) {
25936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25937 }
25938 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25939 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25940 if (!SWIG_IsOK(ecode2)) {
25941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25942 }
25943 arg2 = static_cast< bool >(val2);
25944 {
25945 PyThreadState* __tstate = wxPyBeginAllowThreads();
25946 (arg1)->Show(arg2);
25947 wxPyEndAllowThreads(__tstate);
25948 if (PyErr_Occurred()) SWIG_fail;
25949 }
25950 resultobj = SWIG_Py_Void();
25951 return resultobj;
25952 fail:
25953 return NULL;
25954 }
25955
25956
25957 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25958 PyObject *resultobj = 0;
25959 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25960 wxString *arg2 = 0 ;
25961 void *argp1 = 0 ;
25962 int res1 = 0 ;
25963 bool temp2 = false ;
25964 PyObject * obj0 = 0 ;
25965 PyObject * obj1 = 0 ;
25966 char * kwnames[] = {
25967 (char *) "self",(char *) "text", NULL
25968 };
25969
25970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25972 if (!SWIG_IsOK(res1)) {
25973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25974 }
25975 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25976 {
25977 arg2 = wxString_in_helper(obj1);
25978 if (arg2 == NULL) SWIG_fail;
25979 temp2 = true;
25980 }
25981 {
25982 PyThreadState* __tstate = wxPyBeginAllowThreads();
25983 (arg1)->SetText((wxString const &)*arg2);
25984 wxPyEndAllowThreads(__tstate);
25985 if (PyErr_Occurred()) SWIG_fail;
25986 }
25987 resultobj = SWIG_Py_Void();
25988 {
25989 if (temp2)
25990 delete arg2;
25991 }
25992 return resultobj;
25993 fail:
25994 {
25995 if (temp2)
25996 delete arg2;
25997 }
25998 return NULL;
25999 }
26000
26001
26002 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26003 PyObject *resultobj = 0;
26004 long arg1 ;
26005 long val1 ;
26006 int ecode1 = 0 ;
26007 PyObject * obj0 = 0 ;
26008 char * kwnames[] = {
26009 (char *) "updateInterval", NULL
26010 };
26011
26012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
26013 ecode1 = SWIG_AsVal_long(obj0, &val1);
26014 if (!SWIG_IsOK(ecode1)) {
26015 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
26016 }
26017 arg1 = static_cast< long >(val1);
26018 {
26019 PyThreadState* __tstate = wxPyBeginAllowThreads();
26020 wxUpdateUIEvent::SetUpdateInterval(arg1);
26021 wxPyEndAllowThreads(__tstate);
26022 if (PyErr_Occurred()) SWIG_fail;
26023 }
26024 resultobj = SWIG_Py_Void();
26025 return resultobj;
26026 fail:
26027 return NULL;
26028 }
26029
26030
26031 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26032 PyObject *resultobj = 0;
26033 long result;
26034
26035 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
26036 {
26037 PyThreadState* __tstate = wxPyBeginAllowThreads();
26038 result = (long)wxUpdateUIEvent::GetUpdateInterval();
26039 wxPyEndAllowThreads(__tstate);
26040 if (PyErr_Occurred()) SWIG_fail;
26041 }
26042 resultobj = SWIG_From_long(static_cast< long >(result));
26043 return resultobj;
26044 fail:
26045 return NULL;
26046 }
26047
26048
26049 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26050 PyObject *resultobj = 0;
26051 wxWindow *arg1 = (wxWindow *) 0 ;
26052 bool result;
26053 void *argp1 = 0 ;
26054 int res1 = 0 ;
26055 PyObject * obj0 = 0 ;
26056 char * kwnames[] = {
26057 (char *) "win", NULL
26058 };
26059
26060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
26061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26062 if (!SWIG_IsOK(res1)) {
26063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
26064 }
26065 arg1 = reinterpret_cast< wxWindow * >(argp1);
26066 {
26067 PyThreadState* __tstate = wxPyBeginAllowThreads();
26068 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
26069 wxPyEndAllowThreads(__tstate);
26070 if (PyErr_Occurred()) SWIG_fail;
26071 }
26072 {
26073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26074 }
26075 return resultobj;
26076 fail:
26077 return NULL;
26078 }
26079
26080
26081 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26082 PyObject *resultobj = 0;
26083
26084 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
26085 {
26086 PyThreadState* __tstate = wxPyBeginAllowThreads();
26087 wxUpdateUIEvent::ResetUpdateTime();
26088 wxPyEndAllowThreads(__tstate);
26089 if (PyErr_Occurred()) SWIG_fail;
26090 }
26091 resultobj = SWIG_Py_Void();
26092 return resultobj;
26093 fail:
26094 return NULL;
26095 }
26096
26097
26098 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26099 PyObject *resultobj = 0;
26100 wxUpdateUIMode arg1 ;
26101 int val1 ;
26102 int ecode1 = 0 ;
26103 PyObject * obj0 = 0 ;
26104 char * kwnames[] = {
26105 (char *) "mode", NULL
26106 };
26107
26108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26109 ecode1 = SWIG_AsVal_int(obj0, &val1);
26110 if (!SWIG_IsOK(ecode1)) {
26111 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
26112 }
26113 arg1 = static_cast< wxUpdateUIMode >(val1);
26114 {
26115 PyThreadState* __tstate = wxPyBeginAllowThreads();
26116 wxUpdateUIEvent::SetMode(arg1);
26117 wxPyEndAllowThreads(__tstate);
26118 if (PyErr_Occurred()) SWIG_fail;
26119 }
26120 resultobj = SWIG_Py_Void();
26121 return resultobj;
26122 fail:
26123 return NULL;
26124 }
26125
26126
26127 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26128 PyObject *resultobj = 0;
26129 wxUpdateUIMode result;
26130
26131 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
26132 {
26133 PyThreadState* __tstate = wxPyBeginAllowThreads();
26134 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
26135 wxPyEndAllowThreads(__tstate);
26136 if (PyErr_Occurred()) SWIG_fail;
26137 }
26138 resultobj = SWIG_From_int(static_cast< int >(result));
26139 return resultobj;
26140 fail:
26141 return NULL;
26142 }
26143
26144
26145 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26146 PyObject *obj;
26147 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26148 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
26149 return SWIG_Py_Void();
26150 }
26151
26152 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26153 return SWIG_Python_InitShadowInstance(args);
26154 }
26155
26156 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26157 PyObject *resultobj = 0;
26158 wxSysColourChangedEvent *result = 0 ;
26159
26160 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
26161 {
26162 PyThreadState* __tstate = wxPyBeginAllowThreads();
26163 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
26164 wxPyEndAllowThreads(__tstate);
26165 if (PyErr_Occurred()) SWIG_fail;
26166 }
26167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
26168 return resultobj;
26169 fail:
26170 return NULL;
26171 }
26172
26173
26174 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26175 PyObject *obj;
26176 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26177 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
26178 return SWIG_Py_Void();
26179 }
26180
26181 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26182 return SWIG_Python_InitShadowInstance(args);
26183 }
26184
26185 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26186 PyObject *resultobj = 0;
26187 int arg1 = (int) 0 ;
26188 wxWindow *arg2 = (wxWindow *) NULL ;
26189 wxMouseCaptureChangedEvent *result = 0 ;
26190 int val1 ;
26191 int ecode1 = 0 ;
26192 void *argp2 = 0 ;
26193 int res2 = 0 ;
26194 PyObject * obj0 = 0 ;
26195 PyObject * obj1 = 0 ;
26196 char * kwnames[] = {
26197 (char *) "winid",(char *) "gainedCapture", NULL
26198 };
26199
26200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26201 if (obj0) {
26202 ecode1 = SWIG_AsVal_int(obj0, &val1);
26203 if (!SWIG_IsOK(ecode1)) {
26204 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
26205 }
26206 arg1 = static_cast< int >(val1);
26207 }
26208 if (obj1) {
26209 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26210 if (!SWIG_IsOK(res2)) {
26211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
26212 }
26213 arg2 = reinterpret_cast< wxWindow * >(argp2);
26214 }
26215 {
26216 PyThreadState* __tstate = wxPyBeginAllowThreads();
26217 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
26218 wxPyEndAllowThreads(__tstate);
26219 if (PyErr_Occurred()) SWIG_fail;
26220 }
26221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
26222 return resultobj;
26223 fail:
26224 return NULL;
26225 }
26226
26227
26228 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26229 PyObject *resultobj = 0;
26230 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
26231 wxWindow *result = 0 ;
26232 void *argp1 = 0 ;
26233 int res1 = 0 ;
26234 PyObject *swig_obj[1] ;
26235
26236 if (!args) SWIG_fail;
26237 swig_obj[0] = args;
26238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
26239 if (!SWIG_IsOK(res1)) {
26240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
26241 }
26242 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
26243 {
26244 PyThreadState* __tstate = wxPyBeginAllowThreads();
26245 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
26246 wxPyEndAllowThreads(__tstate);
26247 if (PyErr_Occurred()) SWIG_fail;
26248 }
26249 {
26250 resultobj = wxPyMake_wxObject(result, (bool)0);
26251 }
26252 return resultobj;
26253 fail:
26254 return NULL;
26255 }
26256
26257
26258 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26259 PyObject *obj;
26260 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26261 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
26262 return SWIG_Py_Void();
26263 }
26264
26265 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26266 return SWIG_Python_InitShadowInstance(args);
26267 }
26268
26269 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26270 PyObject *resultobj = 0;
26271 int arg1 = (int) 0 ;
26272 wxMouseCaptureLostEvent *result = 0 ;
26273 int val1 ;
26274 int ecode1 = 0 ;
26275 PyObject * obj0 = 0 ;
26276 char * kwnames[] = {
26277 (char *) "winid", NULL
26278 };
26279
26280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
26281 if (obj0) {
26282 ecode1 = SWIG_AsVal_int(obj0, &val1);
26283 if (!SWIG_IsOK(ecode1)) {
26284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
26285 }
26286 arg1 = static_cast< int >(val1);
26287 }
26288 {
26289 PyThreadState* __tstate = wxPyBeginAllowThreads();
26290 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
26291 wxPyEndAllowThreads(__tstate);
26292 if (PyErr_Occurred()) SWIG_fail;
26293 }
26294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
26295 return resultobj;
26296 fail:
26297 return NULL;
26298 }
26299
26300
26301 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26302 PyObject *obj;
26303 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26304 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
26305 return SWIG_Py_Void();
26306 }
26307
26308 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26309 return SWIG_Python_InitShadowInstance(args);
26310 }
26311
26312 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26313 PyObject *resultobj = 0;
26314 wxDisplayChangedEvent *result = 0 ;
26315
26316 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
26317 {
26318 PyThreadState* __tstate = wxPyBeginAllowThreads();
26319 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
26320 wxPyEndAllowThreads(__tstate);
26321 if (PyErr_Occurred()) SWIG_fail;
26322 }
26323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
26324 return resultobj;
26325 fail:
26326 return NULL;
26327 }
26328
26329
26330 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26331 PyObject *obj;
26332 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26333 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
26334 return SWIG_Py_Void();
26335 }
26336
26337 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26338 return SWIG_Python_InitShadowInstance(args);
26339 }
26340
26341 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26342 PyObject *resultobj = 0;
26343 int arg1 = (int) 0 ;
26344 wxPaletteChangedEvent *result = 0 ;
26345 int val1 ;
26346 int ecode1 = 0 ;
26347 PyObject * obj0 = 0 ;
26348 char * kwnames[] = {
26349 (char *) "id", NULL
26350 };
26351
26352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
26353 if (obj0) {
26354 ecode1 = SWIG_AsVal_int(obj0, &val1);
26355 if (!SWIG_IsOK(ecode1)) {
26356 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
26357 }
26358 arg1 = static_cast< int >(val1);
26359 }
26360 {
26361 PyThreadState* __tstate = wxPyBeginAllowThreads();
26362 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
26363 wxPyEndAllowThreads(__tstate);
26364 if (PyErr_Occurred()) SWIG_fail;
26365 }
26366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
26367 return resultobj;
26368 fail:
26369 return NULL;
26370 }
26371
26372
26373 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26374 PyObject *resultobj = 0;
26375 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
26376 wxWindow *arg2 = (wxWindow *) 0 ;
26377 void *argp1 = 0 ;
26378 int res1 = 0 ;
26379 void *argp2 = 0 ;
26380 int res2 = 0 ;
26381 PyObject * obj0 = 0 ;
26382 PyObject * obj1 = 0 ;
26383 char * kwnames[] = {
26384 (char *) "self",(char *) "win", NULL
26385 };
26386
26387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
26389 if (!SWIG_IsOK(res1)) {
26390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
26391 }
26392 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
26393 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26394 if (!SWIG_IsOK(res2)) {
26395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26396 }
26397 arg2 = reinterpret_cast< wxWindow * >(argp2);
26398 {
26399 PyThreadState* __tstate = wxPyBeginAllowThreads();
26400 (arg1)->SetChangedWindow(arg2);
26401 wxPyEndAllowThreads(__tstate);
26402 if (PyErr_Occurred()) SWIG_fail;
26403 }
26404 resultobj = SWIG_Py_Void();
26405 return resultobj;
26406 fail:
26407 return NULL;
26408 }
26409
26410
26411 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26412 PyObject *resultobj = 0;
26413 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
26414 wxWindow *result = 0 ;
26415 void *argp1 = 0 ;
26416 int res1 = 0 ;
26417 PyObject *swig_obj[1] ;
26418
26419 if (!args) SWIG_fail;
26420 swig_obj[0] = args;
26421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
26422 if (!SWIG_IsOK(res1)) {
26423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
26424 }
26425 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
26426 {
26427 PyThreadState* __tstate = wxPyBeginAllowThreads();
26428 result = (wxWindow *)(arg1)->GetChangedWindow();
26429 wxPyEndAllowThreads(__tstate);
26430 if (PyErr_Occurred()) SWIG_fail;
26431 }
26432 {
26433 resultobj = wxPyMake_wxObject(result, (bool)0);
26434 }
26435 return resultobj;
26436 fail:
26437 return NULL;
26438 }
26439
26440
26441 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26442 PyObject *obj;
26443 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26444 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
26445 return SWIG_Py_Void();
26446 }
26447
26448 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26449 return SWIG_Python_InitShadowInstance(args);
26450 }
26451
26452 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26453 PyObject *resultobj = 0;
26454 int arg1 = (int) 0 ;
26455 wxQueryNewPaletteEvent *result = 0 ;
26456 int val1 ;
26457 int ecode1 = 0 ;
26458 PyObject * obj0 = 0 ;
26459 char * kwnames[] = {
26460 (char *) "winid", NULL
26461 };
26462
26463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
26464 if (obj0) {
26465 ecode1 = SWIG_AsVal_int(obj0, &val1);
26466 if (!SWIG_IsOK(ecode1)) {
26467 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
26468 }
26469 arg1 = static_cast< int >(val1);
26470 }
26471 {
26472 PyThreadState* __tstate = wxPyBeginAllowThreads();
26473 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
26474 wxPyEndAllowThreads(__tstate);
26475 if (PyErr_Occurred()) SWIG_fail;
26476 }
26477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
26478 return resultobj;
26479 fail:
26480 return NULL;
26481 }
26482
26483
26484 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26485 PyObject *resultobj = 0;
26486 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26487 bool arg2 ;
26488 void *argp1 = 0 ;
26489 int res1 = 0 ;
26490 bool val2 ;
26491 int ecode2 = 0 ;
26492 PyObject * obj0 = 0 ;
26493 PyObject * obj1 = 0 ;
26494 char * kwnames[] = {
26495 (char *) "self",(char *) "realized", NULL
26496 };
26497
26498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
26499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26500 if (!SWIG_IsOK(res1)) {
26501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
26502 }
26503 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26504 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26505 if (!SWIG_IsOK(ecode2)) {
26506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
26507 }
26508 arg2 = static_cast< bool >(val2);
26509 {
26510 PyThreadState* __tstate = wxPyBeginAllowThreads();
26511 (arg1)->SetPaletteRealized(arg2);
26512 wxPyEndAllowThreads(__tstate);
26513 if (PyErr_Occurred()) SWIG_fail;
26514 }
26515 resultobj = SWIG_Py_Void();
26516 return resultobj;
26517 fail:
26518 return NULL;
26519 }
26520
26521
26522 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26523 PyObject *resultobj = 0;
26524 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26525 bool result;
26526 void *argp1 = 0 ;
26527 int res1 = 0 ;
26528 PyObject *swig_obj[1] ;
26529
26530 if (!args) SWIG_fail;
26531 swig_obj[0] = args;
26532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26533 if (!SWIG_IsOK(res1)) {
26534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
26535 }
26536 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26537 {
26538 PyThreadState* __tstate = wxPyBeginAllowThreads();
26539 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
26540 wxPyEndAllowThreads(__tstate);
26541 if (PyErr_Occurred()) SWIG_fail;
26542 }
26543 {
26544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26545 }
26546 return resultobj;
26547 fail:
26548 return NULL;
26549 }
26550
26551
26552 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26553 PyObject *obj;
26554 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26555 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
26556 return SWIG_Py_Void();
26557 }
26558
26559 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26560 return SWIG_Python_InitShadowInstance(args);
26561 }
26562
26563 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26564 PyObject *resultobj = 0;
26565 wxNavigationKeyEvent *result = 0 ;
26566
26567 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
26568 {
26569 PyThreadState* __tstate = wxPyBeginAllowThreads();
26570 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
26571 wxPyEndAllowThreads(__tstate);
26572 if (PyErr_Occurred()) SWIG_fail;
26573 }
26574 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
26575 return resultobj;
26576 fail:
26577 return NULL;
26578 }
26579
26580
26581 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26582 PyObject *resultobj = 0;
26583 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26584 bool result;
26585 void *argp1 = 0 ;
26586 int res1 = 0 ;
26587 PyObject *swig_obj[1] ;
26588
26589 if (!args) SWIG_fail;
26590 swig_obj[0] = args;
26591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26592 if (!SWIG_IsOK(res1)) {
26593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26594 }
26595 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26596 {
26597 PyThreadState* __tstate = wxPyBeginAllowThreads();
26598 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
26599 wxPyEndAllowThreads(__tstate);
26600 if (PyErr_Occurred()) SWIG_fail;
26601 }
26602 {
26603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26604 }
26605 return resultobj;
26606 fail:
26607 return NULL;
26608 }
26609
26610
26611 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26612 PyObject *resultobj = 0;
26613 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26614 bool arg2 ;
26615 void *argp1 = 0 ;
26616 int res1 = 0 ;
26617 bool val2 ;
26618 int ecode2 = 0 ;
26619 PyObject * obj0 = 0 ;
26620 PyObject * obj1 = 0 ;
26621 char * kwnames[] = {
26622 (char *) "self",(char *) "forward", NULL
26623 };
26624
26625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
26626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26627 if (!SWIG_IsOK(res1)) {
26628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26629 }
26630 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26631 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26632 if (!SWIG_IsOK(ecode2)) {
26633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
26634 }
26635 arg2 = static_cast< bool >(val2);
26636 {
26637 PyThreadState* __tstate = wxPyBeginAllowThreads();
26638 (arg1)->SetDirection(arg2);
26639 wxPyEndAllowThreads(__tstate);
26640 if (PyErr_Occurred()) SWIG_fail;
26641 }
26642 resultobj = SWIG_Py_Void();
26643 return resultobj;
26644 fail:
26645 return NULL;
26646 }
26647
26648
26649 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26650 PyObject *resultobj = 0;
26651 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26652 bool result;
26653 void *argp1 = 0 ;
26654 int res1 = 0 ;
26655 PyObject *swig_obj[1] ;
26656
26657 if (!args) SWIG_fail;
26658 swig_obj[0] = args;
26659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26660 if (!SWIG_IsOK(res1)) {
26661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26662 }
26663 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26664 {
26665 PyThreadState* __tstate = wxPyBeginAllowThreads();
26666 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26667 wxPyEndAllowThreads(__tstate);
26668 if (PyErr_Occurred()) SWIG_fail;
26669 }
26670 {
26671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26672 }
26673 return resultobj;
26674 fail:
26675 return NULL;
26676 }
26677
26678
26679 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26680 PyObject *resultobj = 0;
26681 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26682 bool arg2 ;
26683 void *argp1 = 0 ;
26684 int res1 = 0 ;
26685 bool val2 ;
26686 int ecode2 = 0 ;
26687 PyObject * obj0 = 0 ;
26688 PyObject * obj1 = 0 ;
26689 char * kwnames[] = {
26690 (char *) "self",(char *) "ischange", NULL
26691 };
26692
26693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26695 if (!SWIG_IsOK(res1)) {
26696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26697 }
26698 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26699 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26700 if (!SWIG_IsOK(ecode2)) {
26701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26702 }
26703 arg2 = static_cast< bool >(val2);
26704 {
26705 PyThreadState* __tstate = wxPyBeginAllowThreads();
26706 (arg1)->SetWindowChange(arg2);
26707 wxPyEndAllowThreads(__tstate);
26708 if (PyErr_Occurred()) SWIG_fail;
26709 }
26710 resultobj = SWIG_Py_Void();
26711 return resultobj;
26712 fail:
26713 return NULL;
26714 }
26715
26716
26717 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26718 PyObject *resultobj = 0;
26719 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26720 bool result;
26721 void *argp1 = 0 ;
26722 int res1 = 0 ;
26723 PyObject *swig_obj[1] ;
26724
26725 if (!args) SWIG_fail;
26726 swig_obj[0] = args;
26727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26728 if (!SWIG_IsOK(res1)) {
26729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26730 }
26731 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26732 {
26733 PyThreadState* __tstate = wxPyBeginAllowThreads();
26734 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26735 wxPyEndAllowThreads(__tstate);
26736 if (PyErr_Occurred()) SWIG_fail;
26737 }
26738 {
26739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26740 }
26741 return resultobj;
26742 fail:
26743 return NULL;
26744 }
26745
26746
26747 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26748 PyObject *resultobj = 0;
26749 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26750 bool arg2 ;
26751 void *argp1 = 0 ;
26752 int res1 = 0 ;
26753 bool val2 ;
26754 int ecode2 = 0 ;
26755 PyObject * obj0 = 0 ;
26756 PyObject * obj1 = 0 ;
26757 char * kwnames[] = {
26758 (char *) "self",(char *) "bIs", NULL
26759 };
26760
26761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26763 if (!SWIG_IsOK(res1)) {
26764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26765 }
26766 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26767 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26768 if (!SWIG_IsOK(ecode2)) {
26769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26770 }
26771 arg2 = static_cast< bool >(val2);
26772 {
26773 PyThreadState* __tstate = wxPyBeginAllowThreads();
26774 (arg1)->SetFromTab(arg2);
26775 wxPyEndAllowThreads(__tstate);
26776 if (PyErr_Occurred()) SWIG_fail;
26777 }
26778 resultobj = SWIG_Py_Void();
26779 return resultobj;
26780 fail:
26781 return NULL;
26782 }
26783
26784
26785 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26786 PyObject *resultobj = 0;
26787 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26788 long arg2 ;
26789 void *argp1 = 0 ;
26790 int res1 = 0 ;
26791 long val2 ;
26792 int ecode2 = 0 ;
26793 PyObject * obj0 = 0 ;
26794 PyObject * obj1 = 0 ;
26795 char * kwnames[] = {
26796 (char *) "self",(char *) "flags", NULL
26797 };
26798
26799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26801 if (!SWIG_IsOK(res1)) {
26802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26803 }
26804 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26805 ecode2 = SWIG_AsVal_long(obj1, &val2);
26806 if (!SWIG_IsOK(ecode2)) {
26807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26808 }
26809 arg2 = static_cast< long >(val2);
26810 {
26811 PyThreadState* __tstate = wxPyBeginAllowThreads();
26812 (arg1)->SetFlags(arg2);
26813 wxPyEndAllowThreads(__tstate);
26814 if (PyErr_Occurred()) SWIG_fail;
26815 }
26816 resultobj = SWIG_Py_Void();
26817 return resultobj;
26818 fail:
26819 return NULL;
26820 }
26821
26822
26823 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26824 PyObject *resultobj = 0;
26825 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26826 wxWindow *result = 0 ;
26827 void *argp1 = 0 ;
26828 int res1 = 0 ;
26829 PyObject *swig_obj[1] ;
26830
26831 if (!args) SWIG_fail;
26832 swig_obj[0] = args;
26833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26834 if (!SWIG_IsOK(res1)) {
26835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26836 }
26837 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26838 {
26839 PyThreadState* __tstate = wxPyBeginAllowThreads();
26840 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26841 wxPyEndAllowThreads(__tstate);
26842 if (PyErr_Occurred()) SWIG_fail;
26843 }
26844 {
26845 resultobj = wxPyMake_wxObject(result, (bool)0);
26846 }
26847 return resultobj;
26848 fail:
26849 return NULL;
26850 }
26851
26852
26853 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26854 PyObject *resultobj = 0;
26855 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26856 wxWindow *arg2 = (wxWindow *) 0 ;
26857 void *argp1 = 0 ;
26858 int res1 = 0 ;
26859 void *argp2 = 0 ;
26860 int res2 = 0 ;
26861 PyObject * obj0 = 0 ;
26862 PyObject * obj1 = 0 ;
26863 char * kwnames[] = {
26864 (char *) "self",(char *) "win", NULL
26865 };
26866
26867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26869 if (!SWIG_IsOK(res1)) {
26870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26871 }
26872 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26873 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26874 if (!SWIG_IsOK(res2)) {
26875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26876 }
26877 arg2 = reinterpret_cast< wxWindow * >(argp2);
26878 {
26879 PyThreadState* __tstate = wxPyBeginAllowThreads();
26880 (arg1)->SetCurrentFocus(arg2);
26881 wxPyEndAllowThreads(__tstate);
26882 if (PyErr_Occurred()) SWIG_fail;
26883 }
26884 resultobj = SWIG_Py_Void();
26885 return resultobj;
26886 fail:
26887 return NULL;
26888 }
26889
26890
26891 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26892 PyObject *obj;
26893 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26894 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26895 return SWIG_Py_Void();
26896 }
26897
26898 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26899 return SWIG_Python_InitShadowInstance(args);
26900 }
26901
26902 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26903 PyObject *resultobj = 0;
26904 wxWindow *arg1 = (wxWindow *) NULL ;
26905 wxWindowCreateEvent *result = 0 ;
26906 void *argp1 = 0 ;
26907 int res1 = 0 ;
26908 PyObject * obj0 = 0 ;
26909 char * kwnames[] = {
26910 (char *) "win", NULL
26911 };
26912
26913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26914 if (obj0) {
26915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26916 if (!SWIG_IsOK(res1)) {
26917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26918 }
26919 arg1 = reinterpret_cast< wxWindow * >(argp1);
26920 }
26921 {
26922 PyThreadState* __tstate = wxPyBeginAllowThreads();
26923 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26924 wxPyEndAllowThreads(__tstate);
26925 if (PyErr_Occurred()) SWIG_fail;
26926 }
26927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26928 return resultobj;
26929 fail:
26930 return NULL;
26931 }
26932
26933
26934 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26935 PyObject *resultobj = 0;
26936 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26937 wxWindow *result = 0 ;
26938 void *argp1 = 0 ;
26939 int res1 = 0 ;
26940 PyObject *swig_obj[1] ;
26941
26942 if (!args) SWIG_fail;
26943 swig_obj[0] = args;
26944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26945 if (!SWIG_IsOK(res1)) {
26946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26947 }
26948 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26949 {
26950 PyThreadState* __tstate = wxPyBeginAllowThreads();
26951 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26952 wxPyEndAllowThreads(__tstate);
26953 if (PyErr_Occurred()) SWIG_fail;
26954 }
26955 {
26956 resultobj = wxPyMake_wxObject(result, (bool)0);
26957 }
26958 return resultobj;
26959 fail:
26960 return NULL;
26961 }
26962
26963
26964 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26965 PyObject *obj;
26966 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26967 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26968 return SWIG_Py_Void();
26969 }
26970
26971 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26972 return SWIG_Python_InitShadowInstance(args);
26973 }
26974
26975 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26976 PyObject *resultobj = 0;
26977 wxWindow *arg1 = (wxWindow *) NULL ;
26978 wxWindowDestroyEvent *result = 0 ;
26979 void *argp1 = 0 ;
26980 int res1 = 0 ;
26981 PyObject * obj0 = 0 ;
26982 char * kwnames[] = {
26983 (char *) "win", NULL
26984 };
26985
26986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26987 if (obj0) {
26988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26989 if (!SWIG_IsOK(res1)) {
26990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26991 }
26992 arg1 = reinterpret_cast< wxWindow * >(argp1);
26993 }
26994 {
26995 PyThreadState* __tstate = wxPyBeginAllowThreads();
26996 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26997 wxPyEndAllowThreads(__tstate);
26998 if (PyErr_Occurred()) SWIG_fail;
26999 }
27000 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
27001 return resultobj;
27002 fail:
27003 return NULL;
27004 }
27005
27006
27007 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27008 PyObject *resultobj = 0;
27009 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
27010 wxWindow *result = 0 ;
27011 void *argp1 = 0 ;
27012 int res1 = 0 ;
27013 PyObject *swig_obj[1] ;
27014
27015 if (!args) SWIG_fail;
27016 swig_obj[0] = args;
27017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
27018 if (!SWIG_IsOK(res1)) {
27019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
27020 }
27021 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
27022 {
27023 PyThreadState* __tstate = wxPyBeginAllowThreads();
27024 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
27025 wxPyEndAllowThreads(__tstate);
27026 if (PyErr_Occurred()) SWIG_fail;
27027 }
27028 {
27029 resultobj = wxPyMake_wxObject(result, (bool)0);
27030 }
27031 return resultobj;
27032 fail:
27033 return NULL;
27034 }
27035
27036
27037 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27038 PyObject *obj;
27039 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27040 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
27041 return SWIG_Py_Void();
27042 }
27043
27044 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27045 return SWIG_Python_InitShadowInstance(args);
27046 }
27047
27048 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27049 PyObject *resultobj = 0;
27050 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27051 int arg2 = (int) 0 ;
27052 wxPoint const &arg3_defvalue = wxDefaultPosition ;
27053 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
27054 wxContextMenuEvent *result = 0 ;
27055 int val1 ;
27056 int ecode1 = 0 ;
27057 int val2 ;
27058 int ecode2 = 0 ;
27059 wxPoint temp3 ;
27060 PyObject * obj0 = 0 ;
27061 PyObject * obj1 = 0 ;
27062 PyObject * obj2 = 0 ;
27063 char * kwnames[] = {
27064 (char *) "type",(char *) "winid",(char *) "pt", NULL
27065 };
27066
27067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27068 if (obj0) {
27069 ecode1 = SWIG_AsVal_int(obj0, &val1);
27070 if (!SWIG_IsOK(ecode1)) {
27071 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27072 }
27073 arg1 = static_cast< wxEventType >(val1);
27074 }
27075 if (obj1) {
27076 ecode2 = SWIG_AsVal_int(obj1, &val2);
27077 if (!SWIG_IsOK(ecode2)) {
27078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
27079 }
27080 arg2 = static_cast< int >(val2);
27081 }
27082 if (obj2) {
27083 {
27084 arg3 = &temp3;
27085 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
27086 }
27087 }
27088 {
27089 PyThreadState* __tstate = wxPyBeginAllowThreads();
27090 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
27091 wxPyEndAllowThreads(__tstate);
27092 if (PyErr_Occurred()) SWIG_fail;
27093 }
27094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
27095 return resultobj;
27096 fail:
27097 return NULL;
27098 }
27099
27100
27101 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27102 PyObject *resultobj = 0;
27103 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
27104 wxPoint *result = 0 ;
27105 void *argp1 = 0 ;
27106 int res1 = 0 ;
27107 PyObject *swig_obj[1] ;
27108
27109 if (!args) SWIG_fail;
27110 swig_obj[0] = args;
27111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
27112 if (!SWIG_IsOK(res1)) {
27113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
27114 }
27115 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
27116 {
27117 PyThreadState* __tstate = wxPyBeginAllowThreads();
27118 {
27119 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
27120 result = (wxPoint *) &_result_ref;
27121 }
27122 wxPyEndAllowThreads(__tstate);
27123 if (PyErr_Occurred()) SWIG_fail;
27124 }
27125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
27126 return resultobj;
27127 fail:
27128 return NULL;
27129 }
27130
27131
27132 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27133 PyObject *resultobj = 0;
27134 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
27135 wxPoint *arg2 = 0 ;
27136 void *argp1 = 0 ;
27137 int res1 = 0 ;
27138 wxPoint temp2 ;
27139 PyObject * obj0 = 0 ;
27140 PyObject * obj1 = 0 ;
27141 char * kwnames[] = {
27142 (char *) "self",(char *) "pos", NULL
27143 };
27144
27145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
27146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
27147 if (!SWIG_IsOK(res1)) {
27148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
27149 }
27150 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
27151 {
27152 arg2 = &temp2;
27153 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
27154 }
27155 {
27156 PyThreadState* __tstate = wxPyBeginAllowThreads();
27157 (arg1)->SetPosition((wxPoint const &)*arg2);
27158 wxPyEndAllowThreads(__tstate);
27159 if (PyErr_Occurred()) SWIG_fail;
27160 }
27161 resultobj = SWIG_Py_Void();
27162 return resultobj;
27163 fail:
27164 return NULL;
27165 }
27166
27167
27168 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27169 PyObject *obj;
27170 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27171 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
27172 return SWIG_Py_Void();
27173 }
27174
27175 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27176 return SWIG_Python_InitShadowInstance(args);
27177 }
27178
27179 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27180 PyObject *resultobj = 0;
27181 wxIdleEvent *result = 0 ;
27182
27183 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
27184 {
27185 PyThreadState* __tstate = wxPyBeginAllowThreads();
27186 result = (wxIdleEvent *)new wxIdleEvent();
27187 wxPyEndAllowThreads(__tstate);
27188 if (PyErr_Occurred()) SWIG_fail;
27189 }
27190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
27191 return resultobj;
27192 fail:
27193 return NULL;
27194 }
27195
27196
27197 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27198 PyObject *resultobj = 0;
27199 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
27200 bool arg2 = (bool) true ;
27201 void *argp1 = 0 ;
27202 int res1 = 0 ;
27203 bool val2 ;
27204 int ecode2 = 0 ;
27205 PyObject * obj0 = 0 ;
27206 PyObject * obj1 = 0 ;
27207 char * kwnames[] = {
27208 (char *) "self",(char *) "needMore", NULL
27209 };
27210
27211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
27212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
27213 if (!SWIG_IsOK(res1)) {
27214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
27215 }
27216 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
27217 if (obj1) {
27218 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27219 if (!SWIG_IsOK(ecode2)) {
27220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
27221 }
27222 arg2 = static_cast< bool >(val2);
27223 }
27224 {
27225 PyThreadState* __tstate = wxPyBeginAllowThreads();
27226 (arg1)->RequestMore(arg2);
27227 wxPyEndAllowThreads(__tstate);
27228 if (PyErr_Occurred()) SWIG_fail;
27229 }
27230 resultobj = SWIG_Py_Void();
27231 return resultobj;
27232 fail:
27233 return NULL;
27234 }
27235
27236
27237 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27238 PyObject *resultobj = 0;
27239 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
27240 bool result;
27241 void *argp1 = 0 ;
27242 int res1 = 0 ;
27243 PyObject *swig_obj[1] ;
27244
27245 if (!args) SWIG_fail;
27246 swig_obj[0] = args;
27247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
27248 if (!SWIG_IsOK(res1)) {
27249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
27250 }
27251 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
27252 {
27253 PyThreadState* __tstate = wxPyBeginAllowThreads();
27254 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
27255 wxPyEndAllowThreads(__tstate);
27256 if (PyErr_Occurred()) SWIG_fail;
27257 }
27258 {
27259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27260 }
27261 return resultobj;
27262 fail:
27263 return NULL;
27264 }
27265
27266
27267 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27268 PyObject *resultobj = 0;
27269 wxIdleMode arg1 ;
27270 int val1 ;
27271 int ecode1 = 0 ;
27272 PyObject * obj0 = 0 ;
27273 char * kwnames[] = {
27274 (char *) "mode", NULL
27275 };
27276
27277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
27278 ecode1 = SWIG_AsVal_int(obj0, &val1);
27279 if (!SWIG_IsOK(ecode1)) {
27280 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
27281 }
27282 arg1 = static_cast< wxIdleMode >(val1);
27283 {
27284 PyThreadState* __tstate = wxPyBeginAllowThreads();
27285 wxIdleEvent::SetMode(arg1);
27286 wxPyEndAllowThreads(__tstate);
27287 if (PyErr_Occurred()) SWIG_fail;
27288 }
27289 resultobj = SWIG_Py_Void();
27290 return resultobj;
27291 fail:
27292 return NULL;
27293 }
27294
27295
27296 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27297 PyObject *resultobj = 0;
27298 wxIdleMode result;
27299
27300 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
27301 {
27302 PyThreadState* __tstate = wxPyBeginAllowThreads();
27303 result = (wxIdleMode)wxIdleEvent::GetMode();
27304 wxPyEndAllowThreads(__tstate);
27305 if (PyErr_Occurred()) SWIG_fail;
27306 }
27307 resultobj = SWIG_From_int(static_cast< int >(result));
27308 return resultobj;
27309 fail:
27310 return NULL;
27311 }
27312
27313
27314 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27315 PyObject *resultobj = 0;
27316 wxWindow *arg1 = (wxWindow *) 0 ;
27317 bool result;
27318 void *argp1 = 0 ;
27319 int res1 = 0 ;
27320 PyObject * obj0 = 0 ;
27321 char * kwnames[] = {
27322 (char *) "win", NULL
27323 };
27324
27325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
27326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27327 if (!SWIG_IsOK(res1)) {
27328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
27329 }
27330 arg1 = reinterpret_cast< wxWindow * >(argp1);
27331 {
27332 PyThreadState* __tstate = wxPyBeginAllowThreads();
27333 result = (bool)wxIdleEvent::CanSend(arg1);
27334 wxPyEndAllowThreads(__tstate);
27335 if (PyErr_Occurred()) SWIG_fail;
27336 }
27337 {
27338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27339 }
27340 return resultobj;
27341 fail:
27342 return NULL;
27343 }
27344
27345
27346 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27347 PyObject *obj;
27348 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27349 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
27350 return SWIG_Py_Void();
27351 }
27352
27353 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27354 return SWIG_Python_InitShadowInstance(args);
27355 }
27356
27357 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27358 PyObject *resultobj = 0;
27359 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27360 int arg2 = (int) 0 ;
27361 wxClipboardTextEvent *result = 0 ;
27362 int val1 ;
27363 int ecode1 = 0 ;
27364 int val2 ;
27365 int ecode2 = 0 ;
27366 PyObject * obj0 = 0 ;
27367 PyObject * obj1 = 0 ;
27368 char * kwnames[] = {
27369 (char *) "type",(char *) "winid", NULL
27370 };
27371
27372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27373 if (obj0) {
27374 ecode1 = SWIG_AsVal_int(obj0, &val1);
27375 if (!SWIG_IsOK(ecode1)) {
27376 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27377 }
27378 arg1 = static_cast< wxEventType >(val1);
27379 }
27380 if (obj1) {
27381 ecode2 = SWIG_AsVal_int(obj1, &val2);
27382 if (!SWIG_IsOK(ecode2)) {
27383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
27384 }
27385 arg2 = static_cast< int >(val2);
27386 }
27387 {
27388 PyThreadState* __tstate = wxPyBeginAllowThreads();
27389 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
27390 wxPyEndAllowThreads(__tstate);
27391 if (PyErr_Occurred()) SWIG_fail;
27392 }
27393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
27394 return resultobj;
27395 fail:
27396 return NULL;
27397 }
27398
27399
27400 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27401 PyObject *obj;
27402 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27403 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
27404 return SWIG_Py_Void();
27405 }
27406
27407 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27408 return SWIG_Python_InitShadowInstance(args);
27409 }
27410
27411 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27412 PyObject *resultobj = 0;
27413 int arg1 = (int) 0 ;
27414 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
27415 wxPyEvent *result = 0 ;
27416 int val1 ;
27417 int ecode1 = 0 ;
27418 int val2 ;
27419 int ecode2 = 0 ;
27420 PyObject * obj0 = 0 ;
27421 PyObject * obj1 = 0 ;
27422 char * kwnames[] = {
27423 (char *) "winid",(char *) "eventType", NULL
27424 };
27425
27426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27427 if (obj0) {
27428 ecode1 = SWIG_AsVal_int(obj0, &val1);
27429 if (!SWIG_IsOK(ecode1)) {
27430 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
27431 }
27432 arg1 = static_cast< int >(val1);
27433 }
27434 if (obj1) {
27435 ecode2 = SWIG_AsVal_int(obj1, &val2);
27436 if (!SWIG_IsOK(ecode2)) {
27437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
27438 }
27439 arg2 = static_cast< wxEventType >(val2);
27440 }
27441 {
27442 PyThreadState* __tstate = wxPyBeginAllowThreads();
27443 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
27444 wxPyEndAllowThreads(__tstate);
27445 if (PyErr_Occurred()) SWIG_fail;
27446 }
27447 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
27448 return resultobj;
27449 fail:
27450 return NULL;
27451 }
27452
27453
27454 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27455 PyObject *resultobj = 0;
27456 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27457 void *argp1 = 0 ;
27458 int res1 = 0 ;
27459 PyObject *swig_obj[1] ;
27460
27461 if (!args) SWIG_fail;
27462 swig_obj[0] = args;
27463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
27464 if (!SWIG_IsOK(res1)) {
27465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27466 }
27467 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27468 {
27469 PyThreadState* __tstate = wxPyBeginAllowThreads();
27470 delete arg1;
27471
27472 wxPyEndAllowThreads(__tstate);
27473 if (PyErr_Occurred()) SWIG_fail;
27474 }
27475 resultobj = SWIG_Py_Void();
27476 return resultobj;
27477 fail:
27478 return NULL;
27479 }
27480
27481
27482 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27483 PyObject *resultobj = 0;
27484 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27485 PyObject *arg2 = (PyObject *) 0 ;
27486 void *argp1 = 0 ;
27487 int res1 = 0 ;
27488 PyObject * obj0 = 0 ;
27489 PyObject * obj1 = 0 ;
27490 char * kwnames[] = {
27491 (char *) "self",(char *) "self", NULL
27492 };
27493
27494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27496 if (!SWIG_IsOK(res1)) {
27497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27498 }
27499 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27500 arg2 = obj1;
27501 {
27502 PyThreadState* __tstate = wxPyBeginAllowThreads();
27503 (arg1)->SetSelf(arg2);
27504 wxPyEndAllowThreads(__tstate);
27505 if (PyErr_Occurred()) SWIG_fail;
27506 }
27507 resultobj = SWIG_Py_Void();
27508 return resultobj;
27509 fail:
27510 return NULL;
27511 }
27512
27513
27514 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27515 PyObject *resultobj = 0;
27516 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27517 PyObject *result = 0 ;
27518 void *argp1 = 0 ;
27519 int res1 = 0 ;
27520 PyObject *swig_obj[1] ;
27521
27522 if (!args) SWIG_fail;
27523 swig_obj[0] = args;
27524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27525 if (!SWIG_IsOK(res1)) {
27526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27527 }
27528 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27529 {
27530 PyThreadState* __tstate = wxPyBeginAllowThreads();
27531 result = (PyObject *)(arg1)->GetSelf();
27532 wxPyEndAllowThreads(__tstate);
27533 if (PyErr_Occurred()) SWIG_fail;
27534 }
27535 resultobj = result;
27536 return resultobj;
27537 fail:
27538 return NULL;
27539 }
27540
27541
27542 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27543 PyObject *obj;
27544 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27545 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
27546 return SWIG_Py_Void();
27547 }
27548
27549 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27550 return SWIG_Python_InitShadowInstance(args);
27551 }
27552
27553 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27554 PyObject *resultobj = 0;
27555 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27556 int arg2 = (int) 0 ;
27557 wxPyCommandEvent *result = 0 ;
27558 int val1 ;
27559 int ecode1 = 0 ;
27560 int val2 ;
27561 int ecode2 = 0 ;
27562 PyObject * obj0 = 0 ;
27563 PyObject * obj1 = 0 ;
27564 char * kwnames[] = {
27565 (char *) "eventType",(char *) "id", NULL
27566 };
27567
27568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27569 if (obj0) {
27570 ecode1 = SWIG_AsVal_int(obj0, &val1);
27571 if (!SWIG_IsOK(ecode1)) {
27572 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27573 }
27574 arg1 = static_cast< wxEventType >(val1);
27575 }
27576 if (obj1) {
27577 ecode2 = SWIG_AsVal_int(obj1, &val2);
27578 if (!SWIG_IsOK(ecode2)) {
27579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
27580 }
27581 arg2 = static_cast< int >(val2);
27582 }
27583 {
27584 PyThreadState* __tstate = wxPyBeginAllowThreads();
27585 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
27586 wxPyEndAllowThreads(__tstate);
27587 if (PyErr_Occurred()) SWIG_fail;
27588 }
27589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
27590 return resultobj;
27591 fail:
27592 return NULL;
27593 }
27594
27595
27596 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27597 PyObject *resultobj = 0;
27598 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27599 void *argp1 = 0 ;
27600 int res1 = 0 ;
27601 PyObject *swig_obj[1] ;
27602
27603 if (!args) SWIG_fail;
27604 swig_obj[0] = args;
27605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
27606 if (!SWIG_IsOK(res1)) {
27607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27608 }
27609 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27610 {
27611 PyThreadState* __tstate = wxPyBeginAllowThreads();
27612 delete arg1;
27613
27614 wxPyEndAllowThreads(__tstate);
27615 if (PyErr_Occurred()) SWIG_fail;
27616 }
27617 resultobj = SWIG_Py_Void();
27618 return resultobj;
27619 fail:
27620 return NULL;
27621 }
27622
27623
27624 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27625 PyObject *resultobj = 0;
27626 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27627 PyObject *arg2 = (PyObject *) 0 ;
27628 void *argp1 = 0 ;
27629 int res1 = 0 ;
27630 PyObject * obj0 = 0 ;
27631 PyObject * obj1 = 0 ;
27632 char * kwnames[] = {
27633 (char *) "self",(char *) "self", NULL
27634 };
27635
27636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27638 if (!SWIG_IsOK(res1)) {
27639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27640 }
27641 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27642 arg2 = obj1;
27643 {
27644 PyThreadState* __tstate = wxPyBeginAllowThreads();
27645 (arg1)->SetSelf(arg2);
27646 wxPyEndAllowThreads(__tstate);
27647 if (PyErr_Occurred()) SWIG_fail;
27648 }
27649 resultobj = SWIG_Py_Void();
27650 return resultobj;
27651 fail:
27652 return NULL;
27653 }
27654
27655
27656 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27657 PyObject *resultobj = 0;
27658 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27659 PyObject *result = 0 ;
27660 void *argp1 = 0 ;
27661 int res1 = 0 ;
27662 PyObject *swig_obj[1] ;
27663
27664 if (!args) SWIG_fail;
27665 swig_obj[0] = args;
27666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27667 if (!SWIG_IsOK(res1)) {
27668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27669 }
27670 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27671 {
27672 PyThreadState* __tstate = wxPyBeginAllowThreads();
27673 result = (PyObject *)(arg1)->GetSelf();
27674 wxPyEndAllowThreads(__tstate);
27675 if (PyErr_Occurred()) SWIG_fail;
27676 }
27677 resultobj = result;
27678 return resultobj;
27679 fail:
27680 return NULL;
27681 }
27682
27683
27684 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27685 PyObject *obj;
27686 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27687 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27688 return SWIG_Py_Void();
27689 }
27690
27691 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27692 return SWIG_Python_InitShadowInstance(args);
27693 }
27694
27695 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27696 PyObject *resultobj = 0;
27697 wxWindow *arg1 = (wxWindow *) 0 ;
27698 wxDateTime *arg2 = 0 ;
27699 wxEventType arg3 ;
27700 wxDateEvent *result = 0 ;
27701 void *argp1 = 0 ;
27702 int res1 = 0 ;
27703 void *argp2 = 0 ;
27704 int res2 = 0 ;
27705 int val3 ;
27706 int ecode3 = 0 ;
27707 PyObject * obj0 = 0 ;
27708 PyObject * obj1 = 0 ;
27709 PyObject * obj2 = 0 ;
27710 char * kwnames[] = {
27711 (char *) "win",(char *) "dt",(char *) "type", NULL
27712 };
27713
27714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27716 if (!SWIG_IsOK(res1)) {
27717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27718 }
27719 arg1 = reinterpret_cast< wxWindow * >(argp1);
27720 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27721 if (!SWIG_IsOK(res2)) {
27722 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27723 }
27724 if (!argp2) {
27725 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27726 }
27727 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27728 ecode3 = SWIG_AsVal_int(obj2, &val3);
27729 if (!SWIG_IsOK(ecode3)) {
27730 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27731 }
27732 arg3 = static_cast< wxEventType >(val3);
27733 {
27734 PyThreadState* __tstate = wxPyBeginAllowThreads();
27735 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27736 wxPyEndAllowThreads(__tstate);
27737 if (PyErr_Occurred()) SWIG_fail;
27738 }
27739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27740 return resultobj;
27741 fail:
27742 return NULL;
27743 }
27744
27745
27746 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27747 PyObject *resultobj = 0;
27748 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27749 wxDateTime *result = 0 ;
27750 void *argp1 = 0 ;
27751 int res1 = 0 ;
27752 PyObject *swig_obj[1] ;
27753
27754 if (!args) SWIG_fail;
27755 swig_obj[0] = args;
27756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27757 if (!SWIG_IsOK(res1)) {
27758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27759 }
27760 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27761 {
27762 PyThreadState* __tstate = wxPyBeginAllowThreads();
27763 {
27764 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27765 result = (wxDateTime *) &_result_ref;
27766 }
27767 wxPyEndAllowThreads(__tstate);
27768 if (PyErr_Occurred()) SWIG_fail;
27769 }
27770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27771 return resultobj;
27772 fail:
27773 return NULL;
27774 }
27775
27776
27777 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27778 PyObject *resultobj = 0;
27779 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27780 wxDateTime *arg2 = 0 ;
27781 void *argp1 = 0 ;
27782 int res1 = 0 ;
27783 void *argp2 = 0 ;
27784 int res2 = 0 ;
27785 PyObject * obj0 = 0 ;
27786 PyObject * obj1 = 0 ;
27787 char * kwnames[] = {
27788 (char *) "self",(char *) "date", NULL
27789 };
27790
27791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27793 if (!SWIG_IsOK(res1)) {
27794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27795 }
27796 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27797 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27798 if (!SWIG_IsOK(res2)) {
27799 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27800 }
27801 if (!argp2) {
27802 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27803 }
27804 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27805 {
27806 PyThreadState* __tstate = wxPyBeginAllowThreads();
27807 (arg1)->SetDate((wxDateTime const &)*arg2);
27808 wxPyEndAllowThreads(__tstate);
27809 if (PyErr_Occurred()) SWIG_fail;
27810 }
27811 resultobj = SWIG_Py_Void();
27812 return resultobj;
27813 fail:
27814 return NULL;
27815 }
27816
27817
27818 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27819 PyObject *obj;
27820 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27821 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27822 return SWIG_Py_Void();
27823 }
27824
27825 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27826 return SWIG_Python_InitShadowInstance(args);
27827 }
27828
27829 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27830 PyObject *resultobj = 0;
27831 wxPyApp *result = 0 ;
27832
27833 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27834 {
27835 PyThreadState* __tstate = wxPyBeginAllowThreads();
27836 result = (wxPyApp *)new_wxPyApp();
27837 wxPyEndAllowThreads(__tstate);
27838 if (PyErr_Occurred()) SWIG_fail;
27839 }
27840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27841 return resultobj;
27842 fail:
27843 return NULL;
27844 }
27845
27846
27847 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27848 PyObject *resultobj = 0;
27849 wxPyApp *arg1 = (wxPyApp *) 0 ;
27850 void *argp1 = 0 ;
27851 int res1 = 0 ;
27852 PyObject *swig_obj[1] ;
27853
27854 if (!args) SWIG_fail;
27855 swig_obj[0] = args;
27856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27857 if (!SWIG_IsOK(res1)) {
27858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27859 }
27860 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27861 {
27862 PyThreadState* __tstate = wxPyBeginAllowThreads();
27863 delete arg1;
27864
27865 wxPyEndAllowThreads(__tstate);
27866 if (PyErr_Occurred()) SWIG_fail;
27867 }
27868 resultobj = SWIG_Py_Void();
27869 return resultobj;
27870 fail:
27871 return NULL;
27872 }
27873
27874
27875 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27876 PyObject *resultobj = 0;
27877 wxPyApp *arg1 = (wxPyApp *) 0 ;
27878 PyObject *arg2 = (PyObject *) 0 ;
27879 PyObject *arg3 = (PyObject *) 0 ;
27880 bool arg4 ;
27881 void *argp1 = 0 ;
27882 int res1 = 0 ;
27883 bool val4 ;
27884 int ecode4 = 0 ;
27885 PyObject * obj0 = 0 ;
27886 PyObject * obj1 = 0 ;
27887 PyObject * obj2 = 0 ;
27888 PyObject * obj3 = 0 ;
27889 char * kwnames[] = {
27890 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27891 };
27892
27893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27895 if (!SWIG_IsOK(res1)) {
27896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27897 }
27898 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27899 arg2 = obj1;
27900 arg3 = obj2;
27901 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27902 if (!SWIG_IsOK(ecode4)) {
27903 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27904 }
27905 arg4 = static_cast< bool >(val4);
27906 {
27907 PyThreadState* __tstate = wxPyBeginAllowThreads();
27908 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27909 wxPyEndAllowThreads(__tstate);
27910 if (PyErr_Occurred()) SWIG_fail;
27911 }
27912 resultobj = SWIG_Py_Void();
27913 return resultobj;
27914 fail:
27915 return NULL;
27916 }
27917
27918
27919 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27920 PyObject *resultobj = 0;
27921 wxPyApp *arg1 = (wxPyApp *) 0 ;
27922 wxString result;
27923 void *argp1 = 0 ;
27924 int res1 = 0 ;
27925 PyObject *swig_obj[1] ;
27926
27927 if (!args) SWIG_fail;
27928 swig_obj[0] = args;
27929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27930 if (!SWIG_IsOK(res1)) {
27931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27932 }
27933 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27934 {
27935 PyThreadState* __tstate = wxPyBeginAllowThreads();
27936 result = ((wxPyApp const *)arg1)->GetAppName();
27937 wxPyEndAllowThreads(__tstate);
27938 if (PyErr_Occurred()) SWIG_fail;
27939 }
27940 {
27941 #if wxUSE_UNICODE
27942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27943 #else
27944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27945 #endif
27946 }
27947 return resultobj;
27948 fail:
27949 return NULL;
27950 }
27951
27952
27953 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27954 PyObject *resultobj = 0;
27955 wxPyApp *arg1 = (wxPyApp *) 0 ;
27956 wxString *arg2 = 0 ;
27957 void *argp1 = 0 ;
27958 int res1 = 0 ;
27959 bool temp2 = false ;
27960 PyObject * obj0 = 0 ;
27961 PyObject * obj1 = 0 ;
27962 char * kwnames[] = {
27963 (char *) "self",(char *) "name", NULL
27964 };
27965
27966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27968 if (!SWIG_IsOK(res1)) {
27969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27970 }
27971 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27972 {
27973 arg2 = wxString_in_helper(obj1);
27974 if (arg2 == NULL) SWIG_fail;
27975 temp2 = true;
27976 }
27977 {
27978 PyThreadState* __tstate = wxPyBeginAllowThreads();
27979 (arg1)->SetAppName((wxString const &)*arg2);
27980 wxPyEndAllowThreads(__tstate);
27981 if (PyErr_Occurred()) SWIG_fail;
27982 }
27983 resultobj = SWIG_Py_Void();
27984 {
27985 if (temp2)
27986 delete arg2;
27987 }
27988 return resultobj;
27989 fail:
27990 {
27991 if (temp2)
27992 delete arg2;
27993 }
27994 return NULL;
27995 }
27996
27997
27998 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27999 PyObject *resultobj = 0;
28000 wxPyApp *arg1 = (wxPyApp *) 0 ;
28001 wxString result;
28002 void *argp1 = 0 ;
28003 int res1 = 0 ;
28004 PyObject *swig_obj[1] ;
28005
28006 if (!args) SWIG_fail;
28007 swig_obj[0] = args;
28008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28009 if (!SWIG_IsOK(res1)) {
28010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28011 }
28012 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28013 {
28014 PyThreadState* __tstate = wxPyBeginAllowThreads();
28015 result = ((wxPyApp const *)arg1)->GetClassName();
28016 wxPyEndAllowThreads(__tstate);
28017 if (PyErr_Occurred()) SWIG_fail;
28018 }
28019 {
28020 #if wxUSE_UNICODE
28021 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28022 #else
28023 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28024 #endif
28025 }
28026 return resultobj;
28027 fail:
28028 return NULL;
28029 }
28030
28031
28032 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28033 PyObject *resultobj = 0;
28034 wxPyApp *arg1 = (wxPyApp *) 0 ;
28035 wxString *arg2 = 0 ;
28036 void *argp1 = 0 ;
28037 int res1 = 0 ;
28038 bool temp2 = false ;
28039 PyObject * obj0 = 0 ;
28040 PyObject * obj1 = 0 ;
28041 char * kwnames[] = {
28042 (char *) "self",(char *) "name", NULL
28043 };
28044
28045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
28046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28047 if (!SWIG_IsOK(res1)) {
28048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
28049 }
28050 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28051 {
28052 arg2 = wxString_in_helper(obj1);
28053 if (arg2 == NULL) SWIG_fail;
28054 temp2 = true;
28055 }
28056 {
28057 PyThreadState* __tstate = wxPyBeginAllowThreads();
28058 (arg1)->SetClassName((wxString const &)*arg2);
28059 wxPyEndAllowThreads(__tstate);
28060 if (PyErr_Occurred()) SWIG_fail;
28061 }
28062 resultobj = SWIG_Py_Void();
28063 {
28064 if (temp2)
28065 delete arg2;
28066 }
28067 return resultobj;
28068 fail:
28069 {
28070 if (temp2)
28071 delete arg2;
28072 }
28073 return NULL;
28074 }
28075
28076
28077 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28078 PyObject *resultobj = 0;
28079 wxPyApp *arg1 = (wxPyApp *) 0 ;
28080 wxString *result = 0 ;
28081 void *argp1 = 0 ;
28082 int res1 = 0 ;
28083 PyObject *swig_obj[1] ;
28084
28085 if (!args) SWIG_fail;
28086 swig_obj[0] = args;
28087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28088 if (!SWIG_IsOK(res1)) {
28089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28090 }
28091 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28092 {
28093 PyThreadState* __tstate = wxPyBeginAllowThreads();
28094 {
28095 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
28096 result = (wxString *) &_result_ref;
28097 }
28098 wxPyEndAllowThreads(__tstate);
28099 if (PyErr_Occurred()) SWIG_fail;
28100 }
28101 {
28102 #if wxUSE_UNICODE
28103 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
28104 #else
28105 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
28106 #endif
28107 }
28108 return resultobj;
28109 fail:
28110 return NULL;
28111 }
28112
28113
28114 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28115 PyObject *resultobj = 0;
28116 wxPyApp *arg1 = (wxPyApp *) 0 ;
28117 wxString *arg2 = 0 ;
28118 void *argp1 = 0 ;
28119 int res1 = 0 ;
28120 bool temp2 = false ;
28121 PyObject * obj0 = 0 ;
28122 PyObject * obj1 = 0 ;
28123 char * kwnames[] = {
28124 (char *) "self",(char *) "name", NULL
28125 };
28126
28127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
28128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28129 if (!SWIG_IsOK(res1)) {
28130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
28131 }
28132 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28133 {
28134 arg2 = wxString_in_helper(obj1);
28135 if (arg2 == NULL) SWIG_fail;
28136 temp2 = true;
28137 }
28138 {
28139 PyThreadState* __tstate = wxPyBeginAllowThreads();
28140 (arg1)->SetVendorName((wxString const &)*arg2);
28141 wxPyEndAllowThreads(__tstate);
28142 if (PyErr_Occurred()) SWIG_fail;
28143 }
28144 resultobj = SWIG_Py_Void();
28145 {
28146 if (temp2)
28147 delete arg2;
28148 }
28149 return resultobj;
28150 fail:
28151 {
28152 if (temp2)
28153 delete arg2;
28154 }
28155 return NULL;
28156 }
28157
28158
28159 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28160 PyObject *resultobj = 0;
28161 wxPyApp *arg1 = (wxPyApp *) 0 ;
28162 wxAppTraits *result = 0 ;
28163 void *argp1 = 0 ;
28164 int res1 = 0 ;
28165 PyObject *swig_obj[1] ;
28166
28167 if (!args) SWIG_fail;
28168 swig_obj[0] = args;
28169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28170 if (!SWIG_IsOK(res1)) {
28171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
28172 }
28173 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28174 {
28175 PyThreadState* __tstate = wxPyBeginAllowThreads();
28176 result = (wxAppTraits *)(arg1)->GetTraits();
28177 wxPyEndAllowThreads(__tstate);
28178 if (PyErr_Occurred()) SWIG_fail;
28179 }
28180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
28181 return resultobj;
28182 fail:
28183 return NULL;
28184 }
28185
28186
28187 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28188 PyObject *resultobj = 0;
28189 wxPyApp *arg1 = (wxPyApp *) 0 ;
28190 void *argp1 = 0 ;
28191 int res1 = 0 ;
28192 PyObject *swig_obj[1] ;
28193
28194 if (!args) SWIG_fail;
28195 swig_obj[0] = args;
28196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28197 if (!SWIG_IsOK(res1)) {
28198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28199 }
28200 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28201 {
28202 PyThreadState* __tstate = wxPyBeginAllowThreads();
28203 (arg1)->ProcessPendingEvents();
28204 wxPyEndAllowThreads(__tstate);
28205 if (PyErr_Occurred()) SWIG_fail;
28206 }
28207 resultobj = SWIG_Py_Void();
28208 return resultobj;
28209 fail:
28210 return NULL;
28211 }
28212
28213
28214 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28215 PyObject *resultobj = 0;
28216 wxPyApp *arg1 = (wxPyApp *) 0 ;
28217 bool arg2 = (bool) false ;
28218 bool result;
28219 void *argp1 = 0 ;
28220 int res1 = 0 ;
28221 bool val2 ;
28222 int ecode2 = 0 ;
28223 PyObject * obj0 = 0 ;
28224 PyObject * obj1 = 0 ;
28225 char * kwnames[] = {
28226 (char *) "self",(char *) "onlyIfNeeded", NULL
28227 };
28228
28229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
28230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28231 if (!SWIG_IsOK(res1)) {
28232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
28233 }
28234 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28235 if (obj1) {
28236 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28237 if (!SWIG_IsOK(ecode2)) {
28238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
28239 }
28240 arg2 = static_cast< bool >(val2);
28241 }
28242 {
28243 PyThreadState* __tstate = wxPyBeginAllowThreads();
28244 result = (bool)(arg1)->Yield(arg2);
28245 wxPyEndAllowThreads(__tstate);
28246 if (PyErr_Occurred()) SWIG_fail;
28247 }
28248 {
28249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28250 }
28251 return resultobj;
28252 fail:
28253 return NULL;
28254 }
28255
28256
28257 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28258 PyObject *resultobj = 0;
28259 wxPyApp *arg1 = (wxPyApp *) 0 ;
28260 void *argp1 = 0 ;
28261 int res1 = 0 ;
28262 PyObject *swig_obj[1] ;
28263
28264 if (!args) SWIG_fail;
28265 swig_obj[0] = args;
28266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28267 if (!SWIG_IsOK(res1)) {
28268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28269 }
28270 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28271 {
28272 PyThreadState* __tstate = wxPyBeginAllowThreads();
28273 (arg1)->WakeUpIdle();
28274 wxPyEndAllowThreads(__tstate);
28275 if (PyErr_Occurred()) SWIG_fail;
28276 }
28277 resultobj = SWIG_Py_Void();
28278 return resultobj;
28279 fail:
28280 return NULL;
28281 }
28282
28283
28284 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28285 PyObject *resultobj = 0;
28286 bool result;
28287
28288 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
28289 {
28290 PyThreadState* __tstate = wxPyBeginAllowThreads();
28291 result = (bool)wxPyApp::IsMainLoopRunning();
28292 wxPyEndAllowThreads(__tstate);
28293 if (PyErr_Occurred()) SWIG_fail;
28294 }
28295 {
28296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28297 }
28298 return resultobj;
28299 fail:
28300 return NULL;
28301 }
28302
28303
28304 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28305 PyObject *resultobj = 0;
28306 wxPyApp *arg1 = (wxPyApp *) 0 ;
28307 int result;
28308 void *argp1 = 0 ;
28309 int res1 = 0 ;
28310 PyObject *swig_obj[1] ;
28311
28312 if (!args) SWIG_fail;
28313 swig_obj[0] = args;
28314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28315 if (!SWIG_IsOK(res1)) {
28316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
28317 }
28318 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28319 {
28320 PyThreadState* __tstate = wxPyBeginAllowThreads();
28321 result = (int)(arg1)->MainLoop();
28322 wxPyEndAllowThreads(__tstate);
28323 if (PyErr_Occurred()) SWIG_fail;
28324 }
28325 resultobj = SWIG_From_int(static_cast< int >(result));
28326 return resultobj;
28327 fail:
28328 return NULL;
28329 }
28330
28331
28332 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28333 PyObject *resultobj = 0;
28334 wxPyApp *arg1 = (wxPyApp *) 0 ;
28335 void *argp1 = 0 ;
28336 int res1 = 0 ;
28337 PyObject *swig_obj[1] ;
28338
28339 if (!args) SWIG_fail;
28340 swig_obj[0] = args;
28341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28342 if (!SWIG_IsOK(res1)) {
28343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
28344 }
28345 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28346 {
28347 PyThreadState* __tstate = wxPyBeginAllowThreads();
28348 (arg1)->Exit();
28349 wxPyEndAllowThreads(__tstate);
28350 if (PyErr_Occurred()) SWIG_fail;
28351 }
28352 resultobj = SWIG_Py_Void();
28353 return resultobj;
28354 fail:
28355 return NULL;
28356 }
28357
28358
28359 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28360 PyObject *resultobj = 0;
28361 wxPyApp *arg1 = (wxPyApp *) 0 ;
28362 wxLayoutDirection result;
28363 void *argp1 = 0 ;
28364 int res1 = 0 ;
28365 PyObject *swig_obj[1] ;
28366
28367 if (!args) SWIG_fail;
28368 swig_obj[0] = args;
28369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28370 if (!SWIG_IsOK(res1)) {
28371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28372 }
28373 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28374 {
28375 PyThreadState* __tstate = wxPyBeginAllowThreads();
28376 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
28377 wxPyEndAllowThreads(__tstate);
28378 if (PyErr_Occurred()) SWIG_fail;
28379 }
28380 resultobj = SWIG_From_int(static_cast< int >(result));
28381 return resultobj;
28382 fail:
28383 return NULL;
28384 }
28385
28386
28387 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28388 PyObject *resultobj = 0;
28389 wxPyApp *arg1 = (wxPyApp *) 0 ;
28390 void *argp1 = 0 ;
28391 int res1 = 0 ;
28392 PyObject *swig_obj[1] ;
28393
28394 if (!args) SWIG_fail;
28395 swig_obj[0] = args;
28396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28397 if (!SWIG_IsOK(res1)) {
28398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
28399 }
28400 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28401 {
28402 PyThreadState* __tstate = wxPyBeginAllowThreads();
28403 (arg1)->ExitMainLoop();
28404 wxPyEndAllowThreads(__tstate);
28405 if (PyErr_Occurred()) SWIG_fail;
28406 }
28407 resultobj = SWIG_Py_Void();
28408 return resultobj;
28409 fail:
28410 return NULL;
28411 }
28412
28413
28414 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28415 PyObject *resultobj = 0;
28416 wxPyApp *arg1 = (wxPyApp *) 0 ;
28417 bool result;
28418 void *argp1 = 0 ;
28419 int res1 = 0 ;
28420 PyObject *swig_obj[1] ;
28421
28422 if (!args) SWIG_fail;
28423 swig_obj[0] = args;
28424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28425 if (!SWIG_IsOK(res1)) {
28426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
28427 }
28428 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28429 {
28430 PyThreadState* __tstate = wxPyBeginAllowThreads();
28431 result = (bool)(arg1)->Pending();
28432 wxPyEndAllowThreads(__tstate);
28433 if (PyErr_Occurred()) SWIG_fail;
28434 }
28435 {
28436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28437 }
28438 return resultobj;
28439 fail:
28440 return NULL;
28441 }
28442
28443
28444 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28445 PyObject *resultobj = 0;
28446 wxPyApp *arg1 = (wxPyApp *) 0 ;
28447 bool result;
28448 void *argp1 = 0 ;
28449 int res1 = 0 ;
28450 PyObject *swig_obj[1] ;
28451
28452 if (!args) SWIG_fail;
28453 swig_obj[0] = args;
28454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28455 if (!SWIG_IsOK(res1)) {
28456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
28457 }
28458 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28459 {
28460 PyThreadState* __tstate = wxPyBeginAllowThreads();
28461 result = (bool)(arg1)->Dispatch();
28462 wxPyEndAllowThreads(__tstate);
28463 if (PyErr_Occurred()) SWIG_fail;
28464 }
28465 {
28466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28467 }
28468 return resultobj;
28469 fail:
28470 return NULL;
28471 }
28472
28473
28474 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28475 PyObject *resultobj = 0;
28476 wxPyApp *arg1 = (wxPyApp *) 0 ;
28477 bool result;
28478 void *argp1 = 0 ;
28479 int res1 = 0 ;
28480 PyObject *swig_obj[1] ;
28481
28482 if (!args) SWIG_fail;
28483 swig_obj[0] = args;
28484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28485 if (!SWIG_IsOK(res1)) {
28486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28487 }
28488 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28489 {
28490 PyThreadState* __tstate = wxPyBeginAllowThreads();
28491 result = (bool)(arg1)->ProcessIdle();
28492 wxPyEndAllowThreads(__tstate);
28493 if (PyErr_Occurred()) SWIG_fail;
28494 }
28495 {
28496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28497 }
28498 return resultobj;
28499 fail:
28500 return NULL;
28501 }
28502
28503
28504 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28505 PyObject *resultobj = 0;
28506 wxPyApp *arg1 = (wxPyApp *) 0 ;
28507 wxWindow *arg2 = (wxWindow *) 0 ;
28508 wxIdleEvent *arg3 = 0 ;
28509 bool result;
28510 void *argp1 = 0 ;
28511 int res1 = 0 ;
28512 void *argp2 = 0 ;
28513 int res2 = 0 ;
28514 void *argp3 = 0 ;
28515 int res3 = 0 ;
28516 PyObject * obj0 = 0 ;
28517 PyObject * obj1 = 0 ;
28518 PyObject * obj2 = 0 ;
28519 char * kwnames[] = {
28520 (char *) "self",(char *) "win",(char *) "event", NULL
28521 };
28522
28523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28525 if (!SWIG_IsOK(res1)) {
28526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28527 }
28528 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28529 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28530 if (!SWIG_IsOK(res2)) {
28531 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
28532 }
28533 arg2 = reinterpret_cast< wxWindow * >(argp2);
28534 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
28535 if (!SWIG_IsOK(res3)) {
28536 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28537 }
28538 if (!argp3) {
28539 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28540 }
28541 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
28542 {
28543 PyThreadState* __tstate = wxPyBeginAllowThreads();
28544 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
28545 wxPyEndAllowThreads(__tstate);
28546 if (PyErr_Occurred()) SWIG_fail;
28547 }
28548 {
28549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28550 }
28551 return resultobj;
28552 fail:
28553 return NULL;
28554 }
28555
28556
28557 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28558 PyObject *resultobj = 0;
28559 wxPyApp *arg1 = (wxPyApp *) 0 ;
28560 bool result;
28561 void *argp1 = 0 ;
28562 int res1 = 0 ;
28563 PyObject *swig_obj[1] ;
28564
28565 if (!args) SWIG_fail;
28566 swig_obj[0] = args;
28567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28568 if (!SWIG_IsOK(res1)) {
28569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28570 }
28571 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28572 {
28573 PyThreadState* __tstate = wxPyBeginAllowThreads();
28574 result = (bool)((wxPyApp const *)arg1)->IsActive();
28575 wxPyEndAllowThreads(__tstate);
28576 if (PyErr_Occurred()) SWIG_fail;
28577 }
28578 {
28579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28580 }
28581 return resultobj;
28582 fail:
28583 return NULL;
28584 }
28585
28586
28587 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28588 PyObject *resultobj = 0;
28589 wxPyApp *arg1 = (wxPyApp *) 0 ;
28590 wxWindow *arg2 = (wxWindow *) 0 ;
28591 void *argp1 = 0 ;
28592 int res1 = 0 ;
28593 void *argp2 = 0 ;
28594 int res2 = 0 ;
28595 PyObject * obj0 = 0 ;
28596 PyObject * obj1 = 0 ;
28597 char * kwnames[] = {
28598 (char *) "self",(char *) "win", NULL
28599 };
28600
28601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28603 if (!SWIG_IsOK(res1)) {
28604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
28605 }
28606 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28608 if (!SWIG_IsOK(res2)) {
28609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28610 }
28611 arg2 = reinterpret_cast< wxWindow * >(argp2);
28612 {
28613 PyThreadState* __tstate = wxPyBeginAllowThreads();
28614 (arg1)->SetTopWindow(arg2);
28615 wxPyEndAllowThreads(__tstate);
28616 if (PyErr_Occurred()) SWIG_fail;
28617 }
28618 resultobj = SWIG_Py_Void();
28619 return resultobj;
28620 fail:
28621 return NULL;
28622 }
28623
28624
28625 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28626 PyObject *resultobj = 0;
28627 wxPyApp *arg1 = (wxPyApp *) 0 ;
28628 wxWindow *result = 0 ;
28629 void *argp1 = 0 ;
28630 int res1 = 0 ;
28631 PyObject *swig_obj[1] ;
28632
28633 if (!args) SWIG_fail;
28634 swig_obj[0] = args;
28635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28636 if (!SWIG_IsOK(res1)) {
28637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28638 }
28639 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28640 {
28641 PyThreadState* __tstate = wxPyBeginAllowThreads();
28642 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
28643 wxPyEndAllowThreads(__tstate);
28644 if (PyErr_Occurred()) SWIG_fail;
28645 }
28646 {
28647 resultobj = wxPyMake_wxObject(result, (bool)0);
28648 }
28649 return resultobj;
28650 fail:
28651 return NULL;
28652 }
28653
28654
28655 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28656 PyObject *resultobj = 0;
28657 wxPyApp *arg1 = (wxPyApp *) 0 ;
28658 bool arg2 ;
28659 void *argp1 = 0 ;
28660 int res1 = 0 ;
28661 bool val2 ;
28662 int ecode2 = 0 ;
28663 PyObject * obj0 = 0 ;
28664 PyObject * obj1 = 0 ;
28665 char * kwnames[] = {
28666 (char *) "self",(char *) "flag", NULL
28667 };
28668
28669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
28670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28671 if (!SWIG_IsOK(res1)) {
28672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28673 }
28674 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28675 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28676 if (!SWIG_IsOK(ecode2)) {
28677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28678 }
28679 arg2 = static_cast< bool >(val2);
28680 {
28681 PyThreadState* __tstate = wxPyBeginAllowThreads();
28682 (arg1)->SetExitOnFrameDelete(arg2);
28683 wxPyEndAllowThreads(__tstate);
28684 if (PyErr_Occurred()) SWIG_fail;
28685 }
28686 resultobj = SWIG_Py_Void();
28687 return resultobj;
28688 fail:
28689 return NULL;
28690 }
28691
28692
28693 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28694 PyObject *resultobj = 0;
28695 wxPyApp *arg1 = (wxPyApp *) 0 ;
28696 bool result;
28697 void *argp1 = 0 ;
28698 int res1 = 0 ;
28699 PyObject *swig_obj[1] ;
28700
28701 if (!args) SWIG_fail;
28702 swig_obj[0] = args;
28703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28704 if (!SWIG_IsOK(res1)) {
28705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28706 }
28707 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28708 {
28709 PyThreadState* __tstate = wxPyBeginAllowThreads();
28710 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28711 wxPyEndAllowThreads(__tstate);
28712 if (PyErr_Occurred()) SWIG_fail;
28713 }
28714 {
28715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28716 }
28717 return resultobj;
28718 fail:
28719 return NULL;
28720 }
28721
28722
28723 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28724 PyObject *resultobj = 0;
28725 wxPyApp *arg1 = (wxPyApp *) 0 ;
28726 bool arg2 ;
28727 void *argp1 = 0 ;
28728 int res1 = 0 ;
28729 bool val2 ;
28730 int ecode2 = 0 ;
28731 PyObject * obj0 = 0 ;
28732 PyObject * obj1 = 0 ;
28733 char * kwnames[] = {
28734 (char *) "self",(char *) "flag", NULL
28735 };
28736
28737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28739 if (!SWIG_IsOK(res1)) {
28740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28741 }
28742 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28743 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28744 if (!SWIG_IsOK(ecode2)) {
28745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28746 }
28747 arg2 = static_cast< bool >(val2);
28748 {
28749 PyThreadState* __tstate = wxPyBeginAllowThreads();
28750 (arg1)->SetUseBestVisual(arg2);
28751 wxPyEndAllowThreads(__tstate);
28752 if (PyErr_Occurred()) SWIG_fail;
28753 }
28754 resultobj = SWIG_Py_Void();
28755 return resultobj;
28756 fail:
28757 return NULL;
28758 }
28759
28760
28761 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28762 PyObject *resultobj = 0;
28763 wxPyApp *arg1 = (wxPyApp *) 0 ;
28764 bool result;
28765 void *argp1 = 0 ;
28766 int res1 = 0 ;
28767 PyObject *swig_obj[1] ;
28768
28769 if (!args) SWIG_fail;
28770 swig_obj[0] = args;
28771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28772 if (!SWIG_IsOK(res1)) {
28773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28774 }
28775 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28776 {
28777 PyThreadState* __tstate = wxPyBeginAllowThreads();
28778 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28779 wxPyEndAllowThreads(__tstate);
28780 if (PyErr_Occurred()) SWIG_fail;
28781 }
28782 {
28783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28784 }
28785 return resultobj;
28786 fail:
28787 return NULL;
28788 }
28789
28790
28791 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28792 PyObject *resultobj = 0;
28793 wxPyApp *arg1 = (wxPyApp *) 0 ;
28794 int arg2 ;
28795 void *argp1 = 0 ;
28796 int res1 = 0 ;
28797 int val2 ;
28798 int ecode2 = 0 ;
28799 PyObject * obj0 = 0 ;
28800 PyObject * obj1 = 0 ;
28801 char * kwnames[] = {
28802 (char *) "self",(char *) "mode", NULL
28803 };
28804
28805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28807 if (!SWIG_IsOK(res1)) {
28808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28809 }
28810 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28811 ecode2 = SWIG_AsVal_int(obj1, &val2);
28812 if (!SWIG_IsOK(ecode2)) {
28813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28814 }
28815 arg2 = static_cast< int >(val2);
28816 {
28817 PyThreadState* __tstate = wxPyBeginAllowThreads();
28818 (arg1)->SetPrintMode(arg2);
28819 wxPyEndAllowThreads(__tstate);
28820 if (PyErr_Occurred()) SWIG_fail;
28821 }
28822 resultobj = SWIG_Py_Void();
28823 return resultobj;
28824 fail:
28825 return NULL;
28826 }
28827
28828
28829 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28830 PyObject *resultobj = 0;
28831 wxPyApp *arg1 = (wxPyApp *) 0 ;
28832 int result;
28833 void *argp1 = 0 ;
28834 int res1 = 0 ;
28835 PyObject *swig_obj[1] ;
28836
28837 if (!args) SWIG_fail;
28838 swig_obj[0] = args;
28839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28840 if (!SWIG_IsOK(res1)) {
28841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28842 }
28843 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28844 {
28845 PyThreadState* __tstate = wxPyBeginAllowThreads();
28846 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28847 wxPyEndAllowThreads(__tstate);
28848 if (PyErr_Occurred()) SWIG_fail;
28849 }
28850 resultobj = SWIG_From_int(static_cast< int >(result));
28851 return resultobj;
28852 fail:
28853 return NULL;
28854 }
28855
28856
28857 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28858 PyObject *resultobj = 0;
28859 wxPyApp *arg1 = (wxPyApp *) 0 ;
28860 int arg2 ;
28861 void *argp1 = 0 ;
28862 int res1 = 0 ;
28863 int val2 ;
28864 int ecode2 = 0 ;
28865 PyObject * obj0 = 0 ;
28866 PyObject * obj1 = 0 ;
28867 char * kwnames[] = {
28868 (char *) "self",(char *) "mode", NULL
28869 };
28870
28871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28873 if (!SWIG_IsOK(res1)) {
28874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28875 }
28876 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28877 ecode2 = SWIG_AsVal_int(obj1, &val2);
28878 if (!SWIG_IsOK(ecode2)) {
28879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28880 }
28881 arg2 = static_cast< int >(val2);
28882 {
28883 PyThreadState* __tstate = wxPyBeginAllowThreads();
28884 (arg1)->SetAssertMode(arg2);
28885 wxPyEndAllowThreads(__tstate);
28886 if (PyErr_Occurred()) SWIG_fail;
28887 }
28888 resultobj = SWIG_Py_Void();
28889 return resultobj;
28890 fail:
28891 return NULL;
28892 }
28893
28894
28895 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28896 PyObject *resultobj = 0;
28897 wxPyApp *arg1 = (wxPyApp *) 0 ;
28898 int result;
28899 void *argp1 = 0 ;
28900 int res1 = 0 ;
28901 PyObject *swig_obj[1] ;
28902
28903 if (!args) SWIG_fail;
28904 swig_obj[0] = args;
28905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28906 if (!SWIG_IsOK(res1)) {
28907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28908 }
28909 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28910 {
28911 PyThreadState* __tstate = wxPyBeginAllowThreads();
28912 result = (int)(arg1)->GetAssertMode();
28913 wxPyEndAllowThreads(__tstate);
28914 if (PyErr_Occurred()) SWIG_fail;
28915 }
28916 resultobj = SWIG_From_int(static_cast< int >(result));
28917 return resultobj;
28918 fail:
28919 return NULL;
28920 }
28921
28922
28923 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28924 PyObject *resultobj = 0;
28925 bool result;
28926
28927 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28928 {
28929 PyThreadState* __tstate = wxPyBeginAllowThreads();
28930 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28931 wxPyEndAllowThreads(__tstate);
28932 if (PyErr_Occurred()) SWIG_fail;
28933 }
28934 {
28935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28936 }
28937 return resultobj;
28938 fail:
28939 return NULL;
28940 }
28941
28942
28943 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28944 PyObject *resultobj = 0;
28945 long result;
28946
28947 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28948 {
28949 PyThreadState* __tstate = wxPyBeginAllowThreads();
28950 result = (long)wxPyApp::GetMacAboutMenuItemId();
28951 wxPyEndAllowThreads(__tstate);
28952 if (PyErr_Occurred()) SWIG_fail;
28953 }
28954 resultobj = SWIG_From_long(static_cast< long >(result));
28955 return resultobj;
28956 fail:
28957 return NULL;
28958 }
28959
28960
28961 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28962 PyObject *resultobj = 0;
28963 long result;
28964
28965 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28966 {
28967 PyThreadState* __tstate = wxPyBeginAllowThreads();
28968 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28969 wxPyEndAllowThreads(__tstate);
28970 if (PyErr_Occurred()) SWIG_fail;
28971 }
28972 resultobj = SWIG_From_long(static_cast< long >(result));
28973 return resultobj;
28974 fail:
28975 return NULL;
28976 }
28977
28978
28979 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28980 PyObject *resultobj = 0;
28981 long result;
28982
28983 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28984 {
28985 PyThreadState* __tstate = wxPyBeginAllowThreads();
28986 result = (long)wxPyApp::GetMacExitMenuItemId();
28987 wxPyEndAllowThreads(__tstate);
28988 if (PyErr_Occurred()) SWIG_fail;
28989 }
28990 resultobj = SWIG_From_long(static_cast< long >(result));
28991 return resultobj;
28992 fail:
28993 return NULL;
28994 }
28995
28996
28997 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28998 PyObject *resultobj = 0;
28999 wxString result;
29000
29001 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
29002 {
29003 PyThreadState* __tstate = wxPyBeginAllowThreads();
29004 result = wxPyApp::GetMacHelpMenuTitleName();
29005 wxPyEndAllowThreads(__tstate);
29006 if (PyErr_Occurred()) SWIG_fail;
29007 }
29008 {
29009 #if wxUSE_UNICODE
29010 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29011 #else
29012 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29013 #endif
29014 }
29015 return resultobj;
29016 fail:
29017 return NULL;
29018 }
29019
29020
29021 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29022 PyObject *resultobj = 0;
29023 bool arg1 ;
29024 bool val1 ;
29025 int ecode1 = 0 ;
29026 PyObject * obj0 = 0 ;
29027 char * kwnames[] = {
29028 (char *) "val", NULL
29029 };
29030
29031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
29032 ecode1 = SWIG_AsVal_bool(obj0, &val1);
29033 if (!SWIG_IsOK(ecode1)) {
29034 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
29035 }
29036 arg1 = static_cast< bool >(val1);
29037 {
29038 PyThreadState* __tstate = wxPyBeginAllowThreads();
29039 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
29040 wxPyEndAllowThreads(__tstate);
29041 if (PyErr_Occurred()) SWIG_fail;
29042 }
29043 resultobj = SWIG_Py_Void();
29044 return resultobj;
29045 fail:
29046 return NULL;
29047 }
29048
29049
29050 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29051 PyObject *resultobj = 0;
29052 long arg1 ;
29053 long val1 ;
29054 int ecode1 = 0 ;
29055 PyObject * obj0 = 0 ;
29056 char * kwnames[] = {
29057 (char *) "val", NULL
29058 };
29059
29060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
29061 ecode1 = SWIG_AsVal_long(obj0, &val1);
29062 if (!SWIG_IsOK(ecode1)) {
29063 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
29064 }
29065 arg1 = static_cast< long >(val1);
29066 {
29067 PyThreadState* __tstate = wxPyBeginAllowThreads();
29068 wxPyApp::SetMacAboutMenuItemId(arg1);
29069 wxPyEndAllowThreads(__tstate);
29070 if (PyErr_Occurred()) SWIG_fail;
29071 }
29072 resultobj = SWIG_Py_Void();
29073 return resultobj;
29074 fail:
29075 return NULL;
29076 }
29077
29078
29079 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29080 PyObject *resultobj = 0;
29081 long arg1 ;
29082 long val1 ;
29083 int ecode1 = 0 ;
29084 PyObject * obj0 = 0 ;
29085 char * kwnames[] = {
29086 (char *) "val", NULL
29087 };
29088
29089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
29090 ecode1 = SWIG_AsVal_long(obj0, &val1);
29091 if (!SWIG_IsOK(ecode1)) {
29092 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
29093 }
29094 arg1 = static_cast< long >(val1);
29095 {
29096 PyThreadState* __tstate = wxPyBeginAllowThreads();
29097 wxPyApp::SetMacPreferencesMenuItemId(arg1);
29098 wxPyEndAllowThreads(__tstate);
29099 if (PyErr_Occurred()) SWIG_fail;
29100 }
29101 resultobj = SWIG_Py_Void();
29102 return resultobj;
29103 fail:
29104 return NULL;
29105 }
29106
29107
29108 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29109 PyObject *resultobj = 0;
29110 long arg1 ;
29111 long val1 ;
29112 int ecode1 = 0 ;
29113 PyObject * obj0 = 0 ;
29114 char * kwnames[] = {
29115 (char *) "val", NULL
29116 };
29117
29118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
29119 ecode1 = SWIG_AsVal_long(obj0, &val1);
29120 if (!SWIG_IsOK(ecode1)) {
29121 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
29122 }
29123 arg1 = static_cast< long >(val1);
29124 {
29125 PyThreadState* __tstate = wxPyBeginAllowThreads();
29126 wxPyApp::SetMacExitMenuItemId(arg1);
29127 wxPyEndAllowThreads(__tstate);
29128 if (PyErr_Occurred()) SWIG_fail;
29129 }
29130 resultobj = SWIG_Py_Void();
29131 return resultobj;
29132 fail:
29133 return NULL;
29134 }
29135
29136
29137 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29138 PyObject *resultobj = 0;
29139 wxString *arg1 = 0 ;
29140 bool temp1 = false ;
29141 PyObject * obj0 = 0 ;
29142 char * kwnames[] = {
29143 (char *) "val", NULL
29144 };
29145
29146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
29147 {
29148 arg1 = wxString_in_helper(obj0);
29149 if (arg1 == NULL) SWIG_fail;
29150 temp1 = true;
29151 }
29152 {
29153 PyThreadState* __tstate = wxPyBeginAllowThreads();
29154 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
29155 wxPyEndAllowThreads(__tstate);
29156 if (PyErr_Occurred()) SWIG_fail;
29157 }
29158 resultobj = SWIG_Py_Void();
29159 {
29160 if (temp1)
29161 delete arg1;
29162 }
29163 return resultobj;
29164 fail:
29165 {
29166 if (temp1)
29167 delete arg1;
29168 }
29169 return NULL;
29170 }
29171
29172
29173 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29174 PyObject *resultobj = 0;
29175 wxPyApp *arg1 = (wxPyApp *) 0 ;
29176 void *argp1 = 0 ;
29177 int res1 = 0 ;
29178 PyObject *swig_obj[1] ;
29179
29180 if (!args) SWIG_fail;
29181 swig_obj[0] = args;
29182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29183 if (!SWIG_IsOK(res1)) {
29184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
29185 }
29186 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29187 {
29188 PyThreadState* __tstate = wxPyBeginAllowThreads();
29189 (arg1)->_BootstrapApp();
29190 wxPyEndAllowThreads(__tstate);
29191 if (PyErr_Occurred()) SWIG_fail;
29192 }
29193 resultobj = SWIG_Py_Void();
29194 return resultobj;
29195 fail:
29196 return NULL;
29197 }
29198
29199
29200 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29201 PyObject *resultobj = 0;
29202 int result;
29203
29204 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
29205 {
29206 PyThreadState* __tstate = wxPyBeginAllowThreads();
29207 result = (int)wxPyApp_GetComCtl32Version();
29208 wxPyEndAllowThreads(__tstate);
29209 if (PyErr_Occurred()) SWIG_fail;
29210 }
29211 resultobj = SWIG_From_int(static_cast< int >(result));
29212 return resultobj;
29213 fail:
29214 return NULL;
29215 }
29216
29217
29218 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29219 PyObject *resultobj = 0;
29220 bool result;
29221
29222 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
29223 {
29224 PyThreadState* __tstate = wxPyBeginAllowThreads();
29225 result = (bool)wxPyApp_IsDisplayAvailable();
29226 wxPyEndAllowThreads(__tstate);
29227 if (PyErr_Occurred()) SWIG_fail;
29228 }
29229 {
29230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29231 }
29232 return resultobj;
29233 fail:
29234 return NULL;
29235 }
29236
29237
29238 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29239 PyObject *obj;
29240 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29241 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
29242 return SWIG_Py_Void();
29243 }
29244
29245 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29246 return SWIG_Python_InitShadowInstance(args);
29247 }
29248
29249 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29250 PyObject *resultobj = 0;
29251
29252 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
29253 {
29254 PyThreadState* __tstate = wxPyBeginAllowThreads();
29255 wxExit();
29256 wxPyEndAllowThreads(__tstate);
29257 if (PyErr_Occurred()) SWIG_fail;
29258 }
29259 resultobj = SWIG_Py_Void();
29260 return resultobj;
29261 fail:
29262 return NULL;
29263 }
29264
29265
29266 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29267 PyObject *resultobj = 0;
29268 bool result;
29269
29270 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
29271 {
29272 PyThreadState* __tstate = wxPyBeginAllowThreads();
29273 result = (bool)wxYield();
29274 wxPyEndAllowThreads(__tstate);
29275 if (PyErr_Occurred()) SWIG_fail;
29276 }
29277 {
29278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29279 }
29280 return resultobj;
29281 fail:
29282 return NULL;
29283 }
29284
29285
29286 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29287 PyObject *resultobj = 0;
29288 bool result;
29289
29290 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
29291 {
29292 PyThreadState* __tstate = wxPyBeginAllowThreads();
29293 result = (bool)wxYieldIfNeeded();
29294 wxPyEndAllowThreads(__tstate);
29295 if (PyErr_Occurred()) SWIG_fail;
29296 }
29297 {
29298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29299 }
29300 return resultobj;
29301 fail:
29302 return NULL;
29303 }
29304
29305
29306 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29307 PyObject *resultobj = 0;
29308 wxWindow *arg1 = (wxWindow *) NULL ;
29309 bool arg2 = (bool) false ;
29310 bool result;
29311 void *argp1 = 0 ;
29312 int res1 = 0 ;
29313 bool val2 ;
29314 int ecode2 = 0 ;
29315 PyObject * obj0 = 0 ;
29316 PyObject * obj1 = 0 ;
29317 char * kwnames[] = {
29318 (char *) "win",(char *) "onlyIfNeeded", NULL
29319 };
29320
29321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
29322 if (obj0) {
29323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29324 if (!SWIG_IsOK(res1)) {
29325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
29326 }
29327 arg1 = reinterpret_cast< wxWindow * >(argp1);
29328 }
29329 if (obj1) {
29330 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29331 if (!SWIG_IsOK(ecode2)) {
29332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
29333 }
29334 arg2 = static_cast< bool >(val2);
29335 }
29336 {
29337 PyThreadState* __tstate = wxPyBeginAllowThreads();
29338 result = (bool)wxSafeYield(arg1,arg2);
29339 wxPyEndAllowThreads(__tstate);
29340 if (PyErr_Occurred()) SWIG_fail;
29341 }
29342 {
29343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29344 }
29345 return resultobj;
29346 fail:
29347 return NULL;
29348 }
29349
29350
29351 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29352 PyObject *resultobj = 0;
29353
29354 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
29355 {
29356 PyThreadState* __tstate = wxPyBeginAllowThreads();
29357 wxWakeUpIdle();
29358 wxPyEndAllowThreads(__tstate);
29359 if (PyErr_Occurred()) SWIG_fail;
29360 }
29361 resultobj = SWIG_Py_Void();
29362 return resultobj;
29363 fail:
29364 return NULL;
29365 }
29366
29367
29368 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29369 PyObject *resultobj = 0;
29370 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
29371 wxEvent *arg2 = 0 ;
29372 void *argp1 = 0 ;
29373 int res1 = 0 ;
29374 void *argp2 = 0 ;
29375 int res2 = 0 ;
29376 PyObject * obj0 = 0 ;
29377 PyObject * obj1 = 0 ;
29378 char * kwnames[] = {
29379 (char *) "dest",(char *) "event", NULL
29380 };
29381
29382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
29384 if (!SWIG_IsOK(res1)) {
29385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
29386 }
29387 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
29388 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
29389 if (!SWIG_IsOK(res2)) {
29390 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
29391 }
29392 if (!argp2) {
29393 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
29394 }
29395 arg2 = reinterpret_cast< wxEvent * >(argp2);
29396 {
29397 PyThreadState* __tstate = wxPyBeginAllowThreads();
29398 wxPostEvent(arg1,*arg2);
29399 wxPyEndAllowThreads(__tstate);
29400 if (PyErr_Occurred()) SWIG_fail;
29401 }
29402 resultobj = SWIG_Py_Void();
29403 return resultobj;
29404 fail:
29405 return NULL;
29406 }
29407
29408
29409 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29410 PyObject *resultobj = 0;
29411
29412 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
29413 {
29414 PyThreadState* __tstate = wxPyBeginAllowThreads();
29415 wxApp_CleanUp();
29416 wxPyEndAllowThreads(__tstate);
29417 if (PyErr_Occurred()) SWIG_fail;
29418 }
29419 resultobj = SWIG_Py_Void();
29420 return resultobj;
29421 fail:
29422 return NULL;
29423 }
29424
29425
29426 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29427 PyObject *resultobj = 0;
29428 wxPyApp *result = 0 ;
29429
29430 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
29431 {
29432 PyThreadState* __tstate = wxPyBeginAllowThreads();
29433 result = (wxPyApp *)wxPyGetApp();
29434 wxPyEndAllowThreads(__tstate);
29435 if (PyErr_Occurred()) SWIG_fail;
29436 }
29437 {
29438 resultobj = wxPyMake_wxObject(result, 0);
29439 }
29440 return resultobj;
29441 fail:
29442 return NULL;
29443 }
29444
29445
29446 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29447 PyObject *resultobj = 0;
29448 char *arg1 = (char *) 0 ;
29449 int res1 ;
29450 char *buf1 = 0 ;
29451 int alloc1 = 0 ;
29452 PyObject * obj0 = 0 ;
29453 char * kwnames[] = {
29454 (char *) "encoding", NULL
29455 };
29456
29457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
29458 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
29459 if (!SWIG_IsOK(res1)) {
29460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
29461 }
29462 arg1 = buf1;
29463 {
29464 PyThreadState* __tstate = wxPyBeginAllowThreads();
29465 wxSetDefaultPyEncoding((char const *)arg1);
29466 wxPyEndAllowThreads(__tstate);
29467 if (PyErr_Occurred()) SWIG_fail;
29468 }
29469 resultobj = SWIG_Py_Void();
29470 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29471 return resultobj;
29472 fail:
29473 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29474 return NULL;
29475 }
29476
29477
29478 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29479 PyObject *resultobj = 0;
29480 char *result = 0 ;
29481
29482 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
29483 {
29484 PyThreadState* __tstate = wxPyBeginAllowThreads();
29485 result = (char *)wxGetDefaultPyEncoding();
29486 wxPyEndAllowThreads(__tstate);
29487 if (PyErr_Occurred()) SWIG_fail;
29488 }
29489 resultobj = SWIG_FromCharPtr(result);
29490 return resultobj;
29491 fail:
29492 return NULL;
29493 }
29494
29495
29496 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29497 PyObject *resultobj = 0;
29498 wxEventLoop *result = 0 ;
29499
29500 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
29501 {
29502 PyThreadState* __tstate = wxPyBeginAllowThreads();
29503 result = (wxEventLoop *)new wxEventLoop();
29504 wxPyEndAllowThreads(__tstate);
29505 if (PyErr_Occurred()) SWIG_fail;
29506 }
29507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
29508 return resultobj;
29509 fail:
29510 return NULL;
29511 }
29512
29513
29514 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29515 PyObject *resultobj = 0;
29516 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29517 void *argp1 = 0 ;
29518 int res1 = 0 ;
29519 PyObject *swig_obj[1] ;
29520
29521 if (!args) SWIG_fail;
29522 swig_obj[0] = args;
29523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
29524 if (!SWIG_IsOK(res1)) {
29525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29526 }
29527 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29528 {
29529 PyThreadState* __tstate = wxPyBeginAllowThreads();
29530 delete arg1;
29531
29532 wxPyEndAllowThreads(__tstate);
29533 if (PyErr_Occurred()) SWIG_fail;
29534 }
29535 resultobj = SWIG_Py_Void();
29536 return resultobj;
29537 fail:
29538 return NULL;
29539 }
29540
29541
29542 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29543 PyObject *resultobj = 0;
29544 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29545 int result;
29546 void *argp1 = 0 ;
29547 int res1 = 0 ;
29548 PyObject *swig_obj[1] ;
29549
29550 if (!args) SWIG_fail;
29551 swig_obj[0] = args;
29552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29553 if (!SWIG_IsOK(res1)) {
29554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29555 }
29556 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29557 {
29558 PyThreadState* __tstate = wxPyBeginAllowThreads();
29559 result = (int)(arg1)->Run();
29560 wxPyEndAllowThreads(__tstate);
29561 if (PyErr_Occurred()) SWIG_fail;
29562 }
29563 resultobj = SWIG_From_int(static_cast< int >(result));
29564 return resultobj;
29565 fail:
29566 return NULL;
29567 }
29568
29569
29570 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29571 PyObject *resultobj = 0;
29572 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29573 int arg2 = (int) 0 ;
29574 void *argp1 = 0 ;
29575 int res1 = 0 ;
29576 int val2 ;
29577 int ecode2 = 0 ;
29578 PyObject * obj0 = 0 ;
29579 PyObject * obj1 = 0 ;
29580 char * kwnames[] = {
29581 (char *) "self",(char *) "rc", NULL
29582 };
29583
29584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
29585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29586 if (!SWIG_IsOK(res1)) {
29587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29588 }
29589 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29590 if (obj1) {
29591 ecode2 = SWIG_AsVal_int(obj1, &val2);
29592 if (!SWIG_IsOK(ecode2)) {
29593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
29594 }
29595 arg2 = static_cast< int >(val2);
29596 }
29597 {
29598 PyThreadState* __tstate = wxPyBeginAllowThreads();
29599 (arg1)->Exit(arg2);
29600 wxPyEndAllowThreads(__tstate);
29601 if (PyErr_Occurred()) SWIG_fail;
29602 }
29603 resultobj = SWIG_Py_Void();
29604 return resultobj;
29605 fail:
29606 return NULL;
29607 }
29608
29609
29610 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29611 PyObject *resultobj = 0;
29612 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29613 bool result;
29614 void *argp1 = 0 ;
29615 int res1 = 0 ;
29616 PyObject *swig_obj[1] ;
29617
29618 if (!args) SWIG_fail;
29619 swig_obj[0] = args;
29620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29621 if (!SWIG_IsOK(res1)) {
29622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29623 }
29624 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29625 {
29626 PyThreadState* __tstate = wxPyBeginAllowThreads();
29627 result = (bool)((wxEventLoop const *)arg1)->Pending();
29628 wxPyEndAllowThreads(__tstate);
29629 if (PyErr_Occurred()) SWIG_fail;
29630 }
29631 {
29632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29633 }
29634 return resultobj;
29635 fail:
29636 return NULL;
29637 }
29638
29639
29640 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29641 PyObject *resultobj = 0;
29642 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29643 bool result;
29644 void *argp1 = 0 ;
29645 int res1 = 0 ;
29646 PyObject *swig_obj[1] ;
29647
29648 if (!args) SWIG_fail;
29649 swig_obj[0] = args;
29650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29651 if (!SWIG_IsOK(res1)) {
29652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29653 }
29654 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29655 {
29656 PyThreadState* __tstate = wxPyBeginAllowThreads();
29657 result = (bool)(arg1)->Dispatch();
29658 wxPyEndAllowThreads(__tstate);
29659 if (PyErr_Occurred()) SWIG_fail;
29660 }
29661 {
29662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29663 }
29664 return resultobj;
29665 fail:
29666 return NULL;
29667 }
29668
29669
29670 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29671 PyObject *resultobj = 0;
29672 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29673 bool result;
29674 void *argp1 = 0 ;
29675 int res1 = 0 ;
29676 PyObject *swig_obj[1] ;
29677
29678 if (!args) SWIG_fail;
29679 swig_obj[0] = args;
29680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29681 if (!SWIG_IsOK(res1)) {
29682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29683 }
29684 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29685 {
29686 PyThreadState* __tstate = wxPyBeginAllowThreads();
29687 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29688 wxPyEndAllowThreads(__tstate);
29689 if (PyErr_Occurred()) SWIG_fail;
29690 }
29691 {
29692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29693 }
29694 return resultobj;
29695 fail:
29696 return NULL;
29697 }
29698
29699
29700 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29701 PyObject *resultobj = 0;
29702 wxEventLoop *result = 0 ;
29703
29704 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29705 {
29706 PyThreadState* __tstate = wxPyBeginAllowThreads();
29707 result = (wxEventLoop *)wxEventLoop::GetActive();
29708 wxPyEndAllowThreads(__tstate);
29709 if (PyErr_Occurred()) SWIG_fail;
29710 }
29711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29712 return resultobj;
29713 fail:
29714 return NULL;
29715 }
29716
29717
29718 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29719 PyObject *resultobj = 0;
29720 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29721 void *argp1 = 0 ;
29722 int res1 = 0 ;
29723 PyObject * obj0 = 0 ;
29724 char * kwnames[] = {
29725 (char *) "loop", NULL
29726 };
29727
29728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29730 if (!SWIG_IsOK(res1)) {
29731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29732 }
29733 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29734 {
29735 PyThreadState* __tstate = wxPyBeginAllowThreads();
29736 wxEventLoop::SetActive(arg1);
29737 wxPyEndAllowThreads(__tstate);
29738 if (PyErr_Occurred()) SWIG_fail;
29739 }
29740 resultobj = SWIG_Py_Void();
29741 return resultobj;
29742 fail:
29743 return NULL;
29744 }
29745
29746
29747 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29748 PyObject *obj;
29749 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29750 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29751 return SWIG_Py_Void();
29752 }
29753
29754 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29755 return SWIG_Python_InitShadowInstance(args);
29756 }
29757
29758 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29759 PyObject *resultobj = 0;
29760 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29761 wxEventLoopActivator *result = 0 ;
29762 void *argp1 = 0 ;
29763 int res1 = 0 ;
29764 PyObject * obj0 = 0 ;
29765 char * kwnames[] = {
29766 (char *) "evtLoop", NULL
29767 };
29768
29769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29771 if (!SWIG_IsOK(res1)) {
29772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29773 }
29774 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29775 {
29776 PyThreadState* __tstate = wxPyBeginAllowThreads();
29777 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29778 wxPyEndAllowThreads(__tstate);
29779 if (PyErr_Occurred()) SWIG_fail;
29780 }
29781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29782 return resultobj;
29783 fail:
29784 return NULL;
29785 }
29786
29787
29788 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29789 PyObject *resultobj = 0;
29790 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29791 void *argp1 = 0 ;
29792 int res1 = 0 ;
29793 PyObject *swig_obj[1] ;
29794
29795 if (!args) SWIG_fail;
29796 swig_obj[0] = args;
29797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29798 if (!SWIG_IsOK(res1)) {
29799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29800 }
29801 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29802 {
29803 PyThreadState* __tstate = wxPyBeginAllowThreads();
29804 delete arg1;
29805
29806 wxPyEndAllowThreads(__tstate);
29807 if (PyErr_Occurred()) SWIG_fail;
29808 }
29809 resultobj = SWIG_Py_Void();
29810 return resultobj;
29811 fail:
29812 return NULL;
29813 }
29814
29815
29816 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29817 PyObject *obj;
29818 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29819 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29820 return SWIG_Py_Void();
29821 }
29822
29823 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29824 return SWIG_Python_InitShadowInstance(args);
29825 }
29826
29827 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29828 PyObject *resultobj = 0;
29829 int arg1 = (int) 0 ;
29830 int arg2 = (int) 0 ;
29831 int arg3 = (int) 0 ;
29832 wxAcceleratorEntry *result = 0 ;
29833 int val1 ;
29834 int ecode1 = 0 ;
29835 int val2 ;
29836 int ecode2 = 0 ;
29837 int val3 ;
29838 int ecode3 = 0 ;
29839 PyObject * obj0 = 0 ;
29840 PyObject * obj1 = 0 ;
29841 PyObject * obj2 = 0 ;
29842 char * kwnames[] = {
29843 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29844 };
29845
29846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29847 if (obj0) {
29848 ecode1 = SWIG_AsVal_int(obj0, &val1);
29849 if (!SWIG_IsOK(ecode1)) {
29850 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29851 }
29852 arg1 = static_cast< int >(val1);
29853 }
29854 if (obj1) {
29855 ecode2 = SWIG_AsVal_int(obj1, &val2);
29856 if (!SWIG_IsOK(ecode2)) {
29857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29858 }
29859 arg2 = static_cast< int >(val2);
29860 }
29861 if (obj2) {
29862 ecode3 = SWIG_AsVal_int(obj2, &val3);
29863 if (!SWIG_IsOK(ecode3)) {
29864 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29865 }
29866 arg3 = static_cast< int >(val3);
29867 }
29868 {
29869 PyThreadState* __tstate = wxPyBeginAllowThreads();
29870 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29871 wxPyEndAllowThreads(__tstate);
29872 if (PyErr_Occurred()) SWIG_fail;
29873 }
29874 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29875 return resultobj;
29876 fail:
29877 return NULL;
29878 }
29879
29880
29881 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29882 PyObject *resultobj = 0;
29883 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29884 void *argp1 = 0 ;
29885 int res1 = 0 ;
29886 PyObject *swig_obj[1] ;
29887
29888 if (!args) SWIG_fail;
29889 swig_obj[0] = args;
29890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29891 if (!SWIG_IsOK(res1)) {
29892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29893 }
29894 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29895 {
29896 PyThreadState* __tstate = wxPyBeginAllowThreads();
29897 delete arg1;
29898
29899 wxPyEndAllowThreads(__tstate);
29900 if (PyErr_Occurred()) SWIG_fail;
29901 }
29902 resultobj = SWIG_Py_Void();
29903 return resultobj;
29904 fail:
29905 return NULL;
29906 }
29907
29908
29909 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29910 PyObject *resultobj = 0;
29911 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29912 int arg2 ;
29913 int arg3 ;
29914 int arg4 ;
29915 void *argp1 = 0 ;
29916 int res1 = 0 ;
29917 int val2 ;
29918 int ecode2 = 0 ;
29919 int val3 ;
29920 int ecode3 = 0 ;
29921 int val4 ;
29922 int ecode4 = 0 ;
29923 PyObject * obj0 = 0 ;
29924 PyObject * obj1 = 0 ;
29925 PyObject * obj2 = 0 ;
29926 PyObject * obj3 = 0 ;
29927 char * kwnames[] = {
29928 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29929 };
29930
29931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29933 if (!SWIG_IsOK(res1)) {
29934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29935 }
29936 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29937 ecode2 = SWIG_AsVal_int(obj1, &val2);
29938 if (!SWIG_IsOK(ecode2)) {
29939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29940 }
29941 arg2 = static_cast< int >(val2);
29942 ecode3 = SWIG_AsVal_int(obj2, &val3);
29943 if (!SWIG_IsOK(ecode3)) {
29944 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29945 }
29946 arg3 = static_cast< int >(val3);
29947 ecode4 = SWIG_AsVal_int(obj3, &val4);
29948 if (!SWIG_IsOK(ecode4)) {
29949 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29950 }
29951 arg4 = static_cast< int >(val4);
29952 {
29953 PyThreadState* __tstate = wxPyBeginAllowThreads();
29954 (arg1)->Set(arg2,arg3,arg4);
29955 wxPyEndAllowThreads(__tstate);
29956 if (PyErr_Occurred()) SWIG_fail;
29957 }
29958 resultobj = SWIG_Py_Void();
29959 return resultobj;
29960 fail:
29961 return NULL;
29962 }
29963
29964
29965 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29966 PyObject *resultobj = 0;
29967 wxString *arg1 = 0 ;
29968 wxAcceleratorEntry *result = 0 ;
29969 bool temp1 = false ;
29970 PyObject * obj0 = 0 ;
29971 char * kwnames[] = {
29972 (char *) "str", NULL
29973 };
29974
29975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
29976 {
29977 arg1 = wxString_in_helper(obj0);
29978 if (arg1 == NULL) SWIG_fail;
29979 temp1 = true;
29980 }
29981 {
29982 PyThreadState* __tstate = wxPyBeginAllowThreads();
29983 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
29984 wxPyEndAllowThreads(__tstate);
29985 if (PyErr_Occurred()) SWIG_fail;
29986 }
29987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
29988 {
29989 if (temp1)
29990 delete arg1;
29991 }
29992 return resultobj;
29993 fail:
29994 {
29995 if (temp1)
29996 delete arg1;
29997 }
29998 return NULL;
29999 }
30000
30001
30002 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30003 PyObject *resultobj = 0;
30004 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30005 int result;
30006 void *argp1 = 0 ;
30007 int res1 = 0 ;
30008 PyObject *swig_obj[1] ;
30009
30010 if (!args) SWIG_fail;
30011 swig_obj[0] = args;
30012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30013 if (!SWIG_IsOK(res1)) {
30014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30015 }
30016 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30017 {
30018 PyThreadState* __tstate = wxPyBeginAllowThreads();
30019 result = (int)(arg1)->GetFlags();
30020 wxPyEndAllowThreads(__tstate);
30021 if (PyErr_Occurred()) SWIG_fail;
30022 }
30023 resultobj = SWIG_From_int(static_cast< int >(result));
30024 return resultobj;
30025 fail:
30026 return NULL;
30027 }
30028
30029
30030 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30031 PyObject *resultobj = 0;
30032 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30033 int result;
30034 void *argp1 = 0 ;
30035 int res1 = 0 ;
30036 PyObject *swig_obj[1] ;
30037
30038 if (!args) SWIG_fail;
30039 swig_obj[0] = args;
30040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30041 if (!SWIG_IsOK(res1)) {
30042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30043 }
30044 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30045 {
30046 PyThreadState* __tstate = wxPyBeginAllowThreads();
30047 result = (int)(arg1)->GetKeyCode();
30048 wxPyEndAllowThreads(__tstate);
30049 if (PyErr_Occurred()) SWIG_fail;
30050 }
30051 resultobj = SWIG_From_int(static_cast< int >(result));
30052 return resultobj;
30053 fail:
30054 return NULL;
30055 }
30056
30057
30058 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30059 PyObject *resultobj = 0;
30060 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30061 int result;
30062 void *argp1 = 0 ;
30063 int res1 = 0 ;
30064 PyObject *swig_obj[1] ;
30065
30066 if (!args) SWIG_fail;
30067 swig_obj[0] = args;
30068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30069 if (!SWIG_IsOK(res1)) {
30070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30071 }
30072 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30073 {
30074 PyThreadState* __tstate = wxPyBeginAllowThreads();
30075 result = (int)(arg1)->GetCommand();
30076 wxPyEndAllowThreads(__tstate);
30077 if (PyErr_Occurred()) SWIG_fail;
30078 }
30079 resultobj = SWIG_From_int(static_cast< int >(result));
30080 return resultobj;
30081 fail:
30082 return NULL;
30083 }
30084
30085
30086 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30087 PyObject *resultobj = 0;
30088 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30089 bool result;
30090 void *argp1 = 0 ;
30091 int res1 = 0 ;
30092 PyObject *swig_obj[1] ;
30093
30094 if (!args) SWIG_fail;
30095 swig_obj[0] = args;
30096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30097 if (!SWIG_IsOK(res1)) {
30098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
30099 }
30100 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30101 {
30102 PyThreadState* __tstate = wxPyBeginAllowThreads();
30103 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
30104 wxPyEndAllowThreads(__tstate);
30105 if (PyErr_Occurred()) SWIG_fail;
30106 }
30107 {
30108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30109 }
30110 return resultobj;
30111 fail:
30112 return NULL;
30113 }
30114
30115
30116 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30117 PyObject *resultobj = 0;
30118 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30119 wxString result;
30120 void *argp1 = 0 ;
30121 int res1 = 0 ;
30122 PyObject *swig_obj[1] ;
30123
30124 if (!args) SWIG_fail;
30125 swig_obj[0] = args;
30126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30127 if (!SWIG_IsOK(res1)) {
30128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
30129 }
30130 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30131 {
30132 PyThreadState* __tstate = wxPyBeginAllowThreads();
30133 result = ((wxAcceleratorEntry const *)arg1)->ToString();
30134 wxPyEndAllowThreads(__tstate);
30135 if (PyErr_Occurred()) SWIG_fail;
30136 }
30137 {
30138 #if wxUSE_UNICODE
30139 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30140 #else
30141 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30142 #endif
30143 }
30144 return resultobj;
30145 fail:
30146 return NULL;
30147 }
30148
30149
30150 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30151 PyObject *resultobj = 0;
30152 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30153 wxString *arg2 = 0 ;
30154 bool result;
30155 void *argp1 = 0 ;
30156 int res1 = 0 ;
30157 bool temp2 = false ;
30158 PyObject * obj0 = 0 ;
30159 PyObject * obj1 = 0 ;
30160 char * kwnames[] = {
30161 (char *) "self",(char *) "str", NULL
30162 };
30163
30164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
30165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30166 if (!SWIG_IsOK(res1)) {
30167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30168 }
30169 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30170 {
30171 arg2 = wxString_in_helper(obj1);
30172 if (arg2 == NULL) SWIG_fail;
30173 temp2 = true;
30174 }
30175 {
30176 PyThreadState* __tstate = wxPyBeginAllowThreads();
30177 result = (bool)(arg1)->FromString((wxString const &)*arg2);
30178 wxPyEndAllowThreads(__tstate);
30179 if (PyErr_Occurred()) SWIG_fail;
30180 }
30181 {
30182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30183 }
30184 {
30185 if (temp2)
30186 delete arg2;
30187 }
30188 return resultobj;
30189 fail:
30190 {
30191 if (temp2)
30192 delete arg2;
30193 }
30194 return NULL;
30195 }
30196
30197
30198 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30199 PyObject *obj;
30200 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30201 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
30202 return SWIG_Py_Void();
30203 }
30204
30205 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30206 return SWIG_Python_InitShadowInstance(args);
30207 }
30208
30209 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30210 PyObject *resultobj = 0;
30211 int arg1 ;
30212 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
30213 wxAcceleratorTable *result = 0 ;
30214 PyObject * obj0 = 0 ;
30215 char * kwnames[] = {
30216 (char *) "n", NULL
30217 };
30218
30219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
30220 {
30221 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
30222 if (arg2) arg1 = PyList_Size(obj0);
30223 else arg1 = 0;
30224 }
30225 {
30226 PyThreadState* __tstate = wxPyBeginAllowThreads();
30227 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
30228 wxPyEndAllowThreads(__tstate);
30229 if (PyErr_Occurred()) SWIG_fail;
30230 }
30231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
30232 return resultobj;
30233 fail:
30234 return NULL;
30235 }
30236
30237
30238 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30239 PyObject *resultobj = 0;
30240 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
30241 void *argp1 = 0 ;
30242 int res1 = 0 ;
30243 PyObject *swig_obj[1] ;
30244
30245 if (!args) SWIG_fail;
30246 swig_obj[0] = args;
30247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
30248 if (!SWIG_IsOK(res1)) {
30249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
30250 }
30251 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
30252 {
30253 PyThreadState* __tstate = wxPyBeginAllowThreads();
30254 delete arg1;
30255
30256 wxPyEndAllowThreads(__tstate);
30257 if (PyErr_Occurred()) SWIG_fail;
30258 }
30259 resultobj = SWIG_Py_Void();
30260 return resultobj;
30261 fail:
30262 return NULL;
30263 }
30264
30265
30266 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30267 PyObject *resultobj = 0;
30268 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
30269 bool result;
30270 void *argp1 = 0 ;
30271 int res1 = 0 ;
30272 PyObject *swig_obj[1] ;
30273
30274 if (!args) SWIG_fail;
30275 swig_obj[0] = args;
30276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
30277 if (!SWIG_IsOK(res1)) {
30278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
30279 }
30280 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
30281 {
30282 PyThreadState* __tstate = wxPyBeginAllowThreads();
30283 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
30284 wxPyEndAllowThreads(__tstate);
30285 if (PyErr_Occurred()) SWIG_fail;
30286 }
30287 {
30288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30289 }
30290 return resultobj;
30291 fail:
30292 return NULL;
30293 }
30294
30295
30296 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30297 PyObject *obj;
30298 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30299 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
30300 return SWIG_Py_Void();
30301 }
30302
30303 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30304 return SWIG_Python_InitShadowInstance(args);
30305 }
30306
30307 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
30308 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
30309 return 1;
30310 }
30311
30312
30313 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
30314 PyObject *pyobj = 0;
30315
30316 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
30317 return pyobj;
30318 }
30319
30320
30321 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30322 PyObject *resultobj = 0;
30323 wxString *arg1 = 0 ;
30324 wxAcceleratorEntry *result = 0 ;
30325 bool temp1 = false ;
30326 PyObject * obj0 = 0 ;
30327 char * kwnames[] = {
30328 (char *) "label", NULL
30329 };
30330
30331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
30332 {
30333 arg1 = wxString_in_helper(obj0);
30334 if (arg1 == NULL) SWIG_fail;
30335 temp1 = true;
30336 }
30337 {
30338 PyThreadState* __tstate = wxPyBeginAllowThreads();
30339 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
30340 wxPyEndAllowThreads(__tstate);
30341 if (PyErr_Occurred()) SWIG_fail;
30342 }
30343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30344 {
30345 if (temp1)
30346 delete arg1;
30347 }
30348 return resultobj;
30349 fail:
30350 {
30351 if (temp1)
30352 delete arg1;
30353 }
30354 return NULL;
30355 }
30356
30357
30358 SWIGINTERN int PanelNameStr_set(PyObject *) {
30359 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
30360 return 1;
30361 }
30362
30363
30364 SWIGINTERN PyObject *PanelNameStr_get(void) {
30365 PyObject *pyobj = 0;
30366
30367 {
30368 #if wxUSE_UNICODE
30369 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
30370 #else
30371 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
30372 #endif
30373 }
30374 return pyobj;
30375 }
30376
30377
30378 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30379 PyObject *resultobj = 0;
30380 wxVisualAttributes *result = 0 ;
30381
30382 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
30383 {
30384 PyThreadState* __tstate = wxPyBeginAllowThreads();
30385 result = (wxVisualAttributes *)new_wxVisualAttributes();
30386 wxPyEndAllowThreads(__tstate);
30387 if (PyErr_Occurred()) SWIG_fail;
30388 }
30389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
30390 return resultobj;
30391 fail:
30392 return NULL;
30393 }
30394
30395
30396 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30397 PyObject *resultobj = 0;
30398 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30399 void *argp1 = 0 ;
30400 int res1 = 0 ;
30401 PyObject *swig_obj[1] ;
30402
30403 if (!args) SWIG_fail;
30404 swig_obj[0] = args;
30405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
30406 if (!SWIG_IsOK(res1)) {
30407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30408 }
30409 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30410 {
30411 PyThreadState* __tstate = wxPyBeginAllowThreads();
30412 delete_wxVisualAttributes(arg1);
30413
30414 wxPyEndAllowThreads(__tstate);
30415 if (PyErr_Occurred()) SWIG_fail;
30416 }
30417 resultobj = SWIG_Py_Void();
30418 return resultobj;
30419 fail:
30420 return NULL;
30421 }
30422
30423
30424 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30425 PyObject *resultobj = 0;
30426 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30427 wxFont *arg2 = (wxFont *) 0 ;
30428 void *argp1 = 0 ;
30429 int res1 = 0 ;
30430 void *argp2 = 0 ;
30431 int res2 = 0 ;
30432 PyObject *swig_obj[2] ;
30433
30434 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
30435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30436 if (!SWIG_IsOK(res1)) {
30437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30438 }
30439 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30440 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
30441 if (!SWIG_IsOK(res2)) {
30442 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
30443 }
30444 arg2 = reinterpret_cast< wxFont * >(argp2);
30445 if (arg1) (arg1)->font = *arg2;
30446
30447 resultobj = SWIG_Py_Void();
30448 return resultobj;
30449 fail:
30450 return NULL;
30451 }
30452
30453
30454 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30455 PyObject *resultobj = 0;
30456 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30457 wxFont *result = 0 ;
30458 void *argp1 = 0 ;
30459 int res1 = 0 ;
30460 PyObject *swig_obj[1] ;
30461
30462 if (!args) SWIG_fail;
30463 swig_obj[0] = args;
30464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30465 if (!SWIG_IsOK(res1)) {
30466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30467 }
30468 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30469 result = (wxFont *)& ((arg1)->font);
30470 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
30471 return resultobj;
30472 fail:
30473 return NULL;
30474 }
30475
30476
30477 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30478 PyObject *resultobj = 0;
30479 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30480 wxColour *arg2 = (wxColour *) 0 ;
30481 void *argp1 = 0 ;
30482 int res1 = 0 ;
30483 void *argp2 = 0 ;
30484 int res2 = 0 ;
30485 PyObject *swig_obj[2] ;
30486
30487 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
30488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30489 if (!SWIG_IsOK(res1)) {
30490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30491 }
30492 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30493 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30494 if (!SWIG_IsOK(res2)) {
30495 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30496 }
30497 arg2 = reinterpret_cast< wxColour * >(argp2);
30498 if (arg1) (arg1)->colFg = *arg2;
30499
30500 resultobj = SWIG_Py_Void();
30501 return resultobj;
30502 fail:
30503 return NULL;
30504 }
30505
30506
30507 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30508 PyObject *resultobj = 0;
30509 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30510 wxColour *result = 0 ;
30511 void *argp1 = 0 ;
30512 int res1 = 0 ;
30513 PyObject *swig_obj[1] ;
30514
30515 if (!args) SWIG_fail;
30516 swig_obj[0] = args;
30517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30518 if (!SWIG_IsOK(res1)) {
30519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30520 }
30521 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30522 result = (wxColour *)& ((arg1)->colFg);
30523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30524 return resultobj;
30525 fail:
30526 return NULL;
30527 }
30528
30529
30530 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30531 PyObject *resultobj = 0;
30532 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30533 wxColour *arg2 = (wxColour *) 0 ;
30534 void *argp1 = 0 ;
30535 int res1 = 0 ;
30536 void *argp2 = 0 ;
30537 int res2 = 0 ;
30538 PyObject *swig_obj[2] ;
30539
30540 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
30541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30542 if (!SWIG_IsOK(res1)) {
30543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30544 }
30545 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30546 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30547 if (!SWIG_IsOK(res2)) {
30548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30549 }
30550 arg2 = reinterpret_cast< wxColour * >(argp2);
30551 if (arg1) (arg1)->colBg = *arg2;
30552
30553 resultobj = SWIG_Py_Void();
30554 return resultobj;
30555 fail:
30556 return NULL;
30557 }
30558
30559
30560 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30561 PyObject *resultobj = 0;
30562 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30563 wxColour *result = 0 ;
30564 void *argp1 = 0 ;
30565 int res1 = 0 ;
30566 PyObject *swig_obj[1] ;
30567
30568 if (!args) SWIG_fail;
30569 swig_obj[0] = args;
30570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30571 if (!SWIG_IsOK(res1)) {
30572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30573 }
30574 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30575 result = (wxColour *)& ((arg1)->colBg);
30576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30577 return resultobj;
30578 fail:
30579 return NULL;
30580 }
30581
30582
30583 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30584 PyObject *obj;
30585 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30586 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
30587 return SWIG_Py_Void();
30588 }
30589
30590 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30591 return SWIG_Python_InitShadowInstance(args);
30592 }
30593
30594 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30595 PyObject *resultobj = 0;
30596 wxWindow *arg1 = (wxWindow *) 0 ;
30597 int arg2 = (int) (int)-1 ;
30598 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30599 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30600 wxSize const &arg4_defvalue = wxDefaultSize ;
30601 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
30602 long arg5 = (long) 0 ;
30603 wxString const &arg6_defvalue = wxPyPanelNameStr ;
30604 wxString *arg6 = (wxString *) &arg6_defvalue ;
30605 wxWindow *result = 0 ;
30606 void *argp1 = 0 ;
30607 int res1 = 0 ;
30608 int val2 ;
30609 int ecode2 = 0 ;
30610 wxPoint temp3 ;
30611 wxSize temp4 ;
30612 long val5 ;
30613 int ecode5 = 0 ;
30614 bool temp6 = false ;
30615 PyObject * obj0 = 0 ;
30616 PyObject * obj1 = 0 ;
30617 PyObject * obj2 = 0 ;
30618 PyObject * obj3 = 0 ;
30619 PyObject * obj4 = 0 ;
30620 PyObject * obj5 = 0 ;
30621 char * kwnames[] = {
30622 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30623 };
30624
30625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30627 if (!SWIG_IsOK(res1)) {
30628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
30629 }
30630 arg1 = reinterpret_cast< wxWindow * >(argp1);
30631 if (obj1) {
30632 ecode2 = SWIG_AsVal_int(obj1, &val2);
30633 if (!SWIG_IsOK(ecode2)) {
30634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
30635 }
30636 arg2 = static_cast< int >(val2);
30637 }
30638 if (obj2) {
30639 {
30640 arg3 = &temp3;
30641 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30642 }
30643 }
30644 if (obj3) {
30645 {
30646 arg4 = &temp4;
30647 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
30648 }
30649 }
30650 if (obj4) {
30651 ecode5 = SWIG_AsVal_long(obj4, &val5);
30652 if (!SWIG_IsOK(ecode5)) {
30653 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
30654 }
30655 arg5 = static_cast< long >(val5);
30656 }
30657 if (obj5) {
30658 {
30659 arg6 = wxString_in_helper(obj5);
30660 if (arg6 == NULL) SWIG_fail;
30661 temp6 = true;
30662 }
30663 }
30664 {
30665 if (!wxPyCheckForApp()) SWIG_fail;
30666 PyThreadState* __tstate = wxPyBeginAllowThreads();
30667 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
30668 wxPyEndAllowThreads(__tstate);
30669 if (PyErr_Occurred()) SWIG_fail;
30670 }
30671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
30672 {
30673 if (temp6)
30674 delete arg6;
30675 }
30676 return resultobj;
30677 fail:
30678 {
30679 if (temp6)
30680 delete arg6;
30681 }
30682 return NULL;
30683 }
30684
30685
30686 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30687 PyObject *resultobj = 0;
30688 wxWindow *result = 0 ;
30689
30690 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
30691 {
30692 if (!wxPyCheckForApp()) SWIG_fail;
30693 PyThreadState* __tstate = wxPyBeginAllowThreads();
30694 result = (wxWindow *)new wxWindow();
30695 wxPyEndAllowThreads(__tstate);
30696 if (PyErr_Occurred()) SWIG_fail;
30697 }
30698 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
30699 return resultobj;
30700 fail:
30701 return NULL;
30702 }
30703
30704
30705 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30706 PyObject *resultobj = 0;
30707 wxWindow *arg1 = (wxWindow *) 0 ;
30708 wxWindow *arg2 = (wxWindow *) 0 ;
30709 int arg3 = (int) (int)-1 ;
30710 wxPoint const &arg4_defvalue = wxDefaultPosition ;
30711 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
30712 wxSize const &arg5_defvalue = wxDefaultSize ;
30713 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
30714 long arg6 = (long) 0 ;
30715 wxString const &arg7_defvalue = wxPyPanelNameStr ;
30716 wxString *arg7 = (wxString *) &arg7_defvalue ;
30717 bool result;
30718 void *argp1 = 0 ;
30719 int res1 = 0 ;
30720 void *argp2 = 0 ;
30721 int res2 = 0 ;
30722 int val3 ;
30723 int ecode3 = 0 ;
30724 wxPoint temp4 ;
30725 wxSize temp5 ;
30726 long val6 ;
30727 int ecode6 = 0 ;
30728 bool temp7 = false ;
30729 PyObject * obj0 = 0 ;
30730 PyObject * obj1 = 0 ;
30731 PyObject * obj2 = 0 ;
30732 PyObject * obj3 = 0 ;
30733 PyObject * obj4 = 0 ;
30734 PyObject * obj5 = 0 ;
30735 PyObject * obj6 = 0 ;
30736 char * kwnames[] = {
30737 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30738 };
30739
30740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30742 if (!SWIG_IsOK(res1)) {
30743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
30744 }
30745 arg1 = reinterpret_cast< wxWindow * >(argp1);
30746 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30747 if (!SWIG_IsOK(res2)) {
30748 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
30749 }
30750 arg2 = reinterpret_cast< wxWindow * >(argp2);
30751 if (obj2) {
30752 ecode3 = SWIG_AsVal_int(obj2, &val3);
30753 if (!SWIG_IsOK(ecode3)) {
30754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
30755 }
30756 arg3 = static_cast< int >(val3);
30757 }
30758 if (obj3) {
30759 {
30760 arg4 = &temp4;
30761 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
30762 }
30763 }
30764 if (obj4) {
30765 {
30766 arg5 = &temp5;
30767 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
30768 }
30769 }
30770 if (obj5) {
30771 ecode6 = SWIG_AsVal_long(obj5, &val6);
30772 if (!SWIG_IsOK(ecode6)) {
30773 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
30774 }
30775 arg6 = static_cast< long >(val6);
30776 }
30777 if (obj6) {
30778 {
30779 arg7 = wxString_in_helper(obj6);
30780 if (arg7 == NULL) SWIG_fail;
30781 temp7 = true;
30782 }
30783 }
30784 {
30785 PyThreadState* __tstate = wxPyBeginAllowThreads();
30786 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
30787 wxPyEndAllowThreads(__tstate);
30788 if (PyErr_Occurred()) SWIG_fail;
30789 }
30790 {
30791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30792 }
30793 {
30794 if (temp7)
30795 delete arg7;
30796 }
30797 return resultobj;
30798 fail:
30799 {
30800 if (temp7)
30801 delete arg7;
30802 }
30803 return NULL;
30804 }
30805
30806
30807 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30808 PyObject *resultobj = 0;
30809 wxWindow *arg1 = (wxWindow *) 0 ;
30810 bool arg2 = (bool) false ;
30811 bool result;
30812 void *argp1 = 0 ;
30813 int res1 = 0 ;
30814 bool val2 ;
30815 int ecode2 = 0 ;
30816 PyObject * obj0 = 0 ;
30817 PyObject * obj1 = 0 ;
30818 char * kwnames[] = {
30819 (char *) "self",(char *) "force", NULL
30820 };
30821
30822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30824 if (!SWIG_IsOK(res1)) {
30825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30826 }
30827 arg1 = reinterpret_cast< wxWindow * >(argp1);
30828 if (obj1) {
30829 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30830 if (!SWIG_IsOK(ecode2)) {
30831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30832 }
30833 arg2 = static_cast< bool >(val2);
30834 }
30835 {
30836 PyThreadState* __tstate = wxPyBeginAllowThreads();
30837 result = (bool)(arg1)->Close(arg2);
30838 wxPyEndAllowThreads(__tstate);
30839 if (PyErr_Occurred()) SWIG_fail;
30840 }
30841 {
30842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30843 }
30844 return resultobj;
30845 fail:
30846 return NULL;
30847 }
30848
30849
30850 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30851 PyObject *resultobj = 0;
30852 wxWindow *arg1 = (wxWindow *) 0 ;
30853 bool result;
30854 void *argp1 = 0 ;
30855 int res1 = 0 ;
30856 PyObject *swig_obj[1] ;
30857
30858 if (!args) SWIG_fail;
30859 swig_obj[0] = args;
30860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30861 if (!SWIG_IsOK(res1)) {
30862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30863 }
30864 arg1 = reinterpret_cast< wxWindow * >(argp1);
30865 {
30866 PyThreadState* __tstate = wxPyBeginAllowThreads();
30867 result = (bool)(arg1)->Destroy();
30868 wxPyEndAllowThreads(__tstate);
30869 if (PyErr_Occurred()) SWIG_fail;
30870 }
30871 {
30872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30873 }
30874 return resultobj;
30875 fail:
30876 return NULL;
30877 }
30878
30879
30880 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30881 PyObject *resultobj = 0;
30882 wxWindow *arg1 = (wxWindow *) 0 ;
30883 bool result;
30884 void *argp1 = 0 ;
30885 int res1 = 0 ;
30886 PyObject *swig_obj[1] ;
30887
30888 if (!args) SWIG_fail;
30889 swig_obj[0] = args;
30890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30891 if (!SWIG_IsOK(res1)) {
30892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30893 }
30894 arg1 = reinterpret_cast< wxWindow * >(argp1);
30895 {
30896 PyThreadState* __tstate = wxPyBeginAllowThreads();
30897 result = (bool)(arg1)->DestroyChildren();
30898 wxPyEndAllowThreads(__tstate);
30899 if (PyErr_Occurred()) SWIG_fail;
30900 }
30901 {
30902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30903 }
30904 return resultobj;
30905 fail:
30906 return NULL;
30907 }
30908
30909
30910 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30911 PyObject *resultobj = 0;
30912 wxWindow *arg1 = (wxWindow *) 0 ;
30913 bool result;
30914 void *argp1 = 0 ;
30915 int res1 = 0 ;
30916 PyObject *swig_obj[1] ;
30917
30918 if (!args) SWIG_fail;
30919 swig_obj[0] = args;
30920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30921 if (!SWIG_IsOK(res1)) {
30922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30923 }
30924 arg1 = reinterpret_cast< wxWindow * >(argp1);
30925 {
30926 PyThreadState* __tstate = wxPyBeginAllowThreads();
30927 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30928 wxPyEndAllowThreads(__tstate);
30929 if (PyErr_Occurred()) SWIG_fail;
30930 }
30931 {
30932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30933 }
30934 return resultobj;
30935 fail:
30936 return NULL;
30937 }
30938
30939
30940 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30941 PyObject *resultobj = 0;
30942 wxWindow *arg1 = (wxWindow *) 0 ;
30943 wxString *arg2 = 0 ;
30944 void *argp1 = 0 ;
30945 int res1 = 0 ;
30946 bool temp2 = false ;
30947 PyObject * obj0 = 0 ;
30948 PyObject * obj1 = 0 ;
30949 char * kwnames[] = {
30950 (char *) "self",(char *) "label", NULL
30951 };
30952
30953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30955 if (!SWIG_IsOK(res1)) {
30956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30957 }
30958 arg1 = reinterpret_cast< wxWindow * >(argp1);
30959 {
30960 arg2 = wxString_in_helper(obj1);
30961 if (arg2 == NULL) SWIG_fail;
30962 temp2 = true;
30963 }
30964 {
30965 PyThreadState* __tstate = wxPyBeginAllowThreads();
30966 (arg1)->SetLabel((wxString const &)*arg2);
30967 wxPyEndAllowThreads(__tstate);
30968 if (PyErr_Occurred()) SWIG_fail;
30969 }
30970 resultobj = SWIG_Py_Void();
30971 {
30972 if (temp2)
30973 delete arg2;
30974 }
30975 return resultobj;
30976 fail:
30977 {
30978 if (temp2)
30979 delete arg2;
30980 }
30981 return NULL;
30982 }
30983
30984
30985 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30986 PyObject *resultobj = 0;
30987 wxWindow *arg1 = (wxWindow *) 0 ;
30988 wxString 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_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30998 }
30999 arg1 = reinterpret_cast< wxWindow * >(argp1);
31000 {
31001 PyThreadState* __tstate = wxPyBeginAllowThreads();
31002 result = ((wxWindow const *)arg1)->GetLabel();
31003 wxPyEndAllowThreads(__tstate);
31004 if (PyErr_Occurred()) SWIG_fail;
31005 }
31006 {
31007 #if wxUSE_UNICODE
31008 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31009 #else
31010 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31011 #endif
31012 }
31013 return resultobj;
31014 fail:
31015 return NULL;
31016 }
31017
31018
31019 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31020 PyObject *resultobj = 0;
31021 wxWindow *arg1 = (wxWindow *) 0 ;
31022 wxString *arg2 = 0 ;
31023 void *argp1 = 0 ;
31024 int res1 = 0 ;
31025 bool temp2 = false ;
31026 PyObject * obj0 = 0 ;
31027 PyObject * obj1 = 0 ;
31028 char * kwnames[] = {
31029 (char *) "self",(char *) "name", NULL
31030 };
31031
31032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
31033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31034 if (!SWIG_IsOK(res1)) {
31035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
31036 }
31037 arg1 = reinterpret_cast< wxWindow * >(argp1);
31038 {
31039 arg2 = wxString_in_helper(obj1);
31040 if (arg2 == NULL) SWIG_fail;
31041 temp2 = true;
31042 }
31043 {
31044 PyThreadState* __tstate = wxPyBeginAllowThreads();
31045 (arg1)->SetName((wxString const &)*arg2);
31046 wxPyEndAllowThreads(__tstate);
31047 if (PyErr_Occurred()) SWIG_fail;
31048 }
31049 resultobj = SWIG_Py_Void();
31050 {
31051 if (temp2)
31052 delete arg2;
31053 }
31054 return resultobj;
31055 fail:
31056 {
31057 if (temp2)
31058 delete arg2;
31059 }
31060 return NULL;
31061 }
31062
31063
31064 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31065 PyObject *resultobj = 0;
31066 wxWindow *arg1 = (wxWindow *) 0 ;
31067 wxString result;
31068 void *argp1 = 0 ;
31069 int res1 = 0 ;
31070 PyObject *swig_obj[1] ;
31071
31072 if (!args) SWIG_fail;
31073 swig_obj[0] = args;
31074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31075 if (!SWIG_IsOK(res1)) {
31076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
31077 }
31078 arg1 = reinterpret_cast< wxWindow * >(argp1);
31079 {
31080 PyThreadState* __tstate = wxPyBeginAllowThreads();
31081 result = ((wxWindow const *)arg1)->GetName();
31082 wxPyEndAllowThreads(__tstate);
31083 if (PyErr_Occurred()) SWIG_fail;
31084 }
31085 {
31086 #if wxUSE_UNICODE
31087 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31088 #else
31089 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31090 #endif
31091 }
31092 return resultobj;
31093 fail:
31094 return NULL;
31095 }
31096
31097
31098 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31099 PyObject *resultobj = 0;
31100 wxWindow *arg1 = (wxWindow *) 0 ;
31101 wxWindowVariant arg2 ;
31102 void *argp1 = 0 ;
31103 int res1 = 0 ;
31104 int val2 ;
31105 int ecode2 = 0 ;
31106 PyObject * obj0 = 0 ;
31107 PyObject * obj1 = 0 ;
31108 char * kwnames[] = {
31109 (char *) "self",(char *) "variant", NULL
31110 };
31111
31112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
31113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31114 if (!SWIG_IsOK(res1)) {
31115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
31116 }
31117 arg1 = reinterpret_cast< wxWindow * >(argp1);
31118 ecode2 = SWIG_AsVal_int(obj1, &val2);
31119 if (!SWIG_IsOK(ecode2)) {
31120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
31121 }
31122 arg2 = static_cast< wxWindowVariant >(val2);
31123 {
31124 PyThreadState* __tstate = wxPyBeginAllowThreads();
31125 (arg1)->SetWindowVariant(arg2);
31126 wxPyEndAllowThreads(__tstate);
31127 if (PyErr_Occurred()) SWIG_fail;
31128 }
31129 resultobj = SWIG_Py_Void();
31130 return resultobj;
31131 fail:
31132 return NULL;
31133 }
31134
31135
31136 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31137 PyObject *resultobj = 0;
31138 wxWindow *arg1 = (wxWindow *) 0 ;
31139 wxWindowVariant result;
31140 void *argp1 = 0 ;
31141 int res1 = 0 ;
31142 PyObject *swig_obj[1] ;
31143
31144 if (!args) SWIG_fail;
31145 swig_obj[0] = args;
31146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31147 if (!SWIG_IsOK(res1)) {
31148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
31149 }
31150 arg1 = reinterpret_cast< wxWindow * >(argp1);
31151 {
31152 PyThreadState* __tstate = wxPyBeginAllowThreads();
31153 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
31154 wxPyEndAllowThreads(__tstate);
31155 if (PyErr_Occurred()) SWIG_fail;
31156 }
31157 resultobj = SWIG_From_int(static_cast< int >(result));
31158 return resultobj;
31159 fail:
31160 return NULL;
31161 }
31162
31163
31164 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31165 PyObject *resultobj = 0;
31166 wxWindow *arg1 = (wxWindow *) 0 ;
31167 int arg2 ;
31168 void *argp1 = 0 ;
31169 int res1 = 0 ;
31170 int val2 ;
31171 int ecode2 = 0 ;
31172 PyObject * obj0 = 0 ;
31173 PyObject * obj1 = 0 ;
31174 char * kwnames[] = {
31175 (char *) "self",(char *) "winid", NULL
31176 };
31177
31178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31180 if (!SWIG_IsOK(res1)) {
31181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
31182 }
31183 arg1 = reinterpret_cast< wxWindow * >(argp1);
31184 ecode2 = SWIG_AsVal_int(obj1, &val2);
31185 if (!SWIG_IsOK(ecode2)) {
31186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
31187 }
31188 arg2 = static_cast< int >(val2);
31189 {
31190 PyThreadState* __tstate = wxPyBeginAllowThreads();
31191 (arg1)->SetId(arg2);
31192 wxPyEndAllowThreads(__tstate);
31193 if (PyErr_Occurred()) SWIG_fail;
31194 }
31195 resultobj = SWIG_Py_Void();
31196 return resultobj;
31197 fail:
31198 return NULL;
31199 }
31200
31201
31202 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31203 PyObject *resultobj = 0;
31204 wxWindow *arg1 = (wxWindow *) 0 ;
31205 int result;
31206 void *argp1 = 0 ;
31207 int res1 = 0 ;
31208 PyObject *swig_obj[1] ;
31209
31210 if (!args) SWIG_fail;
31211 swig_obj[0] = args;
31212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31213 if (!SWIG_IsOK(res1)) {
31214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
31215 }
31216 arg1 = reinterpret_cast< wxWindow * >(argp1);
31217 {
31218 PyThreadState* __tstate = wxPyBeginAllowThreads();
31219 result = (int)((wxWindow const *)arg1)->GetId();
31220 wxPyEndAllowThreads(__tstate);
31221 if (PyErr_Occurred()) SWIG_fail;
31222 }
31223 resultobj = SWIG_From_int(static_cast< int >(result));
31224 return resultobj;
31225 fail:
31226 return NULL;
31227 }
31228
31229
31230 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31231 PyObject *resultobj = 0;
31232 int result;
31233
31234 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
31235 {
31236 PyThreadState* __tstate = wxPyBeginAllowThreads();
31237 result = (int)wxWindow::NewControlId();
31238 wxPyEndAllowThreads(__tstate);
31239 if (PyErr_Occurred()) SWIG_fail;
31240 }
31241 resultobj = SWIG_From_int(static_cast< int >(result));
31242 return resultobj;
31243 fail:
31244 return NULL;
31245 }
31246
31247
31248 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31249 PyObject *resultobj = 0;
31250 int arg1 ;
31251 int result;
31252 int val1 ;
31253 int ecode1 = 0 ;
31254 PyObject * obj0 = 0 ;
31255 char * kwnames[] = {
31256 (char *) "winid", NULL
31257 };
31258
31259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
31260 ecode1 = SWIG_AsVal_int(obj0, &val1);
31261 if (!SWIG_IsOK(ecode1)) {
31262 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
31263 }
31264 arg1 = static_cast< int >(val1);
31265 {
31266 PyThreadState* __tstate = wxPyBeginAllowThreads();
31267 result = (int)wxWindow::NextControlId(arg1);
31268 wxPyEndAllowThreads(__tstate);
31269 if (PyErr_Occurred()) SWIG_fail;
31270 }
31271 resultobj = SWIG_From_int(static_cast< int >(result));
31272 return resultobj;
31273 fail:
31274 return NULL;
31275 }
31276
31277
31278 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31279 PyObject *resultobj = 0;
31280 int arg1 ;
31281 int result;
31282 int val1 ;
31283 int ecode1 = 0 ;
31284 PyObject * obj0 = 0 ;
31285 char * kwnames[] = {
31286 (char *) "winid", NULL
31287 };
31288
31289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
31290 ecode1 = SWIG_AsVal_int(obj0, &val1);
31291 if (!SWIG_IsOK(ecode1)) {
31292 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
31293 }
31294 arg1 = static_cast< int >(val1);
31295 {
31296 PyThreadState* __tstate = wxPyBeginAllowThreads();
31297 result = (int)wxWindow::PrevControlId(arg1);
31298 wxPyEndAllowThreads(__tstate);
31299 if (PyErr_Occurred()) SWIG_fail;
31300 }
31301 resultobj = SWIG_From_int(static_cast< int >(result));
31302 return resultobj;
31303 fail:
31304 return NULL;
31305 }
31306
31307
31308 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31309 PyObject *resultobj = 0;
31310 wxWindow *arg1 = (wxWindow *) 0 ;
31311 wxLayoutDirection result;
31312 void *argp1 = 0 ;
31313 int res1 = 0 ;
31314 PyObject *swig_obj[1] ;
31315
31316 if (!args) SWIG_fail;
31317 swig_obj[0] = args;
31318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31319 if (!SWIG_IsOK(res1)) {
31320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
31321 }
31322 arg1 = reinterpret_cast< wxWindow * >(argp1);
31323 {
31324 PyThreadState* __tstate = wxPyBeginAllowThreads();
31325 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
31326 wxPyEndAllowThreads(__tstate);
31327 if (PyErr_Occurred()) SWIG_fail;
31328 }
31329 resultobj = SWIG_From_int(static_cast< int >(result));
31330 return resultobj;
31331 fail:
31332 return NULL;
31333 }
31334
31335
31336 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31337 PyObject *resultobj = 0;
31338 wxWindow *arg1 = (wxWindow *) 0 ;
31339 wxLayoutDirection arg2 ;
31340 void *argp1 = 0 ;
31341 int res1 = 0 ;
31342 int val2 ;
31343 int ecode2 = 0 ;
31344 PyObject * obj0 = 0 ;
31345 PyObject * obj1 = 0 ;
31346 char * kwnames[] = {
31347 (char *) "self",(char *) "dir", NULL
31348 };
31349
31350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
31351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31352 if (!SWIG_IsOK(res1)) {
31353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
31354 }
31355 arg1 = reinterpret_cast< wxWindow * >(argp1);
31356 ecode2 = SWIG_AsVal_int(obj1, &val2);
31357 if (!SWIG_IsOK(ecode2)) {
31358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
31359 }
31360 arg2 = static_cast< wxLayoutDirection >(val2);
31361 {
31362 PyThreadState* __tstate = wxPyBeginAllowThreads();
31363 (arg1)->SetLayoutDirection(arg2);
31364 wxPyEndAllowThreads(__tstate);
31365 if (PyErr_Occurred()) SWIG_fail;
31366 }
31367 resultobj = SWIG_Py_Void();
31368 return resultobj;
31369 fail:
31370 return NULL;
31371 }
31372
31373
31374 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31375 PyObject *resultobj = 0;
31376 wxWindow *arg1 = (wxWindow *) 0 ;
31377 int arg2 ;
31378 int arg3 ;
31379 int arg4 ;
31380 int result;
31381 void *argp1 = 0 ;
31382 int res1 = 0 ;
31383 int val2 ;
31384 int ecode2 = 0 ;
31385 int val3 ;
31386 int ecode3 = 0 ;
31387 int val4 ;
31388 int ecode4 = 0 ;
31389 PyObject * obj0 = 0 ;
31390 PyObject * obj1 = 0 ;
31391 PyObject * obj2 = 0 ;
31392 PyObject * obj3 = 0 ;
31393 char * kwnames[] = {
31394 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
31395 };
31396
31397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31399 if (!SWIG_IsOK(res1)) {
31400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
31401 }
31402 arg1 = reinterpret_cast< wxWindow * >(argp1);
31403 ecode2 = SWIG_AsVal_int(obj1, &val2);
31404 if (!SWIG_IsOK(ecode2)) {
31405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
31406 }
31407 arg2 = static_cast< int >(val2);
31408 ecode3 = SWIG_AsVal_int(obj2, &val3);
31409 if (!SWIG_IsOK(ecode3)) {
31410 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
31411 }
31412 arg3 = static_cast< int >(val3);
31413 ecode4 = SWIG_AsVal_int(obj3, &val4);
31414 if (!SWIG_IsOK(ecode4)) {
31415 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
31416 }
31417 arg4 = static_cast< int >(val4);
31418 {
31419 PyThreadState* __tstate = wxPyBeginAllowThreads();
31420 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
31421 wxPyEndAllowThreads(__tstate);
31422 if (PyErr_Occurred()) SWIG_fail;
31423 }
31424 resultobj = SWIG_From_int(static_cast< int >(result));
31425 return resultobj;
31426 fail:
31427 return NULL;
31428 }
31429
31430
31431 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31432 PyObject *resultobj = 0;
31433 wxWindow *arg1 = (wxWindow *) 0 ;
31434 wxSize *arg2 = 0 ;
31435 void *argp1 = 0 ;
31436 int res1 = 0 ;
31437 wxSize temp2 ;
31438 PyObject * obj0 = 0 ;
31439 PyObject * obj1 = 0 ;
31440 char * kwnames[] = {
31441 (char *) "self",(char *) "size", NULL
31442 };
31443
31444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
31445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31446 if (!SWIG_IsOK(res1)) {
31447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31448 }
31449 arg1 = reinterpret_cast< wxWindow * >(argp1);
31450 {
31451 arg2 = &temp2;
31452 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31453 }
31454 {
31455 PyThreadState* __tstate = wxPyBeginAllowThreads();
31456 (arg1)->SetSize((wxSize const &)*arg2);
31457 wxPyEndAllowThreads(__tstate);
31458 if (PyErr_Occurred()) SWIG_fail;
31459 }
31460 resultobj = SWIG_Py_Void();
31461 return resultobj;
31462 fail:
31463 return NULL;
31464 }
31465
31466
31467 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31468 PyObject *resultobj = 0;
31469 wxWindow *arg1 = (wxWindow *) 0 ;
31470 int arg2 ;
31471 int arg3 ;
31472 int arg4 ;
31473 int arg5 ;
31474 int arg6 = (int) wxSIZE_AUTO ;
31475 void *argp1 = 0 ;
31476 int res1 = 0 ;
31477 int val2 ;
31478 int ecode2 = 0 ;
31479 int val3 ;
31480 int ecode3 = 0 ;
31481 int val4 ;
31482 int ecode4 = 0 ;
31483 int val5 ;
31484 int ecode5 = 0 ;
31485 int val6 ;
31486 int ecode6 = 0 ;
31487 PyObject * obj0 = 0 ;
31488 PyObject * obj1 = 0 ;
31489 PyObject * obj2 = 0 ;
31490 PyObject * obj3 = 0 ;
31491 PyObject * obj4 = 0 ;
31492 PyObject * obj5 = 0 ;
31493 char * kwnames[] = {
31494 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
31495 };
31496
31497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
31498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31499 if (!SWIG_IsOK(res1)) {
31500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
31501 }
31502 arg1 = reinterpret_cast< wxWindow * >(argp1);
31503 ecode2 = SWIG_AsVal_int(obj1, &val2);
31504 if (!SWIG_IsOK(ecode2)) {
31505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
31506 }
31507 arg2 = static_cast< int >(val2);
31508 ecode3 = SWIG_AsVal_int(obj2, &val3);
31509 if (!SWIG_IsOK(ecode3)) {
31510 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
31511 }
31512 arg3 = static_cast< int >(val3);
31513 ecode4 = SWIG_AsVal_int(obj3, &val4);
31514 if (!SWIG_IsOK(ecode4)) {
31515 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
31516 }
31517 arg4 = static_cast< int >(val4);
31518 ecode5 = SWIG_AsVal_int(obj4, &val5);
31519 if (!SWIG_IsOK(ecode5)) {
31520 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
31521 }
31522 arg5 = static_cast< int >(val5);
31523 if (obj5) {
31524 ecode6 = SWIG_AsVal_int(obj5, &val6);
31525 if (!SWIG_IsOK(ecode6)) {
31526 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
31527 }
31528 arg6 = static_cast< int >(val6);
31529 }
31530 {
31531 PyThreadState* __tstate = wxPyBeginAllowThreads();
31532 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
31533 wxPyEndAllowThreads(__tstate);
31534 if (PyErr_Occurred()) SWIG_fail;
31535 }
31536 resultobj = SWIG_Py_Void();
31537 return resultobj;
31538 fail:
31539 return NULL;
31540 }
31541
31542
31543 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31544 PyObject *resultobj = 0;
31545 wxWindow *arg1 = (wxWindow *) 0 ;
31546 wxRect *arg2 = 0 ;
31547 int arg3 = (int) wxSIZE_AUTO ;
31548 void *argp1 = 0 ;
31549 int res1 = 0 ;
31550 wxRect temp2 ;
31551 int val3 ;
31552 int ecode3 = 0 ;
31553 PyObject * obj0 = 0 ;
31554 PyObject * obj1 = 0 ;
31555 PyObject * obj2 = 0 ;
31556 char * kwnames[] = {
31557 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
31558 };
31559
31560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31562 if (!SWIG_IsOK(res1)) {
31563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31564 }
31565 arg1 = reinterpret_cast< wxWindow * >(argp1);
31566 {
31567 arg2 = &temp2;
31568 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31569 }
31570 if (obj2) {
31571 ecode3 = SWIG_AsVal_int(obj2, &val3);
31572 if (!SWIG_IsOK(ecode3)) {
31573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
31574 }
31575 arg3 = static_cast< int >(val3);
31576 }
31577 {
31578 PyThreadState* __tstate = wxPyBeginAllowThreads();
31579 (arg1)->SetSize((wxRect const &)*arg2,arg3);
31580 wxPyEndAllowThreads(__tstate);
31581 if (PyErr_Occurred()) SWIG_fail;
31582 }
31583 resultobj = SWIG_Py_Void();
31584 return resultobj;
31585 fail:
31586 return NULL;
31587 }
31588
31589
31590 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31591 PyObject *resultobj = 0;
31592 wxWindow *arg1 = (wxWindow *) 0 ;
31593 int arg2 ;
31594 int arg3 ;
31595 void *argp1 = 0 ;
31596 int res1 = 0 ;
31597 int val2 ;
31598 int ecode2 = 0 ;
31599 int val3 ;
31600 int ecode3 = 0 ;
31601 PyObject * obj0 = 0 ;
31602 PyObject * obj1 = 0 ;
31603 PyObject * obj2 = 0 ;
31604 char * kwnames[] = {
31605 (char *) "self",(char *) "width",(char *) "height", NULL
31606 };
31607
31608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31610 if (!SWIG_IsOK(res1)) {
31611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31612 }
31613 arg1 = reinterpret_cast< wxWindow * >(argp1);
31614 ecode2 = SWIG_AsVal_int(obj1, &val2);
31615 if (!SWIG_IsOK(ecode2)) {
31616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
31617 }
31618 arg2 = static_cast< int >(val2);
31619 ecode3 = SWIG_AsVal_int(obj2, &val3);
31620 if (!SWIG_IsOK(ecode3)) {
31621 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
31622 }
31623 arg3 = static_cast< int >(val3);
31624 {
31625 PyThreadState* __tstate = wxPyBeginAllowThreads();
31626 (arg1)->SetSize(arg2,arg3);
31627 wxPyEndAllowThreads(__tstate);
31628 if (PyErr_Occurred()) SWIG_fail;
31629 }
31630 resultobj = SWIG_Py_Void();
31631 return resultobj;
31632 fail:
31633 return NULL;
31634 }
31635
31636
31637 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31638 PyObject *resultobj = 0;
31639 wxWindow *arg1 = (wxWindow *) 0 ;
31640 wxPoint *arg2 = 0 ;
31641 int arg3 = (int) wxSIZE_USE_EXISTING ;
31642 void *argp1 = 0 ;
31643 int res1 = 0 ;
31644 wxPoint temp2 ;
31645 int val3 ;
31646 int ecode3 = 0 ;
31647 PyObject * obj0 = 0 ;
31648 PyObject * obj1 = 0 ;
31649 PyObject * obj2 = 0 ;
31650 char * kwnames[] = {
31651 (char *) "self",(char *) "pt",(char *) "flags", NULL
31652 };
31653
31654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31656 if (!SWIG_IsOK(res1)) {
31657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
31658 }
31659 arg1 = reinterpret_cast< wxWindow * >(argp1);
31660 {
31661 arg2 = &temp2;
31662 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31663 }
31664 if (obj2) {
31665 ecode3 = SWIG_AsVal_int(obj2, &val3);
31666 if (!SWIG_IsOK(ecode3)) {
31667 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
31668 }
31669 arg3 = static_cast< int >(val3);
31670 }
31671 {
31672 PyThreadState* __tstate = wxPyBeginAllowThreads();
31673 (arg1)->Move((wxPoint const &)*arg2,arg3);
31674 wxPyEndAllowThreads(__tstate);
31675 if (PyErr_Occurred()) SWIG_fail;
31676 }
31677 resultobj = SWIG_Py_Void();
31678 return resultobj;
31679 fail:
31680 return NULL;
31681 }
31682
31683
31684 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31685 PyObject *resultobj = 0;
31686 wxWindow *arg1 = (wxWindow *) 0 ;
31687 int arg2 ;
31688 int arg3 ;
31689 int arg4 = (int) wxSIZE_USE_EXISTING ;
31690 void *argp1 = 0 ;
31691 int res1 = 0 ;
31692 int val2 ;
31693 int ecode2 = 0 ;
31694 int val3 ;
31695 int ecode3 = 0 ;
31696 int val4 ;
31697 int ecode4 = 0 ;
31698 PyObject * obj0 = 0 ;
31699 PyObject * obj1 = 0 ;
31700 PyObject * obj2 = 0 ;
31701 PyObject * obj3 = 0 ;
31702 char * kwnames[] = {
31703 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
31704 };
31705
31706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31708 if (!SWIG_IsOK(res1)) {
31709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
31710 }
31711 arg1 = reinterpret_cast< wxWindow * >(argp1);
31712 ecode2 = SWIG_AsVal_int(obj1, &val2);
31713 if (!SWIG_IsOK(ecode2)) {
31714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
31715 }
31716 arg2 = static_cast< int >(val2);
31717 ecode3 = SWIG_AsVal_int(obj2, &val3);
31718 if (!SWIG_IsOK(ecode3)) {
31719 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
31720 }
31721 arg3 = static_cast< int >(val3);
31722 if (obj3) {
31723 ecode4 = SWIG_AsVal_int(obj3, &val4);
31724 if (!SWIG_IsOK(ecode4)) {
31725 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
31726 }
31727 arg4 = static_cast< int >(val4);
31728 }
31729 {
31730 PyThreadState* __tstate = wxPyBeginAllowThreads();
31731 (arg1)->Move(arg2,arg3,arg4);
31732 wxPyEndAllowThreads(__tstate);
31733 if (PyErr_Occurred()) SWIG_fail;
31734 }
31735 resultobj = SWIG_Py_Void();
31736 return resultobj;
31737 fail:
31738 return NULL;
31739 }
31740
31741
31742 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31743 PyObject *resultobj = 0;
31744 wxWindow *arg1 = (wxWindow *) 0 ;
31745 wxSize const &arg2_defvalue = wxDefaultSize ;
31746 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
31747 void *argp1 = 0 ;
31748 int res1 = 0 ;
31749 wxSize temp2 ;
31750 PyObject * obj0 = 0 ;
31751 PyObject * obj1 = 0 ;
31752 char * kwnames[] = {
31753 (char *) "self",(char *) "size", NULL
31754 };
31755
31756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
31757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31758 if (!SWIG_IsOK(res1)) {
31759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31760 }
31761 arg1 = reinterpret_cast< wxWindow * >(argp1);
31762 if (obj1) {
31763 {
31764 arg2 = &temp2;
31765 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31766 }
31767 }
31768 {
31769 PyThreadState* __tstate = wxPyBeginAllowThreads();
31770 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
31771 wxPyEndAllowThreads(__tstate);
31772 if (PyErr_Occurred()) SWIG_fail;
31773 }
31774 resultobj = SWIG_Py_Void();
31775 return resultobj;
31776 fail:
31777 return NULL;
31778 }
31779
31780
31781 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31782 PyObject *resultobj = 0;
31783 wxWindow *arg1 = (wxWindow *) 0 ;
31784 void *argp1 = 0 ;
31785 int res1 = 0 ;
31786 PyObject *swig_obj[1] ;
31787
31788 if (!args) SWIG_fail;
31789 swig_obj[0] = args;
31790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31791 if (!SWIG_IsOK(res1)) {
31792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
31793 }
31794 arg1 = reinterpret_cast< wxWindow * >(argp1);
31795 {
31796 PyThreadState* __tstate = wxPyBeginAllowThreads();
31797 (arg1)->Raise();
31798 wxPyEndAllowThreads(__tstate);
31799 if (PyErr_Occurred()) SWIG_fail;
31800 }
31801 resultobj = SWIG_Py_Void();
31802 return resultobj;
31803 fail:
31804 return NULL;
31805 }
31806
31807
31808 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31809 PyObject *resultobj = 0;
31810 wxWindow *arg1 = (wxWindow *) 0 ;
31811 void *argp1 = 0 ;
31812 int res1 = 0 ;
31813 PyObject *swig_obj[1] ;
31814
31815 if (!args) SWIG_fail;
31816 swig_obj[0] = args;
31817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31818 if (!SWIG_IsOK(res1)) {
31819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
31820 }
31821 arg1 = reinterpret_cast< wxWindow * >(argp1);
31822 {
31823 PyThreadState* __tstate = wxPyBeginAllowThreads();
31824 (arg1)->Lower();
31825 wxPyEndAllowThreads(__tstate);
31826 if (PyErr_Occurred()) SWIG_fail;
31827 }
31828 resultobj = SWIG_Py_Void();
31829 return resultobj;
31830 fail:
31831 return NULL;
31832 }
31833
31834
31835 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31836 PyObject *resultobj = 0;
31837 wxWindow *arg1 = (wxWindow *) 0 ;
31838 wxSize *arg2 = 0 ;
31839 void *argp1 = 0 ;
31840 int res1 = 0 ;
31841 wxSize temp2 ;
31842 PyObject * obj0 = 0 ;
31843 PyObject * obj1 = 0 ;
31844 char * kwnames[] = {
31845 (char *) "self",(char *) "size", NULL
31846 };
31847
31848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
31849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31850 if (!SWIG_IsOK(res1)) {
31851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31852 }
31853 arg1 = reinterpret_cast< wxWindow * >(argp1);
31854 {
31855 arg2 = &temp2;
31856 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31857 }
31858 {
31859 PyThreadState* __tstate = wxPyBeginAllowThreads();
31860 (arg1)->SetClientSize((wxSize const &)*arg2);
31861 wxPyEndAllowThreads(__tstate);
31862 if (PyErr_Occurred()) SWIG_fail;
31863 }
31864 resultobj = SWIG_Py_Void();
31865 return resultobj;
31866 fail:
31867 return NULL;
31868 }
31869
31870
31871 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31872 PyObject *resultobj = 0;
31873 wxWindow *arg1 = (wxWindow *) 0 ;
31874 int arg2 ;
31875 int arg3 ;
31876 void *argp1 = 0 ;
31877 int res1 = 0 ;
31878 int val2 ;
31879 int ecode2 = 0 ;
31880 int val3 ;
31881 int ecode3 = 0 ;
31882 PyObject * obj0 = 0 ;
31883 PyObject * obj1 = 0 ;
31884 PyObject * obj2 = 0 ;
31885 char * kwnames[] = {
31886 (char *) "self",(char *) "width",(char *) "height", NULL
31887 };
31888
31889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31891 if (!SWIG_IsOK(res1)) {
31892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31893 }
31894 arg1 = reinterpret_cast< wxWindow * >(argp1);
31895 ecode2 = SWIG_AsVal_int(obj1, &val2);
31896 if (!SWIG_IsOK(ecode2)) {
31897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
31898 }
31899 arg2 = static_cast< int >(val2);
31900 ecode3 = SWIG_AsVal_int(obj2, &val3);
31901 if (!SWIG_IsOK(ecode3)) {
31902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
31903 }
31904 arg3 = static_cast< int >(val3);
31905 {
31906 PyThreadState* __tstate = wxPyBeginAllowThreads();
31907 (arg1)->SetClientSize(arg2,arg3);
31908 wxPyEndAllowThreads(__tstate);
31909 if (PyErr_Occurred()) SWIG_fail;
31910 }
31911 resultobj = SWIG_Py_Void();
31912 return resultobj;
31913 fail:
31914 return NULL;
31915 }
31916
31917
31918 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31919 PyObject *resultobj = 0;
31920 wxWindow *arg1 = (wxWindow *) 0 ;
31921 wxRect *arg2 = 0 ;
31922 void *argp1 = 0 ;
31923 int res1 = 0 ;
31924 wxRect temp2 ;
31925 PyObject * obj0 = 0 ;
31926 PyObject * obj1 = 0 ;
31927 char * kwnames[] = {
31928 (char *) "self",(char *) "rect", NULL
31929 };
31930
31931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
31932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31933 if (!SWIG_IsOK(res1)) {
31934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31935 }
31936 arg1 = reinterpret_cast< wxWindow * >(argp1);
31937 {
31938 arg2 = &temp2;
31939 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31940 }
31941 {
31942 PyThreadState* __tstate = wxPyBeginAllowThreads();
31943 (arg1)->SetClientSize((wxRect const &)*arg2);
31944 wxPyEndAllowThreads(__tstate);
31945 if (PyErr_Occurred()) SWIG_fail;
31946 }
31947 resultobj = SWIG_Py_Void();
31948 return resultobj;
31949 fail:
31950 return NULL;
31951 }
31952
31953
31954 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31955 PyObject *resultobj = 0;
31956 wxWindow *arg1 = (wxWindow *) 0 ;
31957 wxPoint result;
31958 void *argp1 = 0 ;
31959 int res1 = 0 ;
31960 PyObject *swig_obj[1] ;
31961
31962 if (!args) SWIG_fail;
31963 swig_obj[0] = args;
31964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31965 if (!SWIG_IsOK(res1)) {
31966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31967 }
31968 arg1 = reinterpret_cast< wxWindow * >(argp1);
31969 {
31970 PyThreadState* __tstate = wxPyBeginAllowThreads();
31971 result = ((wxWindow const *)arg1)->GetPosition();
31972 wxPyEndAllowThreads(__tstate);
31973 if (PyErr_Occurred()) SWIG_fail;
31974 }
31975 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31976 return resultobj;
31977 fail:
31978 return NULL;
31979 }
31980
31981
31982 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31983 PyObject *resultobj = 0;
31984 wxWindow *arg1 = (wxWindow *) 0 ;
31985 int *arg2 = (int *) 0 ;
31986 int *arg3 = (int *) 0 ;
31987 void *argp1 = 0 ;
31988 int res1 = 0 ;
31989 int temp2 ;
31990 int res2 = SWIG_TMPOBJ ;
31991 int temp3 ;
31992 int res3 = SWIG_TMPOBJ ;
31993 PyObject *swig_obj[1] ;
31994
31995 arg2 = &temp2;
31996 arg3 = &temp3;
31997 if (!args) SWIG_fail;
31998 swig_obj[0] = args;
31999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32000 if (!SWIG_IsOK(res1)) {
32001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32002 }
32003 arg1 = reinterpret_cast< wxWindow * >(argp1);
32004 {
32005 PyThreadState* __tstate = wxPyBeginAllowThreads();
32006 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
32007 wxPyEndAllowThreads(__tstate);
32008 if (PyErr_Occurred()) SWIG_fail;
32009 }
32010 resultobj = SWIG_Py_Void();
32011 if (SWIG_IsTmpObj(res2)) {
32012 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32013 } else {
32014 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32015 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32016 }
32017 if (SWIG_IsTmpObj(res3)) {
32018 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32019 } else {
32020 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32021 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32022 }
32023 return resultobj;
32024 fail:
32025 return NULL;
32026 }
32027
32028
32029 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32030 PyObject *resultobj = 0;
32031 wxWindow *arg1 = (wxWindow *) 0 ;
32032 wxPoint result;
32033 void *argp1 = 0 ;
32034 int res1 = 0 ;
32035 PyObject *swig_obj[1] ;
32036
32037 if (!args) SWIG_fail;
32038 swig_obj[0] = args;
32039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32040 if (!SWIG_IsOK(res1)) {
32041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
32042 }
32043 arg1 = reinterpret_cast< wxWindow * >(argp1);
32044 {
32045 PyThreadState* __tstate = wxPyBeginAllowThreads();
32046 result = ((wxWindow const *)arg1)->GetScreenPosition();
32047 wxPyEndAllowThreads(__tstate);
32048 if (PyErr_Occurred()) SWIG_fail;
32049 }
32050 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
32051 return resultobj;
32052 fail:
32053 return NULL;
32054 }
32055
32056
32057 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32058 PyObject *resultobj = 0;
32059 wxWindow *arg1 = (wxWindow *) 0 ;
32060 int *arg2 = (int *) 0 ;
32061 int *arg3 = (int *) 0 ;
32062 void *argp1 = 0 ;
32063 int res1 = 0 ;
32064 int temp2 ;
32065 int res2 = SWIG_TMPOBJ ;
32066 int temp3 ;
32067 int res3 = SWIG_TMPOBJ ;
32068 PyObject *swig_obj[1] ;
32069
32070 arg2 = &temp2;
32071 arg3 = &temp3;
32072 if (!args) SWIG_fail;
32073 swig_obj[0] = args;
32074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32075 if (!SWIG_IsOK(res1)) {
32076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32077 }
32078 arg1 = reinterpret_cast< wxWindow * >(argp1);
32079 {
32080 PyThreadState* __tstate = wxPyBeginAllowThreads();
32081 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
32082 wxPyEndAllowThreads(__tstate);
32083 if (PyErr_Occurred()) SWIG_fail;
32084 }
32085 resultobj = SWIG_Py_Void();
32086 if (SWIG_IsTmpObj(res2)) {
32087 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32088 } else {
32089 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32090 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32091 }
32092 if (SWIG_IsTmpObj(res3)) {
32093 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32094 } else {
32095 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32096 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32097 }
32098 return resultobj;
32099 fail:
32100 return NULL;
32101 }
32102
32103
32104 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32105 PyObject *resultobj = 0;
32106 wxWindow *arg1 = (wxWindow *) 0 ;
32107 wxRect result;
32108 void *argp1 = 0 ;
32109 int res1 = 0 ;
32110 PyObject *swig_obj[1] ;
32111
32112 if (!args) SWIG_fail;
32113 swig_obj[0] = args;
32114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32115 if (!SWIG_IsOK(res1)) {
32116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32117 }
32118 arg1 = reinterpret_cast< wxWindow * >(argp1);
32119 {
32120 PyThreadState* __tstate = wxPyBeginAllowThreads();
32121 result = ((wxWindow const *)arg1)->GetScreenRect();
32122 wxPyEndAllowThreads(__tstate);
32123 if (PyErr_Occurred()) SWIG_fail;
32124 }
32125 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32126 return resultobj;
32127 fail:
32128 return NULL;
32129 }
32130
32131
32132 SWIGINTERN PyObject *_wrap_Window_GetSize(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_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32145 }
32146 arg1 = reinterpret_cast< wxWindow * >(argp1);
32147 {
32148 PyThreadState* __tstate = wxPyBeginAllowThreads();
32149 result = ((wxWindow const *)arg1)->GetSize();
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_GetSizeTuple(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_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32180 }
32181 arg1 = reinterpret_cast< wxWindow * >(argp1);
32182 {
32183 PyThreadState* __tstate = wxPyBeginAllowThreads();
32184 ((wxWindow const *)arg1)->GetSize(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_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32208 PyObject *resultobj = 0;
32209 wxWindow *arg1 = (wxWindow *) 0 ;
32210 wxRect 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_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32220 }
32221 arg1 = reinterpret_cast< wxWindow * >(argp1);
32222 {
32223 PyThreadState* __tstate = wxPyBeginAllowThreads();
32224 result = ((wxWindow const *)arg1)->GetRect();
32225 wxPyEndAllowThreads(__tstate);
32226 if (PyErr_Occurred()) SWIG_fail;
32227 }
32228 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32229 return resultobj;
32230 fail:
32231 return NULL;
32232 }
32233
32234
32235 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32236 PyObject *resultobj = 0;
32237 wxWindow *arg1 = (wxWindow *) 0 ;
32238 wxSize result;
32239 void *argp1 = 0 ;
32240 int res1 = 0 ;
32241 PyObject *swig_obj[1] ;
32242
32243 if (!args) SWIG_fail;
32244 swig_obj[0] = args;
32245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32246 if (!SWIG_IsOK(res1)) {
32247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32248 }
32249 arg1 = reinterpret_cast< wxWindow * >(argp1);
32250 {
32251 PyThreadState* __tstate = wxPyBeginAllowThreads();
32252 result = ((wxWindow const *)arg1)->GetClientSize();
32253 wxPyEndAllowThreads(__tstate);
32254 if (PyErr_Occurred()) SWIG_fail;
32255 }
32256 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32257 return resultobj;
32258 fail:
32259 return NULL;
32260 }
32261
32262
32263 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32264 PyObject *resultobj = 0;
32265 wxWindow *arg1 = (wxWindow *) 0 ;
32266 int *arg2 = (int *) 0 ;
32267 int *arg3 = (int *) 0 ;
32268 void *argp1 = 0 ;
32269 int res1 = 0 ;
32270 int temp2 ;
32271 int res2 = SWIG_TMPOBJ ;
32272 int temp3 ;
32273 int res3 = SWIG_TMPOBJ ;
32274 PyObject *swig_obj[1] ;
32275
32276 arg2 = &temp2;
32277 arg3 = &temp3;
32278 if (!args) SWIG_fail;
32279 swig_obj[0] = args;
32280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32281 if (!SWIG_IsOK(res1)) {
32282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32283 }
32284 arg1 = reinterpret_cast< wxWindow * >(argp1);
32285 {
32286 PyThreadState* __tstate = wxPyBeginAllowThreads();
32287 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
32288 wxPyEndAllowThreads(__tstate);
32289 if (PyErr_Occurred()) SWIG_fail;
32290 }
32291 resultobj = SWIG_Py_Void();
32292 if (SWIG_IsTmpObj(res2)) {
32293 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32294 } else {
32295 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32296 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32297 }
32298 if (SWIG_IsTmpObj(res3)) {
32299 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32300 } else {
32301 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32302 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32303 }
32304 return resultobj;
32305 fail:
32306 return NULL;
32307 }
32308
32309
32310 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32311 PyObject *resultobj = 0;
32312 wxWindow *arg1 = (wxWindow *) 0 ;
32313 wxPoint result;
32314 void *argp1 = 0 ;
32315 int res1 = 0 ;
32316 PyObject *swig_obj[1] ;
32317
32318 if (!args) SWIG_fail;
32319 swig_obj[0] = args;
32320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32321 if (!SWIG_IsOK(res1)) {
32322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
32323 }
32324 arg1 = reinterpret_cast< wxWindow * >(argp1);
32325 {
32326 PyThreadState* __tstate = wxPyBeginAllowThreads();
32327 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
32328 wxPyEndAllowThreads(__tstate);
32329 if (PyErr_Occurred()) SWIG_fail;
32330 }
32331 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
32332 return resultobj;
32333 fail:
32334 return NULL;
32335 }
32336
32337
32338 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32339 PyObject *resultobj = 0;
32340 wxWindow *arg1 = (wxWindow *) 0 ;
32341 wxRect result;
32342 void *argp1 = 0 ;
32343 int res1 = 0 ;
32344 PyObject *swig_obj[1] ;
32345
32346 if (!args) SWIG_fail;
32347 swig_obj[0] = args;
32348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32349 if (!SWIG_IsOK(res1)) {
32350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32351 }
32352 arg1 = reinterpret_cast< wxWindow * >(argp1);
32353 {
32354 PyThreadState* __tstate = wxPyBeginAllowThreads();
32355 result = ((wxWindow const *)arg1)->GetClientRect();
32356 wxPyEndAllowThreads(__tstate);
32357 if (PyErr_Occurred()) SWIG_fail;
32358 }
32359 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32360 return resultobj;
32361 fail:
32362 return NULL;
32363 }
32364
32365
32366 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32367 PyObject *resultobj = 0;
32368 wxWindow *arg1 = (wxWindow *) 0 ;
32369 wxSize result;
32370 void *argp1 = 0 ;
32371 int res1 = 0 ;
32372 PyObject *swig_obj[1] ;
32373
32374 if (!args) SWIG_fail;
32375 swig_obj[0] = args;
32376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32377 if (!SWIG_IsOK(res1)) {
32378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32379 }
32380 arg1 = reinterpret_cast< wxWindow * >(argp1);
32381 {
32382 PyThreadState* __tstate = wxPyBeginAllowThreads();
32383 result = ((wxWindow const *)arg1)->GetBestSize();
32384 wxPyEndAllowThreads(__tstate);
32385 if (PyErr_Occurred()) SWIG_fail;
32386 }
32387 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32388 return resultobj;
32389 fail:
32390 return NULL;
32391 }
32392
32393
32394 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32395 PyObject *resultobj = 0;
32396 wxWindow *arg1 = (wxWindow *) 0 ;
32397 int *arg2 = (int *) 0 ;
32398 int *arg3 = (int *) 0 ;
32399 void *argp1 = 0 ;
32400 int res1 = 0 ;
32401 int temp2 ;
32402 int res2 = SWIG_TMPOBJ ;
32403 int temp3 ;
32404 int res3 = SWIG_TMPOBJ ;
32405 PyObject *swig_obj[1] ;
32406
32407 arg2 = &temp2;
32408 arg3 = &temp3;
32409 if (!args) SWIG_fail;
32410 swig_obj[0] = args;
32411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32412 if (!SWIG_IsOK(res1)) {
32413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32414 }
32415 arg1 = reinterpret_cast< wxWindow * >(argp1);
32416 {
32417 PyThreadState* __tstate = wxPyBeginAllowThreads();
32418 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
32419 wxPyEndAllowThreads(__tstate);
32420 if (PyErr_Occurred()) SWIG_fail;
32421 }
32422 resultobj = SWIG_Py_Void();
32423 if (SWIG_IsTmpObj(res2)) {
32424 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32425 } else {
32426 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32427 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32428 }
32429 if (SWIG_IsTmpObj(res3)) {
32430 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32431 } else {
32432 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32433 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32434 }
32435 return resultobj;
32436 fail:
32437 return NULL;
32438 }
32439
32440
32441 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32442 PyObject *resultobj = 0;
32443 wxWindow *arg1 = (wxWindow *) 0 ;
32444 void *argp1 = 0 ;
32445 int res1 = 0 ;
32446 PyObject *swig_obj[1] ;
32447
32448 if (!args) SWIG_fail;
32449 swig_obj[0] = args;
32450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32451 if (!SWIG_IsOK(res1)) {
32452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32453 }
32454 arg1 = reinterpret_cast< wxWindow * >(argp1);
32455 {
32456 PyThreadState* __tstate = wxPyBeginAllowThreads();
32457 (arg1)->InvalidateBestSize();
32458 wxPyEndAllowThreads(__tstate);
32459 if (PyErr_Occurred()) SWIG_fail;
32460 }
32461 resultobj = SWIG_Py_Void();
32462 return resultobj;
32463 fail:
32464 return NULL;
32465 }
32466
32467
32468 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32469 PyObject *resultobj = 0;
32470 wxWindow *arg1 = (wxWindow *) 0 ;
32471 wxSize *arg2 = 0 ;
32472 void *argp1 = 0 ;
32473 int res1 = 0 ;
32474 wxSize temp2 ;
32475 PyObject * obj0 = 0 ;
32476 PyObject * obj1 = 0 ;
32477 char * kwnames[] = {
32478 (char *) "self",(char *) "size", NULL
32479 };
32480
32481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
32482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32483 if (!SWIG_IsOK(res1)) {
32484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32485 }
32486 arg1 = reinterpret_cast< wxWindow * >(argp1);
32487 {
32488 arg2 = &temp2;
32489 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32490 }
32491 {
32492 PyThreadState* __tstate = wxPyBeginAllowThreads();
32493 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
32494 wxPyEndAllowThreads(__tstate);
32495 if (PyErr_Occurred()) SWIG_fail;
32496 }
32497 resultobj = SWIG_Py_Void();
32498 return resultobj;
32499 fail:
32500 return NULL;
32501 }
32502
32503
32504 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32505 PyObject *resultobj = 0;
32506 wxWindow *arg1 = (wxWindow *) 0 ;
32507 wxSize result;
32508 void *argp1 = 0 ;
32509 int res1 = 0 ;
32510 PyObject *swig_obj[1] ;
32511
32512 if (!args) SWIG_fail;
32513 swig_obj[0] = args;
32514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32515 if (!SWIG_IsOK(res1)) {
32516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32517 }
32518 arg1 = reinterpret_cast< wxWindow * >(argp1);
32519 {
32520 PyThreadState* __tstate = wxPyBeginAllowThreads();
32521 result = ((wxWindow const *)arg1)->GetBestFittingSize();
32522 wxPyEndAllowThreads(__tstate);
32523 if (PyErr_Occurred()) SWIG_fail;
32524 }
32525 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32526 return resultobj;
32527 fail:
32528 return NULL;
32529 }
32530
32531
32532 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32533 PyObject *resultobj = 0;
32534 wxWindow *arg1 = (wxWindow *) 0 ;
32535 wxSize result;
32536 void *argp1 = 0 ;
32537 int res1 = 0 ;
32538 PyObject *swig_obj[1] ;
32539
32540 if (!args) SWIG_fail;
32541 swig_obj[0] = args;
32542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32543 if (!SWIG_IsOK(res1)) {
32544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32545 }
32546 arg1 = reinterpret_cast< wxWindow * >(argp1);
32547 {
32548 PyThreadState* __tstate = wxPyBeginAllowThreads();
32549 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
32550 wxPyEndAllowThreads(__tstate);
32551 if (PyErr_Occurred()) SWIG_fail;
32552 }
32553 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32554 return resultobj;
32555 fail:
32556 return NULL;
32557 }
32558
32559
32560 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32561 PyObject *resultobj = 0;
32562 wxWindow *arg1 = (wxWindow *) 0 ;
32563 int arg2 = (int) wxBOTH ;
32564 void *argp1 = 0 ;
32565 int res1 = 0 ;
32566 int val2 ;
32567 int ecode2 = 0 ;
32568 PyObject * obj0 = 0 ;
32569 PyObject * obj1 = 0 ;
32570 char * kwnames[] = {
32571 (char *) "self",(char *) "direction", NULL
32572 };
32573
32574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
32575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32576 if (!SWIG_IsOK(res1)) {
32577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
32578 }
32579 arg1 = reinterpret_cast< wxWindow * >(argp1);
32580 if (obj1) {
32581 ecode2 = SWIG_AsVal_int(obj1, &val2);
32582 if (!SWIG_IsOK(ecode2)) {
32583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
32584 }
32585 arg2 = static_cast< int >(val2);
32586 }
32587 {
32588 PyThreadState* __tstate = wxPyBeginAllowThreads();
32589 (arg1)->Center(arg2);
32590 wxPyEndAllowThreads(__tstate);
32591 if (PyErr_Occurred()) SWIG_fail;
32592 }
32593 resultobj = SWIG_Py_Void();
32594 return resultobj;
32595 fail:
32596 return NULL;
32597 }
32598
32599
32600 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32601 PyObject *resultobj = 0;
32602 wxWindow *arg1 = (wxWindow *) 0 ;
32603 int arg2 = (int) wxBOTH ;
32604 void *argp1 = 0 ;
32605 int res1 = 0 ;
32606 int val2 ;
32607 int ecode2 = 0 ;
32608 PyObject * obj0 = 0 ;
32609 PyObject * obj1 = 0 ;
32610 char * kwnames[] = {
32611 (char *) "self",(char *) "dir", NULL
32612 };
32613
32614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
32615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32616 if (!SWIG_IsOK(res1)) {
32617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
32618 }
32619 arg1 = reinterpret_cast< wxWindow * >(argp1);
32620 if (obj1) {
32621 ecode2 = SWIG_AsVal_int(obj1, &val2);
32622 if (!SWIG_IsOK(ecode2)) {
32623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
32624 }
32625 arg2 = static_cast< int >(val2);
32626 }
32627 {
32628 PyThreadState* __tstate = wxPyBeginAllowThreads();
32629 (arg1)->CenterOnParent(arg2);
32630 wxPyEndAllowThreads(__tstate);
32631 if (PyErr_Occurred()) SWIG_fail;
32632 }
32633 resultobj = SWIG_Py_Void();
32634 return resultobj;
32635 fail:
32636 return NULL;
32637 }
32638
32639
32640 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32641 PyObject *resultobj = 0;
32642 wxWindow *arg1 = (wxWindow *) 0 ;
32643 void *argp1 = 0 ;
32644 int res1 = 0 ;
32645 PyObject *swig_obj[1] ;
32646
32647 if (!args) SWIG_fail;
32648 swig_obj[0] = args;
32649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32650 if (!SWIG_IsOK(res1)) {
32651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
32652 }
32653 arg1 = reinterpret_cast< wxWindow * >(argp1);
32654 {
32655 PyThreadState* __tstate = wxPyBeginAllowThreads();
32656 (arg1)->Fit();
32657 wxPyEndAllowThreads(__tstate);
32658 if (PyErr_Occurred()) SWIG_fail;
32659 }
32660 resultobj = SWIG_Py_Void();
32661 return resultobj;
32662 fail:
32663 return NULL;
32664 }
32665
32666
32667 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32668 PyObject *resultobj = 0;
32669 wxWindow *arg1 = (wxWindow *) 0 ;
32670 void *argp1 = 0 ;
32671 int res1 = 0 ;
32672 PyObject *swig_obj[1] ;
32673
32674 if (!args) SWIG_fail;
32675 swig_obj[0] = args;
32676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32677 if (!SWIG_IsOK(res1)) {
32678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
32679 }
32680 arg1 = reinterpret_cast< wxWindow * >(argp1);
32681 {
32682 PyThreadState* __tstate = wxPyBeginAllowThreads();
32683 (arg1)->FitInside();
32684 wxPyEndAllowThreads(__tstate);
32685 if (PyErr_Occurred()) SWIG_fail;
32686 }
32687 resultobj = SWIG_Py_Void();
32688 return resultobj;
32689 fail:
32690 return NULL;
32691 }
32692
32693
32694 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32695 PyObject *resultobj = 0;
32696 wxWindow *arg1 = (wxWindow *) 0 ;
32697 int arg2 ;
32698 int arg3 ;
32699 int arg4 = (int) -1 ;
32700 int arg5 = (int) -1 ;
32701 int arg6 = (int) -1 ;
32702 int arg7 = (int) -1 ;
32703 void *argp1 = 0 ;
32704 int res1 = 0 ;
32705 int val2 ;
32706 int ecode2 = 0 ;
32707 int val3 ;
32708 int ecode3 = 0 ;
32709 int val4 ;
32710 int ecode4 = 0 ;
32711 int val5 ;
32712 int ecode5 = 0 ;
32713 int val6 ;
32714 int ecode6 = 0 ;
32715 int val7 ;
32716 int ecode7 = 0 ;
32717 PyObject * obj0 = 0 ;
32718 PyObject * obj1 = 0 ;
32719 PyObject * obj2 = 0 ;
32720 PyObject * obj3 = 0 ;
32721 PyObject * obj4 = 0 ;
32722 PyObject * obj5 = 0 ;
32723 PyObject * obj6 = 0 ;
32724 char * kwnames[] = {
32725 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
32726 };
32727
32728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32730 if (!SWIG_IsOK(res1)) {
32731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32732 }
32733 arg1 = reinterpret_cast< wxWindow * >(argp1);
32734 ecode2 = SWIG_AsVal_int(obj1, &val2);
32735 if (!SWIG_IsOK(ecode2)) {
32736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
32737 }
32738 arg2 = static_cast< int >(val2);
32739 ecode3 = SWIG_AsVal_int(obj2, &val3);
32740 if (!SWIG_IsOK(ecode3)) {
32741 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
32742 }
32743 arg3 = static_cast< int >(val3);
32744 if (obj3) {
32745 ecode4 = SWIG_AsVal_int(obj3, &val4);
32746 if (!SWIG_IsOK(ecode4)) {
32747 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
32748 }
32749 arg4 = static_cast< int >(val4);
32750 }
32751 if (obj4) {
32752 ecode5 = SWIG_AsVal_int(obj4, &val5);
32753 if (!SWIG_IsOK(ecode5)) {
32754 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
32755 }
32756 arg5 = static_cast< int >(val5);
32757 }
32758 if (obj5) {
32759 ecode6 = SWIG_AsVal_int(obj5, &val6);
32760 if (!SWIG_IsOK(ecode6)) {
32761 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
32762 }
32763 arg6 = static_cast< int >(val6);
32764 }
32765 if (obj6) {
32766 ecode7 = SWIG_AsVal_int(obj6, &val7);
32767 if (!SWIG_IsOK(ecode7)) {
32768 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
32769 }
32770 arg7 = static_cast< int >(val7);
32771 }
32772 {
32773 PyThreadState* __tstate = wxPyBeginAllowThreads();
32774 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
32775 wxPyEndAllowThreads(__tstate);
32776 if (PyErr_Occurred()) SWIG_fail;
32777 }
32778 resultobj = SWIG_Py_Void();
32779 return resultobj;
32780 fail:
32781 return NULL;
32782 }
32783
32784
32785 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32786 PyObject *resultobj = 0;
32787 wxWindow *arg1 = (wxWindow *) 0 ;
32788 wxSize *arg2 = 0 ;
32789 wxSize const &arg3_defvalue = wxDefaultSize ;
32790 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32791 wxSize const &arg4_defvalue = wxDefaultSize ;
32792 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32793 void *argp1 = 0 ;
32794 int res1 = 0 ;
32795 wxSize temp2 ;
32796 wxSize temp3 ;
32797 wxSize temp4 ;
32798 PyObject * obj0 = 0 ;
32799 PyObject * obj1 = 0 ;
32800 PyObject * obj2 = 0 ;
32801 PyObject * obj3 = 0 ;
32802 char * kwnames[] = {
32803 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
32804 };
32805
32806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32808 if (!SWIG_IsOK(res1)) {
32809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32810 }
32811 arg1 = reinterpret_cast< wxWindow * >(argp1);
32812 {
32813 arg2 = &temp2;
32814 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32815 }
32816 if (obj2) {
32817 {
32818 arg3 = &temp3;
32819 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32820 }
32821 }
32822 if (obj3) {
32823 {
32824 arg4 = &temp4;
32825 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32826 }
32827 }
32828 {
32829 PyThreadState* __tstate = wxPyBeginAllowThreads();
32830 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
32831 wxPyEndAllowThreads(__tstate);
32832 if (PyErr_Occurred()) SWIG_fail;
32833 }
32834 resultobj = SWIG_Py_Void();
32835 return resultobj;
32836 fail:
32837 return NULL;
32838 }
32839
32840
32841 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32842 PyObject *resultobj = 0;
32843 wxWindow *arg1 = (wxWindow *) 0 ;
32844 int arg2 ;
32845 int arg3 ;
32846 int arg4 = (int) -1 ;
32847 int arg5 = (int) -1 ;
32848 void *argp1 = 0 ;
32849 int res1 = 0 ;
32850 int val2 ;
32851 int ecode2 = 0 ;
32852 int val3 ;
32853 int ecode3 = 0 ;
32854 int val4 ;
32855 int ecode4 = 0 ;
32856 int val5 ;
32857 int ecode5 = 0 ;
32858 PyObject * obj0 = 0 ;
32859 PyObject * obj1 = 0 ;
32860 PyObject * obj2 = 0 ;
32861 PyObject * obj3 = 0 ;
32862 PyObject * obj4 = 0 ;
32863 char * kwnames[] = {
32864 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
32865 };
32866
32867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
32868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32869 if (!SWIG_IsOK(res1)) {
32870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32871 }
32872 arg1 = reinterpret_cast< wxWindow * >(argp1);
32873 ecode2 = SWIG_AsVal_int(obj1, &val2);
32874 if (!SWIG_IsOK(ecode2)) {
32875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
32876 }
32877 arg2 = static_cast< int >(val2);
32878 ecode3 = SWIG_AsVal_int(obj2, &val3);
32879 if (!SWIG_IsOK(ecode3)) {
32880 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
32881 }
32882 arg3 = static_cast< int >(val3);
32883 if (obj3) {
32884 ecode4 = SWIG_AsVal_int(obj3, &val4);
32885 if (!SWIG_IsOK(ecode4)) {
32886 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
32887 }
32888 arg4 = static_cast< int >(val4);
32889 }
32890 if (obj4) {
32891 ecode5 = SWIG_AsVal_int(obj4, &val5);
32892 if (!SWIG_IsOK(ecode5)) {
32893 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
32894 }
32895 arg5 = static_cast< int >(val5);
32896 }
32897 {
32898 PyThreadState* __tstate = wxPyBeginAllowThreads();
32899 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
32900 wxPyEndAllowThreads(__tstate);
32901 if (PyErr_Occurred()) SWIG_fail;
32902 }
32903 resultobj = SWIG_Py_Void();
32904 return resultobj;
32905 fail:
32906 return NULL;
32907 }
32908
32909
32910 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32911 PyObject *resultobj = 0;
32912 wxWindow *arg1 = (wxWindow *) 0 ;
32913 wxSize *arg2 = 0 ;
32914 wxSize const &arg3_defvalue = wxDefaultSize ;
32915 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32916 void *argp1 = 0 ;
32917 int res1 = 0 ;
32918 wxSize temp2 ;
32919 wxSize temp3 ;
32920 PyObject * obj0 = 0 ;
32921 PyObject * obj1 = 0 ;
32922 PyObject * obj2 = 0 ;
32923 char * kwnames[] = {
32924 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
32925 };
32926
32927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32929 if (!SWIG_IsOK(res1)) {
32930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32931 }
32932 arg1 = reinterpret_cast< wxWindow * >(argp1);
32933 {
32934 arg2 = &temp2;
32935 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32936 }
32937 if (obj2) {
32938 {
32939 arg3 = &temp3;
32940 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32941 }
32942 }
32943 {
32944 PyThreadState* __tstate = wxPyBeginAllowThreads();
32945 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32946 wxPyEndAllowThreads(__tstate);
32947 if (PyErr_Occurred()) SWIG_fail;
32948 }
32949 resultobj = SWIG_Py_Void();
32950 return resultobj;
32951 fail:
32952 return NULL;
32953 }
32954
32955
32956 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32957 PyObject *resultobj = 0;
32958 wxWindow *arg1 = (wxWindow *) 0 ;
32959 wxSize result;
32960 void *argp1 = 0 ;
32961 int res1 = 0 ;
32962 PyObject *swig_obj[1] ;
32963
32964 if (!args) SWIG_fail;
32965 swig_obj[0] = args;
32966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32967 if (!SWIG_IsOK(res1)) {
32968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32969 }
32970 arg1 = reinterpret_cast< wxWindow * >(argp1);
32971 {
32972 PyThreadState* __tstate = wxPyBeginAllowThreads();
32973 result = ((wxWindow const *)arg1)->GetMaxSize();
32974 wxPyEndAllowThreads(__tstate);
32975 if (PyErr_Occurred()) SWIG_fail;
32976 }
32977 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32978 return resultobj;
32979 fail:
32980 return NULL;
32981 }
32982
32983
32984 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32985 PyObject *resultobj = 0;
32986 wxWindow *arg1 = (wxWindow *) 0 ;
32987 wxSize result;
32988 void *argp1 = 0 ;
32989 int res1 = 0 ;
32990 PyObject *swig_obj[1] ;
32991
32992 if (!args) SWIG_fail;
32993 swig_obj[0] = args;
32994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32995 if (!SWIG_IsOK(res1)) {
32996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32997 }
32998 arg1 = reinterpret_cast< wxWindow * >(argp1);
32999 {
33000 PyThreadState* __tstate = wxPyBeginAllowThreads();
33001 result = ((wxWindow const *)arg1)->GetMinSize();
33002 wxPyEndAllowThreads(__tstate);
33003 if (PyErr_Occurred()) SWIG_fail;
33004 }
33005 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33006 return resultobj;
33007 fail:
33008 return NULL;
33009 }
33010
33011
33012 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33013 PyObject *resultobj = 0;
33014 wxWindow *arg1 = (wxWindow *) 0 ;
33015 wxSize *arg2 = 0 ;
33016 void *argp1 = 0 ;
33017 int res1 = 0 ;
33018 wxSize temp2 ;
33019 PyObject * obj0 = 0 ;
33020 PyObject * obj1 = 0 ;
33021 char * kwnames[] = {
33022 (char *) "self",(char *) "minSize", NULL
33023 };
33024
33025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
33026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33027 if (!SWIG_IsOK(res1)) {
33028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33029 }
33030 arg1 = reinterpret_cast< wxWindow * >(argp1);
33031 {
33032 arg2 = &temp2;
33033 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33034 }
33035 {
33036 PyThreadState* __tstate = wxPyBeginAllowThreads();
33037 (arg1)->SetMinSize((wxSize const &)*arg2);
33038 wxPyEndAllowThreads(__tstate);
33039 if (PyErr_Occurred()) SWIG_fail;
33040 }
33041 resultobj = SWIG_Py_Void();
33042 return resultobj;
33043 fail:
33044 return NULL;
33045 }
33046
33047
33048 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33049 PyObject *resultobj = 0;
33050 wxWindow *arg1 = (wxWindow *) 0 ;
33051 wxSize *arg2 = 0 ;
33052 void *argp1 = 0 ;
33053 int res1 = 0 ;
33054 wxSize temp2 ;
33055 PyObject * obj0 = 0 ;
33056 PyObject * obj1 = 0 ;
33057 char * kwnames[] = {
33058 (char *) "self",(char *) "maxSize", NULL
33059 };
33060
33061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
33062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33063 if (!SWIG_IsOK(res1)) {
33064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33065 }
33066 arg1 = reinterpret_cast< wxWindow * >(argp1);
33067 {
33068 arg2 = &temp2;
33069 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33070 }
33071 {
33072 PyThreadState* __tstate = wxPyBeginAllowThreads();
33073 (arg1)->SetMaxSize((wxSize const &)*arg2);
33074 wxPyEndAllowThreads(__tstate);
33075 if (PyErr_Occurred()) SWIG_fail;
33076 }
33077 resultobj = SWIG_Py_Void();
33078 return resultobj;
33079 fail:
33080 return NULL;
33081 }
33082
33083
33084 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33085 PyObject *resultobj = 0;
33086 wxWindow *arg1 = (wxWindow *) 0 ;
33087 int result;
33088 void *argp1 = 0 ;
33089 int res1 = 0 ;
33090 PyObject *swig_obj[1] ;
33091
33092 if (!args) SWIG_fail;
33093 swig_obj[0] = args;
33094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33095 if (!SWIG_IsOK(res1)) {
33096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
33097 }
33098 arg1 = reinterpret_cast< wxWindow * >(argp1);
33099 {
33100 PyThreadState* __tstate = wxPyBeginAllowThreads();
33101 result = (int)((wxWindow const *)arg1)->GetMinWidth();
33102 wxPyEndAllowThreads(__tstate);
33103 if (PyErr_Occurred()) SWIG_fail;
33104 }
33105 resultobj = SWIG_From_int(static_cast< int >(result));
33106 return resultobj;
33107 fail:
33108 return NULL;
33109 }
33110
33111
33112 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33113 PyObject *resultobj = 0;
33114 wxWindow *arg1 = (wxWindow *) 0 ;
33115 int result;
33116 void *argp1 = 0 ;
33117 int res1 = 0 ;
33118 PyObject *swig_obj[1] ;
33119
33120 if (!args) SWIG_fail;
33121 swig_obj[0] = args;
33122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33123 if (!SWIG_IsOK(res1)) {
33124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
33125 }
33126 arg1 = reinterpret_cast< wxWindow * >(argp1);
33127 {
33128 PyThreadState* __tstate = wxPyBeginAllowThreads();
33129 result = (int)((wxWindow const *)arg1)->GetMinHeight();
33130 wxPyEndAllowThreads(__tstate);
33131 if (PyErr_Occurred()) SWIG_fail;
33132 }
33133 resultobj = SWIG_From_int(static_cast< int >(result));
33134 return resultobj;
33135 fail:
33136 return NULL;
33137 }
33138
33139
33140 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33141 PyObject *resultobj = 0;
33142 wxWindow *arg1 = (wxWindow *) 0 ;
33143 int result;
33144 void *argp1 = 0 ;
33145 int res1 = 0 ;
33146 PyObject *swig_obj[1] ;
33147
33148 if (!args) SWIG_fail;
33149 swig_obj[0] = args;
33150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33151 if (!SWIG_IsOK(res1)) {
33152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
33153 }
33154 arg1 = reinterpret_cast< wxWindow * >(argp1);
33155 {
33156 PyThreadState* __tstate = wxPyBeginAllowThreads();
33157 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
33158 wxPyEndAllowThreads(__tstate);
33159 if (PyErr_Occurred()) SWIG_fail;
33160 }
33161 resultobj = SWIG_From_int(static_cast< int >(result));
33162 return resultobj;
33163 fail:
33164 return NULL;
33165 }
33166
33167
33168 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33169 PyObject *resultobj = 0;
33170 wxWindow *arg1 = (wxWindow *) 0 ;
33171 int result;
33172 void *argp1 = 0 ;
33173 int res1 = 0 ;
33174 PyObject *swig_obj[1] ;
33175
33176 if (!args) SWIG_fail;
33177 swig_obj[0] = args;
33178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33179 if (!SWIG_IsOK(res1)) {
33180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
33181 }
33182 arg1 = reinterpret_cast< wxWindow * >(argp1);
33183 {
33184 PyThreadState* __tstate = wxPyBeginAllowThreads();
33185 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
33186 wxPyEndAllowThreads(__tstate);
33187 if (PyErr_Occurred()) SWIG_fail;
33188 }
33189 resultobj = SWIG_From_int(static_cast< int >(result));
33190 return resultobj;
33191 fail:
33192 return NULL;
33193 }
33194
33195
33196 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33197 PyObject *resultobj = 0;
33198 wxWindow *arg1 = (wxWindow *) 0 ;
33199 wxSize *arg2 = 0 ;
33200 void *argp1 = 0 ;
33201 int res1 = 0 ;
33202 wxSize temp2 ;
33203 PyObject * obj0 = 0 ;
33204 PyObject * obj1 = 0 ;
33205 char * kwnames[] = {
33206 (char *) "self",(char *) "size", NULL
33207 };
33208
33209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
33210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33211 if (!SWIG_IsOK(res1)) {
33212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33213 }
33214 arg1 = reinterpret_cast< wxWindow * >(argp1);
33215 {
33216 arg2 = &temp2;
33217 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33218 }
33219 {
33220 PyThreadState* __tstate = wxPyBeginAllowThreads();
33221 (arg1)->SetVirtualSize((wxSize const &)*arg2);
33222 wxPyEndAllowThreads(__tstate);
33223 if (PyErr_Occurred()) SWIG_fail;
33224 }
33225 resultobj = SWIG_Py_Void();
33226 return resultobj;
33227 fail:
33228 return NULL;
33229 }
33230
33231
33232 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33233 PyObject *resultobj = 0;
33234 wxWindow *arg1 = (wxWindow *) 0 ;
33235 int arg2 ;
33236 int arg3 ;
33237 void *argp1 = 0 ;
33238 int res1 = 0 ;
33239 int val2 ;
33240 int ecode2 = 0 ;
33241 int val3 ;
33242 int ecode3 = 0 ;
33243 PyObject * obj0 = 0 ;
33244 PyObject * obj1 = 0 ;
33245 PyObject * obj2 = 0 ;
33246 char * kwnames[] = {
33247 (char *) "self",(char *) "w",(char *) "h", NULL
33248 };
33249
33250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33252 if (!SWIG_IsOK(res1)) {
33253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33254 }
33255 arg1 = reinterpret_cast< wxWindow * >(argp1);
33256 ecode2 = SWIG_AsVal_int(obj1, &val2);
33257 if (!SWIG_IsOK(ecode2)) {
33258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
33259 }
33260 arg2 = static_cast< int >(val2);
33261 ecode3 = SWIG_AsVal_int(obj2, &val3);
33262 if (!SWIG_IsOK(ecode3)) {
33263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
33264 }
33265 arg3 = static_cast< int >(val3);
33266 {
33267 PyThreadState* __tstate = wxPyBeginAllowThreads();
33268 (arg1)->SetVirtualSize(arg2,arg3);
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_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33280 PyObject *resultobj = 0;
33281 wxWindow *arg1 = (wxWindow *) 0 ;
33282 wxSize result;
33283 void *argp1 = 0 ;
33284 int res1 = 0 ;
33285 PyObject *swig_obj[1] ;
33286
33287 if (!args) SWIG_fail;
33288 swig_obj[0] = args;
33289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33290 if (!SWIG_IsOK(res1)) {
33291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
33292 }
33293 arg1 = reinterpret_cast< wxWindow * >(argp1);
33294 {
33295 PyThreadState* __tstate = wxPyBeginAllowThreads();
33296 result = ((wxWindow const *)arg1)->GetVirtualSize();
33297 wxPyEndAllowThreads(__tstate);
33298 if (PyErr_Occurred()) SWIG_fail;
33299 }
33300 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33301 return resultobj;
33302 fail:
33303 return NULL;
33304 }
33305
33306
33307 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33308 PyObject *resultobj = 0;
33309 wxWindow *arg1 = (wxWindow *) 0 ;
33310 int *arg2 = (int *) 0 ;
33311 int *arg3 = (int *) 0 ;
33312 void *argp1 = 0 ;
33313 int res1 = 0 ;
33314 int temp2 ;
33315 int res2 = SWIG_TMPOBJ ;
33316 int temp3 ;
33317 int res3 = SWIG_TMPOBJ ;
33318 PyObject *swig_obj[1] ;
33319
33320 arg2 = &temp2;
33321 arg3 = &temp3;
33322 if (!args) SWIG_fail;
33323 swig_obj[0] = args;
33324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33325 if (!SWIG_IsOK(res1)) {
33326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
33327 }
33328 arg1 = reinterpret_cast< wxWindow * >(argp1);
33329 {
33330 PyThreadState* __tstate = wxPyBeginAllowThreads();
33331 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
33332 wxPyEndAllowThreads(__tstate);
33333 if (PyErr_Occurred()) SWIG_fail;
33334 }
33335 resultobj = SWIG_Py_Void();
33336 if (SWIG_IsTmpObj(res2)) {
33337 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
33338 } else {
33339 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
33340 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
33341 }
33342 if (SWIG_IsTmpObj(res3)) {
33343 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
33344 } else {
33345 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
33346 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
33347 }
33348 return resultobj;
33349 fail:
33350 return NULL;
33351 }
33352
33353
33354 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33355 PyObject *resultobj = 0;
33356 wxWindow *arg1 = (wxWindow *) 0 ;
33357 wxSize result;
33358 void *argp1 = 0 ;
33359 int res1 = 0 ;
33360 PyObject *swig_obj[1] ;
33361
33362 if (!args) SWIG_fail;
33363 swig_obj[0] = args;
33364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33365 if (!SWIG_IsOK(res1)) {
33366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
33367 }
33368 arg1 = reinterpret_cast< wxWindow * >(argp1);
33369 {
33370 PyThreadState* __tstate = wxPyBeginAllowThreads();
33371 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
33372 wxPyEndAllowThreads(__tstate);
33373 if (PyErr_Occurred()) SWIG_fail;
33374 }
33375 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33376 return resultobj;
33377 fail:
33378 return NULL;
33379 }
33380
33381
33382 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33383 PyObject *resultobj = 0;
33384 wxWindow *arg1 = (wxWindow *) 0 ;
33385 bool arg2 = (bool) true ;
33386 bool result;
33387 void *argp1 = 0 ;
33388 int res1 = 0 ;
33389 bool val2 ;
33390 int ecode2 = 0 ;
33391 PyObject * obj0 = 0 ;
33392 PyObject * obj1 = 0 ;
33393 char * kwnames[] = {
33394 (char *) "self",(char *) "show", NULL
33395 };
33396
33397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
33398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33399 if (!SWIG_IsOK(res1)) {
33400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
33401 }
33402 arg1 = reinterpret_cast< wxWindow * >(argp1);
33403 if (obj1) {
33404 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33405 if (!SWIG_IsOK(ecode2)) {
33406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
33407 }
33408 arg2 = static_cast< bool >(val2);
33409 }
33410 {
33411 PyThreadState* __tstate = wxPyBeginAllowThreads();
33412 result = (bool)(arg1)->Show(arg2);
33413 wxPyEndAllowThreads(__tstate);
33414 if (PyErr_Occurred()) SWIG_fail;
33415 }
33416 {
33417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33418 }
33419 return resultobj;
33420 fail:
33421 return NULL;
33422 }
33423
33424
33425 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33426 PyObject *resultobj = 0;
33427 wxWindow *arg1 = (wxWindow *) 0 ;
33428 bool result;
33429 void *argp1 = 0 ;
33430 int res1 = 0 ;
33431 PyObject *swig_obj[1] ;
33432
33433 if (!args) SWIG_fail;
33434 swig_obj[0] = args;
33435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33436 if (!SWIG_IsOK(res1)) {
33437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
33438 }
33439 arg1 = reinterpret_cast< wxWindow * >(argp1);
33440 {
33441 PyThreadState* __tstate = wxPyBeginAllowThreads();
33442 result = (bool)(arg1)->Hide();
33443 wxPyEndAllowThreads(__tstate);
33444 if (PyErr_Occurred()) SWIG_fail;
33445 }
33446 {
33447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33448 }
33449 return resultobj;
33450 fail:
33451 return NULL;
33452 }
33453
33454
33455 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33456 PyObject *resultobj = 0;
33457 wxWindow *arg1 = (wxWindow *) 0 ;
33458 bool arg2 = (bool) true ;
33459 bool result;
33460 void *argp1 = 0 ;
33461 int res1 = 0 ;
33462 bool val2 ;
33463 int ecode2 = 0 ;
33464 PyObject * obj0 = 0 ;
33465 PyObject * obj1 = 0 ;
33466 char * kwnames[] = {
33467 (char *) "self",(char *) "enable", NULL
33468 };
33469
33470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
33471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33472 if (!SWIG_IsOK(res1)) {
33473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
33474 }
33475 arg1 = reinterpret_cast< wxWindow * >(argp1);
33476 if (obj1) {
33477 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33478 if (!SWIG_IsOK(ecode2)) {
33479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
33480 }
33481 arg2 = static_cast< bool >(val2);
33482 }
33483 {
33484 PyThreadState* __tstate = wxPyBeginAllowThreads();
33485 result = (bool)(arg1)->Enable(arg2);
33486 wxPyEndAllowThreads(__tstate);
33487 if (PyErr_Occurred()) SWIG_fail;
33488 }
33489 {
33490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33491 }
33492 return resultobj;
33493 fail:
33494 return NULL;
33495 }
33496
33497
33498 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33499 PyObject *resultobj = 0;
33500 wxWindow *arg1 = (wxWindow *) 0 ;
33501 bool result;
33502 void *argp1 = 0 ;
33503 int res1 = 0 ;
33504 PyObject *swig_obj[1] ;
33505
33506 if (!args) SWIG_fail;
33507 swig_obj[0] = args;
33508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33509 if (!SWIG_IsOK(res1)) {
33510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
33511 }
33512 arg1 = reinterpret_cast< wxWindow * >(argp1);
33513 {
33514 PyThreadState* __tstate = wxPyBeginAllowThreads();
33515 result = (bool)(arg1)->Disable();
33516 wxPyEndAllowThreads(__tstate);
33517 if (PyErr_Occurred()) SWIG_fail;
33518 }
33519 {
33520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33521 }
33522 return resultobj;
33523 fail:
33524 return NULL;
33525 }
33526
33527
33528 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33529 PyObject *resultobj = 0;
33530 wxWindow *arg1 = (wxWindow *) 0 ;
33531 bool result;
33532 void *argp1 = 0 ;
33533 int res1 = 0 ;
33534 PyObject *swig_obj[1] ;
33535
33536 if (!args) SWIG_fail;
33537 swig_obj[0] = args;
33538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33539 if (!SWIG_IsOK(res1)) {
33540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
33541 }
33542 arg1 = reinterpret_cast< wxWindow * >(argp1);
33543 {
33544 PyThreadState* __tstate = wxPyBeginAllowThreads();
33545 result = (bool)((wxWindow const *)arg1)->IsShown();
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_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33559 PyObject *resultobj = 0;
33560 wxWindow *arg1 = (wxWindow *) 0 ;
33561 bool result;
33562 void *argp1 = 0 ;
33563 int res1 = 0 ;
33564 PyObject *swig_obj[1] ;
33565
33566 if (!args) SWIG_fail;
33567 swig_obj[0] = args;
33568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33569 if (!SWIG_IsOK(res1)) {
33570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33571 }
33572 arg1 = reinterpret_cast< wxWindow * >(argp1);
33573 {
33574 PyThreadState* __tstate = wxPyBeginAllowThreads();
33575 result = (bool)((wxWindow const *)arg1)->IsEnabled();
33576 wxPyEndAllowThreads(__tstate);
33577 if (PyErr_Occurred()) SWIG_fail;
33578 }
33579 {
33580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33581 }
33582 return resultobj;
33583 fail:
33584 return NULL;
33585 }
33586
33587
33588 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33589 PyObject *resultobj = 0;
33590 wxWindow *arg1 = (wxWindow *) 0 ;
33591 bool result;
33592 void *argp1 = 0 ;
33593 int res1 = 0 ;
33594 PyObject *swig_obj[1] ;
33595
33596 if (!args) SWIG_fail;
33597 swig_obj[0] = args;
33598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33599 if (!SWIG_IsOK(res1)) {
33600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
33601 }
33602 arg1 = reinterpret_cast< wxWindow * >(argp1);
33603 {
33604 PyThreadState* __tstate = wxPyBeginAllowThreads();
33605 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
33606 wxPyEndAllowThreads(__tstate);
33607 if (PyErr_Occurred()) SWIG_fail;
33608 }
33609 {
33610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33611 }
33612 return resultobj;
33613 fail:
33614 return NULL;
33615 }
33616
33617
33618 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33619 PyObject *resultobj = 0;
33620 wxWindow *arg1 = (wxWindow *) 0 ;
33621 long arg2 ;
33622 void *argp1 = 0 ;
33623 int res1 = 0 ;
33624 long val2 ;
33625 int ecode2 = 0 ;
33626 PyObject * obj0 = 0 ;
33627 PyObject * obj1 = 0 ;
33628 char * kwnames[] = {
33629 (char *) "self",(char *) "style", NULL
33630 };
33631
33632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33634 if (!SWIG_IsOK(res1)) {
33635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33636 }
33637 arg1 = reinterpret_cast< wxWindow * >(argp1);
33638 ecode2 = SWIG_AsVal_long(obj1, &val2);
33639 if (!SWIG_IsOK(ecode2)) {
33640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33641 }
33642 arg2 = static_cast< long >(val2);
33643 {
33644 PyThreadState* __tstate = wxPyBeginAllowThreads();
33645 (arg1)->SetWindowStyleFlag(arg2);
33646 wxPyEndAllowThreads(__tstate);
33647 if (PyErr_Occurred()) SWIG_fail;
33648 }
33649 resultobj = SWIG_Py_Void();
33650 return resultobj;
33651 fail:
33652 return NULL;
33653 }
33654
33655
33656 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33657 PyObject *resultobj = 0;
33658 wxWindow *arg1 = (wxWindow *) 0 ;
33659 long result;
33660 void *argp1 = 0 ;
33661 int res1 = 0 ;
33662 PyObject *swig_obj[1] ;
33663
33664 if (!args) SWIG_fail;
33665 swig_obj[0] = args;
33666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33667 if (!SWIG_IsOK(res1)) {
33668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33669 }
33670 arg1 = reinterpret_cast< wxWindow * >(argp1);
33671 {
33672 PyThreadState* __tstate = wxPyBeginAllowThreads();
33673 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33674 wxPyEndAllowThreads(__tstate);
33675 if (PyErr_Occurred()) SWIG_fail;
33676 }
33677 resultobj = SWIG_From_long(static_cast< long >(result));
33678 return resultobj;
33679 fail:
33680 return NULL;
33681 }
33682
33683
33684 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33685 PyObject *resultobj = 0;
33686 wxWindow *arg1 = (wxWindow *) 0 ;
33687 int arg2 ;
33688 bool result;
33689 void *argp1 = 0 ;
33690 int res1 = 0 ;
33691 int val2 ;
33692 int ecode2 = 0 ;
33693 PyObject * obj0 = 0 ;
33694 PyObject * obj1 = 0 ;
33695 char * kwnames[] = {
33696 (char *) "self",(char *) "flag", NULL
33697 };
33698
33699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33701 if (!SWIG_IsOK(res1)) {
33702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33703 }
33704 arg1 = reinterpret_cast< wxWindow * >(argp1);
33705 ecode2 = SWIG_AsVal_int(obj1, &val2);
33706 if (!SWIG_IsOK(ecode2)) {
33707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33708 }
33709 arg2 = static_cast< int >(val2);
33710 {
33711 PyThreadState* __tstate = wxPyBeginAllowThreads();
33712 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
33713 wxPyEndAllowThreads(__tstate);
33714 if (PyErr_Occurred()) SWIG_fail;
33715 }
33716 {
33717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33718 }
33719 return resultobj;
33720 fail:
33721 return NULL;
33722 }
33723
33724
33725 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33726 PyObject *resultobj = 0;
33727 wxWindow *arg1 = (wxWindow *) 0 ;
33728 bool result;
33729 void *argp1 = 0 ;
33730 int res1 = 0 ;
33731 PyObject *swig_obj[1] ;
33732
33733 if (!args) SWIG_fail;
33734 swig_obj[0] = args;
33735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33736 if (!SWIG_IsOK(res1)) {
33737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
33738 }
33739 arg1 = reinterpret_cast< wxWindow * >(argp1);
33740 {
33741 PyThreadState* __tstate = wxPyBeginAllowThreads();
33742 result = (bool)((wxWindow const *)arg1)->IsRetained();
33743 wxPyEndAllowThreads(__tstate);
33744 if (PyErr_Occurred()) SWIG_fail;
33745 }
33746 {
33747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33748 }
33749 return resultobj;
33750 fail:
33751 return NULL;
33752 }
33753
33754
33755 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33756 PyObject *resultobj = 0;
33757 wxWindow *arg1 = (wxWindow *) 0 ;
33758 long arg2 ;
33759 void *argp1 = 0 ;
33760 int res1 = 0 ;
33761 long val2 ;
33762 int ecode2 = 0 ;
33763 PyObject * obj0 = 0 ;
33764 PyObject * obj1 = 0 ;
33765 char * kwnames[] = {
33766 (char *) "self",(char *) "exStyle", NULL
33767 };
33768
33769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33771 if (!SWIG_IsOK(res1)) {
33772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33773 }
33774 arg1 = reinterpret_cast< wxWindow * >(argp1);
33775 ecode2 = SWIG_AsVal_long(obj1, &val2);
33776 if (!SWIG_IsOK(ecode2)) {
33777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33778 }
33779 arg2 = static_cast< long >(val2);
33780 {
33781 PyThreadState* __tstate = wxPyBeginAllowThreads();
33782 (arg1)->SetExtraStyle(arg2);
33783 wxPyEndAllowThreads(__tstate);
33784 if (PyErr_Occurred()) SWIG_fail;
33785 }
33786 resultobj = SWIG_Py_Void();
33787 return resultobj;
33788 fail:
33789 return NULL;
33790 }
33791
33792
33793 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33794 PyObject *resultobj = 0;
33795 wxWindow *arg1 = (wxWindow *) 0 ;
33796 long result;
33797 void *argp1 = 0 ;
33798 int res1 = 0 ;
33799 PyObject *swig_obj[1] ;
33800
33801 if (!args) SWIG_fail;
33802 swig_obj[0] = args;
33803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33804 if (!SWIG_IsOK(res1)) {
33805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33806 }
33807 arg1 = reinterpret_cast< wxWindow * >(argp1);
33808 {
33809 PyThreadState* __tstate = wxPyBeginAllowThreads();
33810 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33811 wxPyEndAllowThreads(__tstate);
33812 if (PyErr_Occurred()) SWIG_fail;
33813 }
33814 resultobj = SWIG_From_long(static_cast< long >(result));
33815 return resultobj;
33816 fail:
33817 return NULL;
33818 }
33819
33820
33821 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33822 PyObject *resultobj = 0;
33823 wxWindow *arg1 = (wxWindow *) 0 ;
33824 bool arg2 = (bool) true ;
33825 void *argp1 = 0 ;
33826 int res1 = 0 ;
33827 bool val2 ;
33828 int ecode2 = 0 ;
33829 PyObject * obj0 = 0 ;
33830 PyObject * obj1 = 0 ;
33831 char * kwnames[] = {
33832 (char *) "self",(char *) "modal", NULL
33833 };
33834
33835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33837 if (!SWIG_IsOK(res1)) {
33838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33839 }
33840 arg1 = reinterpret_cast< wxWindow * >(argp1);
33841 if (obj1) {
33842 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33843 if (!SWIG_IsOK(ecode2)) {
33844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33845 }
33846 arg2 = static_cast< bool >(val2);
33847 }
33848 {
33849 PyThreadState* __tstate = wxPyBeginAllowThreads();
33850 (arg1)->MakeModal(arg2);
33851 wxPyEndAllowThreads(__tstate);
33852 if (PyErr_Occurred()) SWIG_fail;
33853 }
33854 resultobj = SWIG_Py_Void();
33855 return resultobj;
33856 fail:
33857 return NULL;
33858 }
33859
33860
33861 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33862 PyObject *resultobj = 0;
33863 wxWindow *arg1 = (wxWindow *) 0 ;
33864 bool arg2 ;
33865 void *argp1 = 0 ;
33866 int res1 = 0 ;
33867 bool val2 ;
33868 int ecode2 = 0 ;
33869 PyObject * obj0 = 0 ;
33870 PyObject * obj1 = 0 ;
33871 char * kwnames[] = {
33872 (char *) "self",(char *) "enableTheme", NULL
33873 };
33874
33875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
33876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33877 if (!SWIG_IsOK(res1)) {
33878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33879 }
33880 arg1 = reinterpret_cast< wxWindow * >(argp1);
33881 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33882 if (!SWIG_IsOK(ecode2)) {
33883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33884 }
33885 arg2 = static_cast< bool >(val2);
33886 {
33887 PyThreadState* __tstate = wxPyBeginAllowThreads();
33888 (arg1)->SetThemeEnabled(arg2);
33889 wxPyEndAllowThreads(__tstate);
33890 if (PyErr_Occurred()) SWIG_fail;
33891 }
33892 resultobj = SWIG_Py_Void();
33893 return resultobj;
33894 fail:
33895 return NULL;
33896 }
33897
33898
33899 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33900 PyObject *resultobj = 0;
33901 wxWindow *arg1 = (wxWindow *) 0 ;
33902 bool result;
33903 void *argp1 = 0 ;
33904 int res1 = 0 ;
33905 PyObject *swig_obj[1] ;
33906
33907 if (!args) SWIG_fail;
33908 swig_obj[0] = args;
33909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33910 if (!SWIG_IsOK(res1)) {
33911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33912 }
33913 arg1 = reinterpret_cast< wxWindow * >(argp1);
33914 {
33915 PyThreadState* __tstate = wxPyBeginAllowThreads();
33916 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33917 wxPyEndAllowThreads(__tstate);
33918 if (PyErr_Occurred()) SWIG_fail;
33919 }
33920 {
33921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33922 }
33923 return resultobj;
33924 fail:
33925 return NULL;
33926 }
33927
33928
33929 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33930 PyObject *resultobj = 0;
33931 wxWindow *arg1 = (wxWindow *) 0 ;
33932 void *argp1 = 0 ;
33933 int res1 = 0 ;
33934 PyObject *swig_obj[1] ;
33935
33936 if (!args) SWIG_fail;
33937 swig_obj[0] = args;
33938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33939 if (!SWIG_IsOK(res1)) {
33940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33941 }
33942 arg1 = reinterpret_cast< wxWindow * >(argp1);
33943 {
33944 PyThreadState* __tstate = wxPyBeginAllowThreads();
33945 (arg1)->SetFocus();
33946 wxPyEndAllowThreads(__tstate);
33947 if (PyErr_Occurred()) SWIG_fail;
33948 }
33949 resultobj = SWIG_Py_Void();
33950 return resultobj;
33951 fail:
33952 return NULL;
33953 }
33954
33955
33956 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33957 PyObject *resultobj = 0;
33958 wxWindow *arg1 = (wxWindow *) 0 ;
33959 void *argp1 = 0 ;
33960 int res1 = 0 ;
33961 PyObject *swig_obj[1] ;
33962
33963 if (!args) SWIG_fail;
33964 swig_obj[0] = args;
33965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33966 if (!SWIG_IsOK(res1)) {
33967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33968 }
33969 arg1 = reinterpret_cast< wxWindow * >(argp1);
33970 {
33971 PyThreadState* __tstate = wxPyBeginAllowThreads();
33972 (arg1)->SetFocusFromKbd();
33973 wxPyEndAllowThreads(__tstate);
33974 if (PyErr_Occurred()) SWIG_fail;
33975 }
33976 resultobj = SWIG_Py_Void();
33977 return resultobj;
33978 fail:
33979 return NULL;
33980 }
33981
33982
33983 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33984 PyObject *resultobj = 0;
33985 wxWindow *result = 0 ;
33986
33987 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33988 {
33989 if (!wxPyCheckForApp()) SWIG_fail;
33990 PyThreadState* __tstate = wxPyBeginAllowThreads();
33991 result = (wxWindow *)wxWindow::FindFocus();
33992 wxPyEndAllowThreads(__tstate);
33993 if (PyErr_Occurred()) SWIG_fail;
33994 }
33995 {
33996 resultobj = wxPyMake_wxObject(result, 0);
33997 }
33998 return resultobj;
33999 fail:
34000 return NULL;
34001 }
34002
34003
34004 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34005 PyObject *resultobj = 0;
34006 wxWindow *arg1 = (wxWindow *) 0 ;
34007 bool result;
34008 void *argp1 = 0 ;
34009 int res1 = 0 ;
34010 PyObject *swig_obj[1] ;
34011
34012 if (!args) SWIG_fail;
34013 swig_obj[0] = args;
34014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34015 if (!SWIG_IsOK(res1)) {
34016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
34017 }
34018 arg1 = reinterpret_cast< wxWindow * >(argp1);
34019 {
34020 PyThreadState* __tstate = wxPyBeginAllowThreads();
34021 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
34022 wxPyEndAllowThreads(__tstate);
34023 if (PyErr_Occurred()) SWIG_fail;
34024 }
34025 {
34026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34027 }
34028 return resultobj;
34029 fail:
34030 return NULL;
34031 }
34032
34033
34034 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34035 PyObject *resultobj = 0;
34036 wxWindow *arg1 = (wxWindow *) 0 ;
34037 bool result;
34038 void *argp1 = 0 ;
34039 int res1 = 0 ;
34040 PyObject *swig_obj[1] ;
34041
34042 if (!args) SWIG_fail;
34043 swig_obj[0] = args;
34044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34045 if (!SWIG_IsOK(res1)) {
34046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
34047 }
34048 arg1 = reinterpret_cast< wxWindow * >(argp1);
34049 {
34050 PyThreadState* __tstate = wxPyBeginAllowThreads();
34051 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
34052 wxPyEndAllowThreads(__tstate);
34053 if (PyErr_Occurred()) SWIG_fail;
34054 }
34055 {
34056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34057 }
34058 return resultobj;
34059 fail:
34060 return NULL;
34061 }
34062
34063
34064 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34065 PyObject *resultobj = 0;
34066 wxWindow *arg1 = (wxWindow *) 0 ;
34067 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
34068 bool result;
34069 void *argp1 = 0 ;
34070 int res1 = 0 ;
34071 int val2 ;
34072 int ecode2 = 0 ;
34073 PyObject * obj0 = 0 ;
34074 PyObject * obj1 = 0 ;
34075 char * kwnames[] = {
34076 (char *) "self",(char *) "flags", NULL
34077 };
34078
34079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
34080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34081 if (!SWIG_IsOK(res1)) {
34082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
34083 }
34084 arg1 = reinterpret_cast< wxWindow * >(argp1);
34085 if (obj1) {
34086 ecode2 = SWIG_AsVal_int(obj1, &val2);
34087 if (!SWIG_IsOK(ecode2)) {
34088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
34089 }
34090 arg2 = static_cast< int >(val2);
34091 }
34092 {
34093 PyThreadState* __tstate = wxPyBeginAllowThreads();
34094 result = (bool)(arg1)->Navigate(arg2);
34095 wxPyEndAllowThreads(__tstate);
34096 if (PyErr_Occurred()) SWIG_fail;
34097 }
34098 {
34099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34100 }
34101 return resultobj;
34102 fail:
34103 return NULL;
34104 }
34105
34106
34107 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34108 PyObject *resultobj = 0;
34109 wxWindow *arg1 = (wxWindow *) 0 ;
34110 wxWindow *arg2 = (wxWindow *) 0 ;
34111 void *argp1 = 0 ;
34112 int res1 = 0 ;
34113 void *argp2 = 0 ;
34114 int res2 = 0 ;
34115 PyObject * obj0 = 0 ;
34116 PyObject * obj1 = 0 ;
34117 char * kwnames[] = {
34118 (char *) "self",(char *) "win", NULL
34119 };
34120
34121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
34122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34123 if (!SWIG_IsOK(res1)) {
34124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
34125 }
34126 arg1 = reinterpret_cast< wxWindow * >(argp1);
34127 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34128 if (!SWIG_IsOK(res2)) {
34129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
34130 }
34131 arg2 = reinterpret_cast< wxWindow * >(argp2);
34132 {
34133 PyThreadState* __tstate = wxPyBeginAllowThreads();
34134 (arg1)->MoveAfterInTabOrder(arg2);
34135 wxPyEndAllowThreads(__tstate);
34136 if (PyErr_Occurred()) SWIG_fail;
34137 }
34138 resultobj = SWIG_Py_Void();
34139 return resultobj;
34140 fail:
34141 return NULL;
34142 }
34143
34144
34145 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34146 PyObject *resultobj = 0;
34147 wxWindow *arg1 = (wxWindow *) 0 ;
34148 wxWindow *arg2 = (wxWindow *) 0 ;
34149 void *argp1 = 0 ;
34150 int res1 = 0 ;
34151 void *argp2 = 0 ;
34152 int res2 = 0 ;
34153 PyObject * obj0 = 0 ;
34154 PyObject * obj1 = 0 ;
34155 char * kwnames[] = {
34156 (char *) "self",(char *) "win", NULL
34157 };
34158
34159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
34160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34161 if (!SWIG_IsOK(res1)) {
34162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
34163 }
34164 arg1 = reinterpret_cast< wxWindow * >(argp1);
34165 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34166 if (!SWIG_IsOK(res2)) {
34167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
34168 }
34169 arg2 = reinterpret_cast< wxWindow * >(argp2);
34170 {
34171 PyThreadState* __tstate = wxPyBeginAllowThreads();
34172 (arg1)->MoveBeforeInTabOrder(arg2);
34173 wxPyEndAllowThreads(__tstate);
34174 if (PyErr_Occurred()) SWIG_fail;
34175 }
34176 resultobj = SWIG_Py_Void();
34177 return resultobj;
34178 fail:
34179 return NULL;
34180 }
34181
34182
34183 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34184 PyObject *resultobj = 0;
34185 wxWindow *arg1 = (wxWindow *) 0 ;
34186 PyObject *result = 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_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
34196 }
34197 arg1 = reinterpret_cast< wxWindow * >(argp1);
34198 {
34199 PyThreadState* __tstate = wxPyBeginAllowThreads();
34200 result = (PyObject *)wxWindow_GetChildren(arg1);
34201 wxPyEndAllowThreads(__tstate);
34202 if (PyErr_Occurred()) SWIG_fail;
34203 }
34204 resultobj = result;
34205 return resultobj;
34206 fail:
34207 return NULL;
34208 }
34209
34210
34211 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34212 PyObject *resultobj = 0;
34213 wxWindow *arg1 = (wxWindow *) 0 ;
34214 wxWindow *result = 0 ;
34215 void *argp1 = 0 ;
34216 int res1 = 0 ;
34217 PyObject *swig_obj[1] ;
34218
34219 if (!args) SWIG_fail;
34220 swig_obj[0] = args;
34221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34222 if (!SWIG_IsOK(res1)) {
34223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
34224 }
34225 arg1 = reinterpret_cast< wxWindow * >(argp1);
34226 {
34227 PyThreadState* __tstate = wxPyBeginAllowThreads();
34228 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
34229 wxPyEndAllowThreads(__tstate);
34230 if (PyErr_Occurred()) SWIG_fail;
34231 }
34232 {
34233 resultobj = wxPyMake_wxObject(result, 0);
34234 }
34235 return resultobj;
34236 fail:
34237 return NULL;
34238 }
34239
34240
34241 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34242 PyObject *resultobj = 0;
34243 wxWindow *arg1 = (wxWindow *) 0 ;
34244 wxWindow *result = 0 ;
34245 void *argp1 = 0 ;
34246 int res1 = 0 ;
34247 PyObject *swig_obj[1] ;
34248
34249 if (!args) SWIG_fail;
34250 swig_obj[0] = args;
34251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34252 if (!SWIG_IsOK(res1)) {
34253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
34254 }
34255 arg1 = reinterpret_cast< wxWindow * >(argp1);
34256 {
34257 PyThreadState* __tstate = wxPyBeginAllowThreads();
34258 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
34259 wxPyEndAllowThreads(__tstate);
34260 if (PyErr_Occurred()) SWIG_fail;
34261 }
34262 {
34263 resultobj = wxPyMake_wxObject(result, 0);
34264 }
34265 return resultobj;
34266 fail:
34267 return NULL;
34268 }
34269
34270
34271 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34272 PyObject *resultobj = 0;
34273 wxWindow *arg1 = (wxWindow *) 0 ;
34274 bool result;
34275 void *argp1 = 0 ;
34276 int res1 = 0 ;
34277 PyObject *swig_obj[1] ;
34278
34279 if (!args) SWIG_fail;
34280 swig_obj[0] = args;
34281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34282 if (!SWIG_IsOK(res1)) {
34283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
34284 }
34285 arg1 = reinterpret_cast< wxWindow * >(argp1);
34286 {
34287 PyThreadState* __tstate = wxPyBeginAllowThreads();
34288 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
34289 wxPyEndAllowThreads(__tstate);
34290 if (PyErr_Occurred()) SWIG_fail;
34291 }
34292 {
34293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34294 }
34295 return resultobj;
34296 fail:
34297 return NULL;
34298 }
34299
34300
34301 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34302 PyObject *resultobj = 0;
34303 wxWindow *arg1 = (wxWindow *) 0 ;
34304 wxWindow *arg2 = (wxWindow *) 0 ;
34305 bool result;
34306 void *argp1 = 0 ;
34307 int res1 = 0 ;
34308 void *argp2 = 0 ;
34309 int res2 = 0 ;
34310 PyObject * obj0 = 0 ;
34311 PyObject * obj1 = 0 ;
34312 char * kwnames[] = {
34313 (char *) "self",(char *) "newParent", NULL
34314 };
34315
34316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
34317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34318 if (!SWIG_IsOK(res1)) {
34319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
34320 }
34321 arg1 = reinterpret_cast< wxWindow * >(argp1);
34322 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34323 if (!SWIG_IsOK(res2)) {
34324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
34325 }
34326 arg2 = reinterpret_cast< wxWindow * >(argp2);
34327 {
34328 PyThreadState* __tstate = wxPyBeginAllowThreads();
34329 result = (bool)(arg1)->Reparent(arg2);
34330 wxPyEndAllowThreads(__tstate);
34331 if (PyErr_Occurred()) SWIG_fail;
34332 }
34333 {
34334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34335 }
34336 return resultobj;
34337 fail:
34338 return NULL;
34339 }
34340
34341
34342 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34343 PyObject *resultobj = 0;
34344 wxWindow *arg1 = (wxWindow *) 0 ;
34345 wxWindow *arg2 = (wxWindow *) 0 ;
34346 void *argp1 = 0 ;
34347 int res1 = 0 ;
34348 void *argp2 = 0 ;
34349 int res2 = 0 ;
34350 PyObject * obj0 = 0 ;
34351 PyObject * obj1 = 0 ;
34352 char * kwnames[] = {
34353 (char *) "self",(char *) "child", NULL
34354 };
34355
34356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
34357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34358 if (!SWIG_IsOK(res1)) {
34359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
34360 }
34361 arg1 = reinterpret_cast< wxWindow * >(argp1);
34362 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34363 if (!SWIG_IsOK(res2)) {
34364 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
34365 }
34366 arg2 = reinterpret_cast< wxWindow * >(argp2);
34367 {
34368 PyThreadState* __tstate = wxPyBeginAllowThreads();
34369 (arg1)->AddChild(arg2);
34370 wxPyEndAllowThreads(__tstate);
34371 if (PyErr_Occurred()) SWIG_fail;
34372 }
34373 resultobj = SWIG_Py_Void();
34374 return resultobj;
34375 fail:
34376 return NULL;
34377 }
34378
34379
34380 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34381 PyObject *resultobj = 0;
34382 wxWindow *arg1 = (wxWindow *) 0 ;
34383 wxWindow *arg2 = (wxWindow *) 0 ;
34384 void *argp1 = 0 ;
34385 int res1 = 0 ;
34386 void *argp2 = 0 ;
34387 int res2 = 0 ;
34388 PyObject * obj0 = 0 ;
34389 PyObject * obj1 = 0 ;
34390 char * kwnames[] = {
34391 (char *) "self",(char *) "child", NULL
34392 };
34393
34394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
34395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34396 if (!SWIG_IsOK(res1)) {
34397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
34398 }
34399 arg1 = reinterpret_cast< wxWindow * >(argp1);
34400 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34401 if (!SWIG_IsOK(res2)) {
34402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
34403 }
34404 arg2 = reinterpret_cast< wxWindow * >(argp2);
34405 {
34406 PyThreadState* __tstate = wxPyBeginAllowThreads();
34407 (arg1)->RemoveChild(arg2);
34408 wxPyEndAllowThreads(__tstate);
34409 if (PyErr_Occurred()) SWIG_fail;
34410 }
34411 resultobj = SWIG_Py_Void();
34412 return resultobj;
34413 fail:
34414 return NULL;
34415 }
34416
34417
34418 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34419 PyObject *resultobj = 0;
34420 wxWindow *arg1 = (wxWindow *) 0 ;
34421 bool arg2 ;
34422 void *argp1 = 0 ;
34423 int res1 = 0 ;
34424 bool val2 ;
34425 int ecode2 = 0 ;
34426 PyObject * obj0 = 0 ;
34427 PyObject * obj1 = 0 ;
34428 char * kwnames[] = {
34429 (char *) "self",(char *) "on", NULL
34430 };
34431
34432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
34433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34434 if (!SWIG_IsOK(res1)) {
34435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
34436 }
34437 arg1 = reinterpret_cast< wxWindow * >(argp1);
34438 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34439 if (!SWIG_IsOK(ecode2)) {
34440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
34441 }
34442 arg2 = static_cast< bool >(val2);
34443 {
34444 PyThreadState* __tstate = wxPyBeginAllowThreads();
34445 (arg1)->SetDoubleBuffered(arg2);
34446 wxPyEndAllowThreads(__tstate);
34447 if (PyErr_Occurred()) SWIG_fail;
34448 }
34449 resultobj = SWIG_Py_Void();
34450 return resultobj;
34451 fail:
34452 return NULL;
34453 }
34454
34455
34456 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34457 PyObject *resultobj = 0;
34458 wxWindow *arg1 = (wxWindow *) 0 ;
34459 long arg2 ;
34460 wxWindow *result = 0 ;
34461 void *argp1 = 0 ;
34462 int res1 = 0 ;
34463 long val2 ;
34464 int ecode2 = 0 ;
34465 PyObject * obj0 = 0 ;
34466 PyObject * obj1 = 0 ;
34467 char * kwnames[] = {
34468 (char *) "self",(char *) "winid", NULL
34469 };
34470
34471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
34472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34473 if (!SWIG_IsOK(res1)) {
34474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
34475 }
34476 arg1 = reinterpret_cast< wxWindow * >(argp1);
34477 ecode2 = SWIG_AsVal_long(obj1, &val2);
34478 if (!SWIG_IsOK(ecode2)) {
34479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
34480 }
34481 arg2 = static_cast< long >(val2);
34482 {
34483 PyThreadState* __tstate = wxPyBeginAllowThreads();
34484 result = (wxWindow *)(arg1)->FindWindow(arg2);
34485 wxPyEndAllowThreads(__tstate);
34486 if (PyErr_Occurred()) SWIG_fail;
34487 }
34488 {
34489 resultobj = wxPyMake_wxObject(result, 0);
34490 }
34491 return resultobj;
34492 fail:
34493 return NULL;
34494 }
34495
34496
34497 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34498 PyObject *resultobj = 0;
34499 wxWindow *arg1 = (wxWindow *) 0 ;
34500 wxString *arg2 = 0 ;
34501 wxWindow *result = 0 ;
34502 void *argp1 = 0 ;
34503 int res1 = 0 ;
34504 bool temp2 = false ;
34505 PyObject * obj0 = 0 ;
34506 PyObject * obj1 = 0 ;
34507 char * kwnames[] = {
34508 (char *) "self",(char *) "name", NULL
34509 };
34510
34511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
34512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34513 if (!SWIG_IsOK(res1)) {
34514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
34515 }
34516 arg1 = reinterpret_cast< wxWindow * >(argp1);
34517 {
34518 arg2 = wxString_in_helper(obj1);
34519 if (arg2 == NULL) SWIG_fail;
34520 temp2 = true;
34521 }
34522 {
34523 PyThreadState* __tstate = wxPyBeginAllowThreads();
34524 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
34525 wxPyEndAllowThreads(__tstate);
34526 if (PyErr_Occurred()) SWIG_fail;
34527 }
34528 {
34529 resultobj = wxPyMake_wxObject(result, 0);
34530 }
34531 {
34532 if (temp2)
34533 delete arg2;
34534 }
34535 return resultobj;
34536 fail:
34537 {
34538 if (temp2)
34539 delete arg2;
34540 }
34541 return NULL;
34542 }
34543
34544
34545 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34546 PyObject *resultobj = 0;
34547 wxWindow *arg1 = (wxWindow *) 0 ;
34548 wxEvtHandler *result = 0 ;
34549 void *argp1 = 0 ;
34550 int res1 = 0 ;
34551 PyObject *swig_obj[1] ;
34552
34553 if (!args) SWIG_fail;
34554 swig_obj[0] = args;
34555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34556 if (!SWIG_IsOK(res1)) {
34557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
34558 }
34559 arg1 = reinterpret_cast< wxWindow * >(argp1);
34560 {
34561 PyThreadState* __tstate = wxPyBeginAllowThreads();
34562 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
34563 wxPyEndAllowThreads(__tstate);
34564 if (PyErr_Occurred()) SWIG_fail;
34565 }
34566 {
34567 resultobj = wxPyMake_wxObject(result, 0);
34568 }
34569 return resultobj;
34570 fail:
34571 return NULL;
34572 }
34573
34574
34575 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34576 PyObject *resultobj = 0;
34577 wxWindow *arg1 = (wxWindow *) 0 ;
34578 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34579 void *argp1 = 0 ;
34580 int res1 = 0 ;
34581 void *argp2 = 0 ;
34582 int res2 = 0 ;
34583 PyObject * obj0 = 0 ;
34584 PyObject * obj1 = 0 ;
34585 char * kwnames[] = {
34586 (char *) "self",(char *) "handler", NULL
34587 };
34588
34589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34591 if (!SWIG_IsOK(res1)) {
34592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34593 }
34594 arg1 = reinterpret_cast< wxWindow * >(argp1);
34595 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34596 if (!SWIG_IsOK(res2)) {
34597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34598 }
34599 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34600 {
34601 PyThreadState* __tstate = wxPyBeginAllowThreads();
34602 (arg1)->SetEventHandler(arg2);
34603 wxPyEndAllowThreads(__tstate);
34604 if (PyErr_Occurred()) SWIG_fail;
34605 }
34606 resultobj = SWIG_Py_Void();
34607 return resultobj;
34608 fail:
34609 return NULL;
34610 }
34611
34612
34613 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34614 PyObject *resultobj = 0;
34615 wxWindow *arg1 = (wxWindow *) 0 ;
34616 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34617 void *argp1 = 0 ;
34618 int res1 = 0 ;
34619 void *argp2 = 0 ;
34620 int res2 = 0 ;
34621 PyObject * obj0 = 0 ;
34622 PyObject * obj1 = 0 ;
34623 char * kwnames[] = {
34624 (char *) "self",(char *) "handler", NULL
34625 };
34626
34627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34629 if (!SWIG_IsOK(res1)) {
34630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34631 }
34632 arg1 = reinterpret_cast< wxWindow * >(argp1);
34633 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34634 if (!SWIG_IsOK(res2)) {
34635 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34636 }
34637 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34638 {
34639 PyThreadState* __tstate = wxPyBeginAllowThreads();
34640 (arg1)->PushEventHandler(arg2);
34641 wxPyEndAllowThreads(__tstate);
34642 if (PyErr_Occurred()) SWIG_fail;
34643 }
34644 resultobj = SWIG_Py_Void();
34645 return resultobj;
34646 fail:
34647 return NULL;
34648 }
34649
34650
34651 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34652 PyObject *resultobj = 0;
34653 wxWindow *arg1 = (wxWindow *) 0 ;
34654 bool arg2 = (bool) false ;
34655 wxEvtHandler *result = 0 ;
34656 void *argp1 = 0 ;
34657 int res1 = 0 ;
34658 bool val2 ;
34659 int ecode2 = 0 ;
34660 PyObject * obj0 = 0 ;
34661 PyObject * obj1 = 0 ;
34662 char * kwnames[] = {
34663 (char *) "self",(char *) "deleteHandler", NULL
34664 };
34665
34666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34668 if (!SWIG_IsOK(res1)) {
34669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34670 }
34671 arg1 = reinterpret_cast< wxWindow * >(argp1);
34672 if (obj1) {
34673 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34674 if (!SWIG_IsOK(ecode2)) {
34675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34676 }
34677 arg2 = static_cast< bool >(val2);
34678 }
34679 {
34680 PyThreadState* __tstate = wxPyBeginAllowThreads();
34681 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34682 wxPyEndAllowThreads(__tstate);
34683 if (PyErr_Occurred()) SWIG_fail;
34684 }
34685 {
34686 resultobj = wxPyMake_wxObject(result, 0);
34687 }
34688 return resultobj;
34689 fail:
34690 return NULL;
34691 }
34692
34693
34694 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34695 PyObject *resultobj = 0;
34696 wxWindow *arg1 = (wxWindow *) 0 ;
34697 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34698 bool result;
34699 void *argp1 = 0 ;
34700 int res1 = 0 ;
34701 void *argp2 = 0 ;
34702 int res2 = 0 ;
34703 PyObject * obj0 = 0 ;
34704 PyObject * obj1 = 0 ;
34705 char * kwnames[] = {
34706 (char *) "self",(char *) "handler", NULL
34707 };
34708
34709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34711 if (!SWIG_IsOK(res1)) {
34712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34713 }
34714 arg1 = reinterpret_cast< wxWindow * >(argp1);
34715 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34716 if (!SWIG_IsOK(res2)) {
34717 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34718 }
34719 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34720 {
34721 PyThreadState* __tstate = wxPyBeginAllowThreads();
34722 result = (bool)(arg1)->RemoveEventHandler(arg2);
34723 wxPyEndAllowThreads(__tstate);
34724 if (PyErr_Occurred()) SWIG_fail;
34725 }
34726 {
34727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34728 }
34729 return resultobj;
34730 fail:
34731 return NULL;
34732 }
34733
34734
34735 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34736 PyObject *resultobj = 0;
34737 wxWindow *arg1 = (wxWindow *) 0 ;
34738 wxValidator *arg2 = 0 ;
34739 void *argp1 = 0 ;
34740 int res1 = 0 ;
34741 void *argp2 = 0 ;
34742 int res2 = 0 ;
34743 PyObject * obj0 = 0 ;
34744 PyObject * obj1 = 0 ;
34745 char * kwnames[] = {
34746 (char *) "self",(char *) "validator", NULL
34747 };
34748
34749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34751 if (!SWIG_IsOK(res1)) {
34752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34753 }
34754 arg1 = reinterpret_cast< wxWindow * >(argp1);
34755 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34756 if (!SWIG_IsOK(res2)) {
34757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34758 }
34759 if (!argp2) {
34760 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34761 }
34762 arg2 = reinterpret_cast< wxValidator * >(argp2);
34763 {
34764 PyThreadState* __tstate = wxPyBeginAllowThreads();
34765 (arg1)->SetValidator((wxValidator const &)*arg2);
34766 wxPyEndAllowThreads(__tstate);
34767 if (PyErr_Occurred()) SWIG_fail;
34768 }
34769 resultobj = SWIG_Py_Void();
34770 return resultobj;
34771 fail:
34772 return NULL;
34773 }
34774
34775
34776 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34777 PyObject *resultobj = 0;
34778 wxWindow *arg1 = (wxWindow *) 0 ;
34779 wxValidator *result = 0 ;
34780 void *argp1 = 0 ;
34781 int res1 = 0 ;
34782 PyObject *swig_obj[1] ;
34783
34784 if (!args) SWIG_fail;
34785 swig_obj[0] = args;
34786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34787 if (!SWIG_IsOK(res1)) {
34788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34789 }
34790 arg1 = reinterpret_cast< wxWindow * >(argp1);
34791 {
34792 PyThreadState* __tstate = wxPyBeginAllowThreads();
34793 result = (wxValidator *)(arg1)->GetValidator();
34794 wxPyEndAllowThreads(__tstate);
34795 if (PyErr_Occurred()) SWIG_fail;
34796 }
34797 {
34798 resultobj = wxPyMake_wxObject(result, (bool)0);
34799 }
34800 return resultobj;
34801 fail:
34802 return NULL;
34803 }
34804
34805
34806 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34807 PyObject *resultobj = 0;
34808 wxWindow *arg1 = (wxWindow *) 0 ;
34809 bool result;
34810 void *argp1 = 0 ;
34811 int res1 = 0 ;
34812 PyObject *swig_obj[1] ;
34813
34814 if (!args) SWIG_fail;
34815 swig_obj[0] = args;
34816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34817 if (!SWIG_IsOK(res1)) {
34818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34819 }
34820 arg1 = reinterpret_cast< wxWindow * >(argp1);
34821 {
34822 PyThreadState* __tstate = wxPyBeginAllowThreads();
34823 result = (bool)(arg1)->Validate();
34824 wxPyEndAllowThreads(__tstate);
34825 if (PyErr_Occurred()) SWIG_fail;
34826 }
34827 {
34828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34829 }
34830 return resultobj;
34831 fail:
34832 return NULL;
34833 }
34834
34835
34836 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34837 PyObject *resultobj = 0;
34838 wxWindow *arg1 = (wxWindow *) 0 ;
34839 bool result;
34840 void *argp1 = 0 ;
34841 int res1 = 0 ;
34842 PyObject *swig_obj[1] ;
34843
34844 if (!args) SWIG_fail;
34845 swig_obj[0] = args;
34846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34847 if (!SWIG_IsOK(res1)) {
34848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34849 }
34850 arg1 = reinterpret_cast< wxWindow * >(argp1);
34851 {
34852 PyThreadState* __tstate = wxPyBeginAllowThreads();
34853 result = (bool)(arg1)->TransferDataToWindow();
34854 wxPyEndAllowThreads(__tstate);
34855 if (PyErr_Occurred()) SWIG_fail;
34856 }
34857 {
34858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34859 }
34860 return resultobj;
34861 fail:
34862 return NULL;
34863 }
34864
34865
34866 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34867 PyObject *resultobj = 0;
34868 wxWindow *arg1 = (wxWindow *) 0 ;
34869 bool result;
34870 void *argp1 = 0 ;
34871 int res1 = 0 ;
34872 PyObject *swig_obj[1] ;
34873
34874 if (!args) SWIG_fail;
34875 swig_obj[0] = args;
34876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34877 if (!SWIG_IsOK(res1)) {
34878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34879 }
34880 arg1 = reinterpret_cast< wxWindow * >(argp1);
34881 {
34882 PyThreadState* __tstate = wxPyBeginAllowThreads();
34883 result = (bool)(arg1)->TransferDataFromWindow();
34884 wxPyEndAllowThreads(__tstate);
34885 if (PyErr_Occurred()) SWIG_fail;
34886 }
34887 {
34888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34889 }
34890 return resultobj;
34891 fail:
34892 return NULL;
34893 }
34894
34895
34896 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34897 PyObject *resultobj = 0;
34898 wxWindow *arg1 = (wxWindow *) 0 ;
34899 void *argp1 = 0 ;
34900 int res1 = 0 ;
34901 PyObject *swig_obj[1] ;
34902
34903 if (!args) SWIG_fail;
34904 swig_obj[0] = args;
34905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34906 if (!SWIG_IsOK(res1)) {
34907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34908 }
34909 arg1 = reinterpret_cast< wxWindow * >(argp1);
34910 {
34911 PyThreadState* __tstate = wxPyBeginAllowThreads();
34912 (arg1)->InitDialog();
34913 wxPyEndAllowThreads(__tstate);
34914 if (PyErr_Occurred()) SWIG_fail;
34915 }
34916 resultobj = SWIG_Py_Void();
34917 return resultobj;
34918 fail:
34919 return NULL;
34920 }
34921
34922
34923 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34924 PyObject *resultobj = 0;
34925 wxWindow *arg1 = (wxWindow *) 0 ;
34926 wxAcceleratorTable *arg2 = 0 ;
34927 void *argp1 = 0 ;
34928 int res1 = 0 ;
34929 void *argp2 = 0 ;
34930 int res2 = 0 ;
34931 PyObject * obj0 = 0 ;
34932 PyObject * obj1 = 0 ;
34933 char * kwnames[] = {
34934 (char *) "self",(char *) "accel", NULL
34935 };
34936
34937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34939 if (!SWIG_IsOK(res1)) {
34940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34941 }
34942 arg1 = reinterpret_cast< wxWindow * >(argp1);
34943 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34944 if (!SWIG_IsOK(res2)) {
34945 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34946 }
34947 if (!argp2) {
34948 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34949 }
34950 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34951 {
34952 PyThreadState* __tstate = wxPyBeginAllowThreads();
34953 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
34954 wxPyEndAllowThreads(__tstate);
34955 if (PyErr_Occurred()) SWIG_fail;
34956 }
34957 resultobj = SWIG_Py_Void();
34958 return resultobj;
34959 fail:
34960 return NULL;
34961 }
34962
34963
34964 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34965 PyObject *resultobj = 0;
34966 wxWindow *arg1 = (wxWindow *) 0 ;
34967 wxAcceleratorTable *result = 0 ;
34968 void *argp1 = 0 ;
34969 int res1 = 0 ;
34970 PyObject *swig_obj[1] ;
34971
34972 if (!args) SWIG_fail;
34973 swig_obj[0] = args;
34974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34975 if (!SWIG_IsOK(res1)) {
34976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34977 }
34978 arg1 = reinterpret_cast< wxWindow * >(argp1);
34979 {
34980 PyThreadState* __tstate = wxPyBeginAllowThreads();
34981 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34982 wxPyEndAllowThreads(__tstate);
34983 if (PyErr_Occurred()) SWIG_fail;
34984 }
34985 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34986 return resultobj;
34987 fail:
34988 return NULL;
34989 }
34990
34991
34992 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34993 PyObject *resultobj = 0;
34994 wxWindow *arg1 = (wxWindow *) 0 ;
34995 int arg2 ;
34996 int arg3 ;
34997 int arg4 ;
34998 bool result;
34999 void *argp1 = 0 ;
35000 int res1 = 0 ;
35001 int val2 ;
35002 int ecode2 = 0 ;
35003 int val3 ;
35004 int ecode3 = 0 ;
35005 int val4 ;
35006 int ecode4 = 0 ;
35007 PyObject * obj0 = 0 ;
35008 PyObject * obj1 = 0 ;
35009 PyObject * obj2 = 0 ;
35010 PyObject * obj3 = 0 ;
35011 char * kwnames[] = {
35012 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
35013 };
35014
35015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35017 if (!SWIG_IsOK(res1)) {
35018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
35019 }
35020 arg1 = reinterpret_cast< wxWindow * >(argp1);
35021 ecode2 = SWIG_AsVal_int(obj1, &val2);
35022 if (!SWIG_IsOK(ecode2)) {
35023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
35024 }
35025 arg2 = static_cast< int >(val2);
35026 ecode3 = SWIG_AsVal_int(obj2, &val3);
35027 if (!SWIG_IsOK(ecode3)) {
35028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
35029 }
35030 arg3 = static_cast< int >(val3);
35031 ecode4 = SWIG_AsVal_int(obj3, &val4);
35032 if (!SWIG_IsOK(ecode4)) {
35033 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
35034 }
35035 arg4 = static_cast< int >(val4);
35036 {
35037 PyThreadState* __tstate = wxPyBeginAllowThreads();
35038 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
35039 wxPyEndAllowThreads(__tstate);
35040 if (PyErr_Occurred()) SWIG_fail;
35041 }
35042 {
35043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35044 }
35045 return resultobj;
35046 fail:
35047 return NULL;
35048 }
35049
35050
35051 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35052 PyObject *resultobj = 0;
35053 wxWindow *arg1 = (wxWindow *) 0 ;
35054 int arg2 ;
35055 bool result;
35056 void *argp1 = 0 ;
35057 int res1 = 0 ;
35058 int val2 ;
35059 int ecode2 = 0 ;
35060 PyObject * obj0 = 0 ;
35061 PyObject * obj1 = 0 ;
35062 char * kwnames[] = {
35063 (char *) "self",(char *) "hotkeyId", NULL
35064 };
35065
35066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
35067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35068 if (!SWIG_IsOK(res1)) {
35069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
35070 }
35071 arg1 = reinterpret_cast< wxWindow * >(argp1);
35072 ecode2 = SWIG_AsVal_int(obj1, &val2);
35073 if (!SWIG_IsOK(ecode2)) {
35074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
35075 }
35076 arg2 = static_cast< int >(val2);
35077 {
35078 PyThreadState* __tstate = wxPyBeginAllowThreads();
35079 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
35080 wxPyEndAllowThreads(__tstate);
35081 if (PyErr_Occurred()) SWIG_fail;
35082 }
35083 {
35084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35085 }
35086 return resultobj;
35087 fail:
35088 return NULL;
35089 }
35090
35091
35092 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35093 PyObject *resultobj = 0;
35094 wxWindow *arg1 = (wxWindow *) 0 ;
35095 wxPoint *arg2 = 0 ;
35096 wxPoint result;
35097 void *argp1 = 0 ;
35098 int res1 = 0 ;
35099 wxPoint temp2 ;
35100 PyObject * obj0 = 0 ;
35101 PyObject * obj1 = 0 ;
35102 char * kwnames[] = {
35103 (char *) "self",(char *) "pt", NULL
35104 };
35105
35106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
35107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35108 if (!SWIG_IsOK(res1)) {
35109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
35110 }
35111 arg1 = reinterpret_cast< wxWindow * >(argp1);
35112 {
35113 arg2 = &temp2;
35114 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35115 }
35116 {
35117 PyThreadState* __tstate = wxPyBeginAllowThreads();
35118 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
35119 wxPyEndAllowThreads(__tstate);
35120 if (PyErr_Occurred()) SWIG_fail;
35121 }
35122 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35123 return resultobj;
35124 fail:
35125 return NULL;
35126 }
35127
35128
35129 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35130 PyObject *resultobj = 0;
35131 wxWindow *arg1 = (wxWindow *) 0 ;
35132 wxSize *arg2 = 0 ;
35133 wxSize result;
35134 void *argp1 = 0 ;
35135 int res1 = 0 ;
35136 wxSize temp2 ;
35137 PyObject * obj0 = 0 ;
35138 PyObject * obj1 = 0 ;
35139 char * kwnames[] = {
35140 (char *) "self",(char *) "sz", NULL
35141 };
35142
35143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
35144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35145 if (!SWIG_IsOK(res1)) {
35146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
35147 }
35148 arg1 = reinterpret_cast< wxWindow * >(argp1);
35149 {
35150 arg2 = &temp2;
35151 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35152 }
35153 {
35154 PyThreadState* __tstate = wxPyBeginAllowThreads();
35155 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
35156 wxPyEndAllowThreads(__tstate);
35157 if (PyErr_Occurred()) SWIG_fail;
35158 }
35159 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35160 return resultobj;
35161 fail:
35162 return NULL;
35163 }
35164
35165
35166 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35167 PyObject *resultobj = 0;
35168 wxWindow *arg1 = (wxWindow *) 0 ;
35169 wxPoint *arg2 = 0 ;
35170 wxPoint result;
35171 void *argp1 = 0 ;
35172 int res1 = 0 ;
35173 wxPoint temp2 ;
35174 PyObject * obj0 = 0 ;
35175 PyObject * obj1 = 0 ;
35176 char * kwnames[] = {
35177 (char *) "self",(char *) "pt", NULL
35178 };
35179
35180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
35181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35182 if (!SWIG_IsOK(res1)) {
35183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
35184 }
35185 arg1 = reinterpret_cast< wxWindow * >(argp1);
35186 {
35187 arg2 = &temp2;
35188 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35189 }
35190 {
35191 PyThreadState* __tstate = wxPyBeginAllowThreads();
35192 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
35193 wxPyEndAllowThreads(__tstate);
35194 if (PyErr_Occurred()) SWIG_fail;
35195 }
35196 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35197 return resultobj;
35198 fail:
35199 return NULL;
35200 }
35201
35202
35203 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35204 PyObject *resultobj = 0;
35205 wxWindow *arg1 = (wxWindow *) 0 ;
35206 wxSize *arg2 = 0 ;
35207 wxSize result;
35208 void *argp1 = 0 ;
35209 int res1 = 0 ;
35210 wxSize temp2 ;
35211 PyObject * obj0 = 0 ;
35212 PyObject * obj1 = 0 ;
35213 char * kwnames[] = {
35214 (char *) "self",(char *) "sz", NULL
35215 };
35216
35217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
35218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35219 if (!SWIG_IsOK(res1)) {
35220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
35221 }
35222 arg1 = reinterpret_cast< wxWindow * >(argp1);
35223 {
35224 arg2 = &temp2;
35225 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35226 }
35227 {
35228 PyThreadState* __tstate = wxPyBeginAllowThreads();
35229 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
35230 wxPyEndAllowThreads(__tstate);
35231 if (PyErr_Occurred()) SWIG_fail;
35232 }
35233 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35234 return resultobj;
35235 fail:
35236 return NULL;
35237 }
35238
35239
35240 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35241 PyObject *resultobj = 0;
35242 wxWindow *arg1 = (wxWindow *) 0 ;
35243 wxPoint *arg2 = 0 ;
35244 wxPoint result;
35245 void *argp1 = 0 ;
35246 int res1 = 0 ;
35247 wxPoint temp2 ;
35248 PyObject * obj0 = 0 ;
35249 PyObject * obj1 = 0 ;
35250 char * kwnames[] = {
35251 (char *) "self",(char *) "pt", NULL
35252 };
35253
35254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
35255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35256 if (!SWIG_IsOK(res1)) {
35257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
35258 }
35259 arg1 = reinterpret_cast< wxWindow * >(argp1);
35260 {
35261 arg2 = &temp2;
35262 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35263 }
35264 {
35265 PyThreadState* __tstate = wxPyBeginAllowThreads();
35266 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
35267 wxPyEndAllowThreads(__tstate);
35268 if (PyErr_Occurred()) SWIG_fail;
35269 }
35270 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35271 return resultobj;
35272 fail:
35273 return NULL;
35274 }
35275
35276
35277 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35278 PyObject *resultobj = 0;
35279 wxWindow *arg1 = (wxWindow *) 0 ;
35280 wxSize *arg2 = 0 ;
35281 wxSize result;
35282 void *argp1 = 0 ;
35283 int res1 = 0 ;
35284 wxSize temp2 ;
35285 PyObject * obj0 = 0 ;
35286 PyObject * obj1 = 0 ;
35287 char * kwnames[] = {
35288 (char *) "self",(char *) "sz", NULL
35289 };
35290
35291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
35292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35293 if (!SWIG_IsOK(res1)) {
35294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
35295 }
35296 arg1 = reinterpret_cast< wxWindow * >(argp1);
35297 {
35298 arg2 = &temp2;
35299 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35300 }
35301 {
35302 PyThreadState* __tstate = wxPyBeginAllowThreads();
35303 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
35304 wxPyEndAllowThreads(__tstate);
35305 if (PyErr_Occurred()) SWIG_fail;
35306 }
35307 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35308 return resultobj;
35309 fail:
35310 return NULL;
35311 }
35312
35313
35314 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35315 PyObject *resultobj = 0;
35316 wxWindow *arg1 = (wxWindow *) 0 ;
35317 int arg2 ;
35318 int arg3 ;
35319 void *argp1 = 0 ;
35320 int res1 = 0 ;
35321 int val2 ;
35322 int ecode2 = 0 ;
35323 int val3 ;
35324 int ecode3 = 0 ;
35325 PyObject * obj0 = 0 ;
35326 PyObject * obj1 = 0 ;
35327 PyObject * obj2 = 0 ;
35328 char * kwnames[] = {
35329 (char *) "self",(char *) "x",(char *) "y", NULL
35330 };
35331
35332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35334 if (!SWIG_IsOK(res1)) {
35335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
35336 }
35337 arg1 = reinterpret_cast< wxWindow * >(argp1);
35338 ecode2 = SWIG_AsVal_int(obj1, &val2);
35339 if (!SWIG_IsOK(ecode2)) {
35340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
35341 }
35342 arg2 = static_cast< int >(val2);
35343 ecode3 = SWIG_AsVal_int(obj2, &val3);
35344 if (!SWIG_IsOK(ecode3)) {
35345 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
35346 }
35347 arg3 = static_cast< int >(val3);
35348 {
35349 PyThreadState* __tstate = wxPyBeginAllowThreads();
35350 (arg1)->WarpPointer(arg2,arg3);
35351 wxPyEndAllowThreads(__tstate);
35352 if (PyErr_Occurred()) SWIG_fail;
35353 }
35354 resultobj = SWIG_Py_Void();
35355 return resultobj;
35356 fail:
35357 return NULL;
35358 }
35359
35360
35361 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35362 PyObject *resultobj = 0;
35363 wxWindow *arg1 = (wxWindow *) 0 ;
35364 void *argp1 = 0 ;
35365 int res1 = 0 ;
35366 PyObject *swig_obj[1] ;
35367
35368 if (!args) SWIG_fail;
35369 swig_obj[0] = args;
35370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35371 if (!SWIG_IsOK(res1)) {
35372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
35373 }
35374 arg1 = reinterpret_cast< wxWindow * >(argp1);
35375 {
35376 PyThreadState* __tstate = wxPyBeginAllowThreads();
35377 (arg1)->CaptureMouse();
35378 wxPyEndAllowThreads(__tstate);
35379 if (PyErr_Occurred()) SWIG_fail;
35380 }
35381 resultobj = SWIG_Py_Void();
35382 return resultobj;
35383 fail:
35384 return NULL;
35385 }
35386
35387
35388 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35389 PyObject *resultobj = 0;
35390 wxWindow *arg1 = (wxWindow *) 0 ;
35391 void *argp1 = 0 ;
35392 int res1 = 0 ;
35393 PyObject *swig_obj[1] ;
35394
35395 if (!args) SWIG_fail;
35396 swig_obj[0] = args;
35397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35398 if (!SWIG_IsOK(res1)) {
35399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
35400 }
35401 arg1 = reinterpret_cast< wxWindow * >(argp1);
35402 {
35403 PyThreadState* __tstate = wxPyBeginAllowThreads();
35404 (arg1)->ReleaseMouse();
35405 wxPyEndAllowThreads(__tstate);
35406 if (PyErr_Occurred()) SWIG_fail;
35407 }
35408 resultobj = SWIG_Py_Void();
35409 return resultobj;
35410 fail:
35411 return NULL;
35412 }
35413
35414
35415 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35416 PyObject *resultobj = 0;
35417 wxWindow *result = 0 ;
35418
35419 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
35420 {
35421 if (!wxPyCheckForApp()) SWIG_fail;
35422 PyThreadState* __tstate = wxPyBeginAllowThreads();
35423 result = (wxWindow *)wxWindow::GetCapture();
35424 wxPyEndAllowThreads(__tstate);
35425 if (PyErr_Occurred()) SWIG_fail;
35426 }
35427 {
35428 resultobj = wxPyMake_wxObject(result, 0);
35429 }
35430 return resultobj;
35431 fail:
35432 return NULL;
35433 }
35434
35435
35436 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35437 PyObject *resultobj = 0;
35438 wxWindow *arg1 = (wxWindow *) 0 ;
35439 bool result;
35440 void *argp1 = 0 ;
35441 int res1 = 0 ;
35442 PyObject *swig_obj[1] ;
35443
35444 if (!args) SWIG_fail;
35445 swig_obj[0] = args;
35446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35447 if (!SWIG_IsOK(res1)) {
35448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
35449 }
35450 arg1 = reinterpret_cast< wxWindow * >(argp1);
35451 {
35452 PyThreadState* __tstate = wxPyBeginAllowThreads();
35453 result = (bool)((wxWindow const *)arg1)->HasCapture();
35454 wxPyEndAllowThreads(__tstate);
35455 if (PyErr_Occurred()) SWIG_fail;
35456 }
35457 {
35458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35459 }
35460 return resultobj;
35461 fail:
35462 return NULL;
35463 }
35464
35465
35466 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35467 PyObject *resultobj = 0;
35468 wxWindow *arg1 = (wxWindow *) 0 ;
35469 bool arg2 = (bool) true ;
35470 wxRect *arg3 = (wxRect *) NULL ;
35471 void *argp1 = 0 ;
35472 int res1 = 0 ;
35473 bool val2 ;
35474 int ecode2 = 0 ;
35475 void *argp3 = 0 ;
35476 int res3 = 0 ;
35477 PyObject * obj0 = 0 ;
35478 PyObject * obj1 = 0 ;
35479 PyObject * obj2 = 0 ;
35480 char * kwnames[] = {
35481 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
35482 };
35483
35484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35486 if (!SWIG_IsOK(res1)) {
35487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
35488 }
35489 arg1 = reinterpret_cast< wxWindow * >(argp1);
35490 if (obj1) {
35491 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35492 if (!SWIG_IsOK(ecode2)) {
35493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
35494 }
35495 arg2 = static_cast< bool >(val2);
35496 }
35497 if (obj2) {
35498 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
35499 if (!SWIG_IsOK(res3)) {
35500 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
35501 }
35502 arg3 = reinterpret_cast< wxRect * >(argp3);
35503 }
35504 {
35505 PyThreadState* __tstate = wxPyBeginAllowThreads();
35506 (arg1)->Refresh(arg2,(wxRect const *)arg3);
35507 wxPyEndAllowThreads(__tstate);
35508 if (PyErr_Occurred()) SWIG_fail;
35509 }
35510 resultobj = SWIG_Py_Void();
35511 return resultobj;
35512 fail:
35513 return NULL;
35514 }
35515
35516
35517 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35518 PyObject *resultobj = 0;
35519 wxWindow *arg1 = (wxWindow *) 0 ;
35520 wxRect *arg2 = 0 ;
35521 bool arg3 = (bool) true ;
35522 void *argp1 = 0 ;
35523 int res1 = 0 ;
35524 wxRect temp2 ;
35525 bool val3 ;
35526 int ecode3 = 0 ;
35527 PyObject * obj0 = 0 ;
35528 PyObject * obj1 = 0 ;
35529 PyObject * obj2 = 0 ;
35530 char * kwnames[] = {
35531 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
35532 };
35533
35534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35536 if (!SWIG_IsOK(res1)) {
35537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
35538 }
35539 arg1 = reinterpret_cast< wxWindow * >(argp1);
35540 {
35541 arg2 = &temp2;
35542 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35543 }
35544 if (obj2) {
35545 ecode3 = SWIG_AsVal_bool(obj2, &val3);
35546 if (!SWIG_IsOK(ecode3)) {
35547 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
35548 }
35549 arg3 = static_cast< bool >(val3);
35550 }
35551 {
35552 PyThreadState* __tstate = wxPyBeginAllowThreads();
35553 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
35554 wxPyEndAllowThreads(__tstate);
35555 if (PyErr_Occurred()) SWIG_fail;
35556 }
35557 resultobj = SWIG_Py_Void();
35558 return resultobj;
35559 fail:
35560 return NULL;
35561 }
35562
35563
35564 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35565 PyObject *resultobj = 0;
35566 wxWindow *arg1 = (wxWindow *) 0 ;
35567 void *argp1 = 0 ;
35568 int res1 = 0 ;
35569 PyObject *swig_obj[1] ;
35570
35571 if (!args) SWIG_fail;
35572 swig_obj[0] = args;
35573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35574 if (!SWIG_IsOK(res1)) {
35575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
35576 }
35577 arg1 = reinterpret_cast< wxWindow * >(argp1);
35578 {
35579 PyThreadState* __tstate = wxPyBeginAllowThreads();
35580 (arg1)->Update();
35581 wxPyEndAllowThreads(__tstate);
35582 if (PyErr_Occurred()) SWIG_fail;
35583 }
35584 resultobj = SWIG_Py_Void();
35585 return resultobj;
35586 fail:
35587 return NULL;
35588 }
35589
35590
35591 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35592 PyObject *resultobj = 0;
35593 wxWindow *arg1 = (wxWindow *) 0 ;
35594 void *argp1 = 0 ;
35595 int res1 = 0 ;
35596 PyObject *swig_obj[1] ;
35597
35598 if (!args) SWIG_fail;
35599 swig_obj[0] = args;
35600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35601 if (!SWIG_IsOK(res1)) {
35602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35603 }
35604 arg1 = reinterpret_cast< wxWindow * >(argp1);
35605 {
35606 PyThreadState* __tstate = wxPyBeginAllowThreads();
35607 (arg1)->ClearBackground();
35608 wxPyEndAllowThreads(__tstate);
35609 if (PyErr_Occurred()) SWIG_fail;
35610 }
35611 resultobj = SWIG_Py_Void();
35612 return resultobj;
35613 fail:
35614 return NULL;
35615 }
35616
35617
35618 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35619 PyObject *resultobj = 0;
35620 wxWindow *arg1 = (wxWindow *) 0 ;
35621 void *argp1 = 0 ;
35622 int res1 = 0 ;
35623 PyObject *swig_obj[1] ;
35624
35625 if (!args) SWIG_fail;
35626 swig_obj[0] = args;
35627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35628 if (!SWIG_IsOK(res1)) {
35629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35630 }
35631 arg1 = reinterpret_cast< wxWindow * >(argp1);
35632 {
35633 PyThreadState* __tstate = wxPyBeginAllowThreads();
35634 (arg1)->Freeze();
35635 wxPyEndAllowThreads(__tstate);
35636 if (PyErr_Occurred()) SWIG_fail;
35637 }
35638 resultobj = SWIG_Py_Void();
35639 return resultobj;
35640 fail:
35641 return NULL;
35642 }
35643
35644
35645 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35646 PyObject *resultobj = 0;
35647 wxWindow *arg1 = (wxWindow *) 0 ;
35648 bool result;
35649 void *argp1 = 0 ;
35650 int res1 = 0 ;
35651 PyObject *swig_obj[1] ;
35652
35653 if (!args) SWIG_fail;
35654 swig_obj[0] = args;
35655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35656 if (!SWIG_IsOK(res1)) {
35657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35658 }
35659 arg1 = reinterpret_cast< wxWindow * >(argp1);
35660 {
35661 PyThreadState* __tstate = wxPyBeginAllowThreads();
35662 result = (bool)((wxWindow const *)arg1)->IsFrozen();
35663 wxPyEndAllowThreads(__tstate);
35664 if (PyErr_Occurred()) SWIG_fail;
35665 }
35666 {
35667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35668 }
35669 return resultobj;
35670 fail:
35671 return NULL;
35672 }
35673
35674
35675 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35676 PyObject *resultobj = 0;
35677 wxWindow *arg1 = (wxWindow *) 0 ;
35678 void *argp1 = 0 ;
35679 int res1 = 0 ;
35680 PyObject *swig_obj[1] ;
35681
35682 if (!args) SWIG_fail;
35683 swig_obj[0] = args;
35684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35685 if (!SWIG_IsOK(res1)) {
35686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35687 }
35688 arg1 = reinterpret_cast< wxWindow * >(argp1);
35689 {
35690 PyThreadState* __tstate = wxPyBeginAllowThreads();
35691 (arg1)->Thaw();
35692 wxPyEndAllowThreads(__tstate);
35693 if (PyErr_Occurred()) SWIG_fail;
35694 }
35695 resultobj = SWIG_Py_Void();
35696 return resultobj;
35697 fail:
35698 return NULL;
35699 }
35700
35701
35702 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35703 PyObject *resultobj = 0;
35704 wxWindow *arg1 = (wxWindow *) 0 ;
35705 wxDC *arg2 = 0 ;
35706 void *argp1 = 0 ;
35707 int res1 = 0 ;
35708 void *argp2 = 0 ;
35709 int res2 = 0 ;
35710 PyObject * obj0 = 0 ;
35711 PyObject * obj1 = 0 ;
35712 char * kwnames[] = {
35713 (char *) "self",(char *) "dc", NULL
35714 };
35715
35716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35718 if (!SWIG_IsOK(res1)) {
35719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35720 }
35721 arg1 = reinterpret_cast< wxWindow * >(argp1);
35722 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35723 if (!SWIG_IsOK(res2)) {
35724 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35725 }
35726 if (!argp2) {
35727 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35728 }
35729 arg2 = reinterpret_cast< wxDC * >(argp2);
35730 {
35731 PyThreadState* __tstate = wxPyBeginAllowThreads();
35732 (arg1)->PrepareDC(*arg2);
35733 wxPyEndAllowThreads(__tstate);
35734 if (PyErr_Occurred()) SWIG_fail;
35735 }
35736 resultobj = SWIG_Py_Void();
35737 return resultobj;
35738 fail:
35739 return NULL;
35740 }
35741
35742
35743 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35744 PyObject *resultobj = 0;
35745 wxWindow *arg1 = (wxWindow *) 0 ;
35746 bool result;
35747 void *argp1 = 0 ;
35748 int res1 = 0 ;
35749 PyObject *swig_obj[1] ;
35750
35751 if (!args) SWIG_fail;
35752 swig_obj[0] = args;
35753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35754 if (!SWIG_IsOK(res1)) {
35755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
35756 }
35757 arg1 = reinterpret_cast< wxWindow * >(argp1);
35758 {
35759 PyThreadState* __tstate = wxPyBeginAllowThreads();
35760 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
35761 wxPyEndAllowThreads(__tstate);
35762 if (PyErr_Occurred()) SWIG_fail;
35763 }
35764 {
35765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35766 }
35767 return resultobj;
35768 fail:
35769 return NULL;
35770 }
35771
35772
35773 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35774 PyObject *resultobj = 0;
35775 wxWindow *arg1 = (wxWindow *) 0 ;
35776 wxRegion *result = 0 ;
35777 void *argp1 = 0 ;
35778 int res1 = 0 ;
35779 PyObject *swig_obj[1] ;
35780
35781 if (!args) SWIG_fail;
35782 swig_obj[0] = args;
35783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35784 if (!SWIG_IsOK(res1)) {
35785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35786 }
35787 arg1 = reinterpret_cast< wxWindow * >(argp1);
35788 {
35789 PyThreadState* __tstate = wxPyBeginAllowThreads();
35790 {
35791 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35792 result = (wxRegion *) &_result_ref;
35793 }
35794 wxPyEndAllowThreads(__tstate);
35795 if (PyErr_Occurred()) SWIG_fail;
35796 }
35797 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35798 return resultobj;
35799 fail:
35800 return NULL;
35801 }
35802
35803
35804 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35805 PyObject *resultobj = 0;
35806 wxWindow *arg1 = (wxWindow *) 0 ;
35807 wxRect result;
35808 void *argp1 = 0 ;
35809 int res1 = 0 ;
35810 PyObject *swig_obj[1] ;
35811
35812 if (!args) SWIG_fail;
35813 swig_obj[0] = args;
35814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35815 if (!SWIG_IsOK(res1)) {
35816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35817 }
35818 arg1 = reinterpret_cast< wxWindow * >(argp1);
35819 {
35820 PyThreadState* __tstate = wxPyBeginAllowThreads();
35821 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35822 wxPyEndAllowThreads(__tstate);
35823 if (PyErr_Occurred()) SWIG_fail;
35824 }
35825 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35826 return resultobj;
35827 fail:
35828 return NULL;
35829 }
35830
35831
35832 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35833 PyObject *resultobj = 0;
35834 wxWindow *arg1 = (wxWindow *) 0 ;
35835 int arg2 ;
35836 int arg3 ;
35837 int arg4 = (int) 1 ;
35838 int arg5 = (int) 1 ;
35839 bool result;
35840 void *argp1 = 0 ;
35841 int res1 = 0 ;
35842 int val2 ;
35843 int ecode2 = 0 ;
35844 int val3 ;
35845 int ecode3 = 0 ;
35846 int val4 ;
35847 int ecode4 = 0 ;
35848 int val5 ;
35849 int ecode5 = 0 ;
35850 PyObject * obj0 = 0 ;
35851 PyObject * obj1 = 0 ;
35852 PyObject * obj2 = 0 ;
35853 PyObject * obj3 = 0 ;
35854 PyObject * obj4 = 0 ;
35855 char * kwnames[] = {
35856 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35857 };
35858
35859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35861 if (!SWIG_IsOK(res1)) {
35862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35863 }
35864 arg1 = reinterpret_cast< wxWindow * >(argp1);
35865 ecode2 = SWIG_AsVal_int(obj1, &val2);
35866 if (!SWIG_IsOK(ecode2)) {
35867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35868 }
35869 arg2 = static_cast< int >(val2);
35870 ecode3 = SWIG_AsVal_int(obj2, &val3);
35871 if (!SWIG_IsOK(ecode3)) {
35872 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35873 }
35874 arg3 = static_cast< int >(val3);
35875 if (obj3) {
35876 ecode4 = SWIG_AsVal_int(obj3, &val4);
35877 if (!SWIG_IsOK(ecode4)) {
35878 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35879 }
35880 arg4 = static_cast< int >(val4);
35881 }
35882 if (obj4) {
35883 ecode5 = SWIG_AsVal_int(obj4, &val5);
35884 if (!SWIG_IsOK(ecode5)) {
35885 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35886 }
35887 arg5 = static_cast< int >(val5);
35888 }
35889 {
35890 PyThreadState* __tstate = wxPyBeginAllowThreads();
35891 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
35892 wxPyEndAllowThreads(__tstate);
35893 if (PyErr_Occurred()) SWIG_fail;
35894 }
35895 {
35896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35897 }
35898 return resultobj;
35899 fail:
35900 return NULL;
35901 }
35902
35903
35904 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35905 PyObject *resultobj = 0;
35906 wxWindow *arg1 = (wxWindow *) 0 ;
35907 wxPoint *arg2 = 0 ;
35908 bool result;
35909 void *argp1 = 0 ;
35910 int res1 = 0 ;
35911 wxPoint temp2 ;
35912 PyObject * obj0 = 0 ;
35913 PyObject * obj1 = 0 ;
35914 char * kwnames[] = {
35915 (char *) "self",(char *) "pt", NULL
35916 };
35917
35918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
35919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35920 if (!SWIG_IsOK(res1)) {
35921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35922 }
35923 arg1 = reinterpret_cast< wxWindow * >(argp1);
35924 {
35925 arg2 = &temp2;
35926 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35927 }
35928 {
35929 PyThreadState* __tstate = wxPyBeginAllowThreads();
35930 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35931 wxPyEndAllowThreads(__tstate);
35932 if (PyErr_Occurred()) SWIG_fail;
35933 }
35934 {
35935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35936 }
35937 return resultobj;
35938 fail:
35939 return NULL;
35940 }
35941
35942
35943 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35944 PyObject *resultobj = 0;
35945 wxWindow *arg1 = (wxWindow *) 0 ;
35946 wxRect *arg2 = 0 ;
35947 bool result;
35948 void *argp1 = 0 ;
35949 int res1 = 0 ;
35950 wxRect temp2 ;
35951 PyObject * obj0 = 0 ;
35952 PyObject * obj1 = 0 ;
35953 char * kwnames[] = {
35954 (char *) "self",(char *) "rect", NULL
35955 };
35956
35957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35959 if (!SWIG_IsOK(res1)) {
35960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35961 }
35962 arg1 = reinterpret_cast< wxWindow * >(argp1);
35963 {
35964 arg2 = &temp2;
35965 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35966 }
35967 {
35968 PyThreadState* __tstate = wxPyBeginAllowThreads();
35969 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35970 wxPyEndAllowThreads(__tstate);
35971 if (PyErr_Occurred()) SWIG_fail;
35972 }
35973 {
35974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35975 }
35976 return resultobj;
35977 fail:
35978 return NULL;
35979 }
35980
35981
35982 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35983 PyObject *resultobj = 0;
35984 wxWindow *arg1 = (wxWindow *) 0 ;
35985 SwigValueWrapper<wxVisualAttributes > result;
35986 void *argp1 = 0 ;
35987 int res1 = 0 ;
35988 PyObject *swig_obj[1] ;
35989
35990 if (!args) SWIG_fail;
35991 swig_obj[0] = args;
35992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35993 if (!SWIG_IsOK(res1)) {
35994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35995 }
35996 arg1 = reinterpret_cast< wxWindow * >(argp1);
35997 {
35998 PyThreadState* __tstate = wxPyBeginAllowThreads();
35999 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
36000 wxPyEndAllowThreads(__tstate);
36001 if (PyErr_Occurred()) SWIG_fail;
36002 }
36003 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
36004 return resultobj;
36005 fail:
36006 return NULL;
36007 }
36008
36009
36010 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36011 PyObject *resultobj = 0;
36012 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
36013 SwigValueWrapper<wxVisualAttributes > result;
36014 int val1 ;
36015 int ecode1 = 0 ;
36016 PyObject * obj0 = 0 ;
36017 char * kwnames[] = {
36018 (char *) "variant", NULL
36019 };
36020
36021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
36022 if (obj0) {
36023 ecode1 = SWIG_AsVal_int(obj0, &val1);
36024 if (!SWIG_IsOK(ecode1)) {
36025 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
36026 }
36027 arg1 = static_cast< wxWindowVariant >(val1);
36028 }
36029 {
36030 if (!wxPyCheckForApp()) SWIG_fail;
36031 PyThreadState* __tstate = wxPyBeginAllowThreads();
36032 result = wxWindow::GetClassDefaultAttributes(arg1);
36033 wxPyEndAllowThreads(__tstate);
36034 if (PyErr_Occurred()) SWIG_fail;
36035 }
36036 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
36037 return resultobj;
36038 fail:
36039 return NULL;
36040 }
36041
36042
36043 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36044 PyObject *resultobj = 0;
36045 wxWindow *arg1 = (wxWindow *) 0 ;
36046 wxColour *arg2 = 0 ;
36047 bool result;
36048 void *argp1 = 0 ;
36049 int res1 = 0 ;
36050 wxColour temp2 ;
36051 PyObject * obj0 = 0 ;
36052 PyObject * obj1 = 0 ;
36053 char * kwnames[] = {
36054 (char *) "self",(char *) "colour", NULL
36055 };
36056
36057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36059 if (!SWIG_IsOK(res1)) {
36060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36061 }
36062 arg1 = reinterpret_cast< wxWindow * >(argp1);
36063 {
36064 arg2 = &temp2;
36065 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36066 }
36067 {
36068 PyThreadState* __tstate = wxPyBeginAllowThreads();
36069 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
36070 wxPyEndAllowThreads(__tstate);
36071 if (PyErr_Occurred()) SWIG_fail;
36072 }
36073 {
36074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36075 }
36076 return resultobj;
36077 fail:
36078 return NULL;
36079 }
36080
36081
36082 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36083 PyObject *resultobj = 0;
36084 wxWindow *arg1 = (wxWindow *) 0 ;
36085 wxColour *arg2 = 0 ;
36086 void *argp1 = 0 ;
36087 int res1 = 0 ;
36088 wxColour temp2 ;
36089 PyObject * obj0 = 0 ;
36090 PyObject * obj1 = 0 ;
36091 char * kwnames[] = {
36092 (char *) "self",(char *) "colour", NULL
36093 };
36094
36095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36097 if (!SWIG_IsOK(res1)) {
36098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36099 }
36100 arg1 = reinterpret_cast< wxWindow * >(argp1);
36101 {
36102 arg2 = &temp2;
36103 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36104 }
36105 {
36106 PyThreadState* __tstate = wxPyBeginAllowThreads();
36107 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
36108 wxPyEndAllowThreads(__tstate);
36109 if (PyErr_Occurred()) SWIG_fail;
36110 }
36111 resultobj = SWIG_Py_Void();
36112 return resultobj;
36113 fail:
36114 return NULL;
36115 }
36116
36117
36118 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36119 PyObject *resultobj = 0;
36120 wxWindow *arg1 = (wxWindow *) 0 ;
36121 wxColour *arg2 = 0 ;
36122 bool result;
36123 void *argp1 = 0 ;
36124 int res1 = 0 ;
36125 wxColour temp2 ;
36126 PyObject * obj0 = 0 ;
36127 PyObject * obj1 = 0 ;
36128 char * kwnames[] = {
36129 (char *) "self",(char *) "colour", NULL
36130 };
36131
36132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36134 if (!SWIG_IsOK(res1)) {
36135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36136 }
36137 arg1 = reinterpret_cast< wxWindow * >(argp1);
36138 {
36139 arg2 = &temp2;
36140 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36141 }
36142 {
36143 PyThreadState* __tstate = wxPyBeginAllowThreads();
36144 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
36145 wxPyEndAllowThreads(__tstate);
36146 if (PyErr_Occurred()) SWIG_fail;
36147 }
36148 {
36149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36150 }
36151 return resultobj;
36152 fail:
36153 return NULL;
36154 }
36155
36156
36157 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36158 PyObject *resultobj = 0;
36159 wxWindow *arg1 = (wxWindow *) 0 ;
36160 wxColour *arg2 = 0 ;
36161 void *argp1 = 0 ;
36162 int res1 = 0 ;
36163 wxColour temp2 ;
36164 PyObject * obj0 = 0 ;
36165 PyObject * obj1 = 0 ;
36166 char * kwnames[] = {
36167 (char *) "self",(char *) "colour", NULL
36168 };
36169
36170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36172 if (!SWIG_IsOK(res1)) {
36173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36174 }
36175 arg1 = reinterpret_cast< wxWindow * >(argp1);
36176 {
36177 arg2 = &temp2;
36178 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36179 }
36180 {
36181 PyThreadState* __tstate = wxPyBeginAllowThreads();
36182 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
36183 wxPyEndAllowThreads(__tstate);
36184 if (PyErr_Occurred()) SWIG_fail;
36185 }
36186 resultobj = SWIG_Py_Void();
36187 return resultobj;
36188 fail:
36189 return NULL;
36190 }
36191
36192
36193 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36194 PyObject *resultobj = 0;
36195 wxWindow *arg1 = (wxWindow *) 0 ;
36196 wxColour result;
36197 void *argp1 = 0 ;
36198 int res1 = 0 ;
36199 PyObject *swig_obj[1] ;
36200
36201 if (!args) SWIG_fail;
36202 swig_obj[0] = args;
36203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36204 if (!SWIG_IsOK(res1)) {
36205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36206 }
36207 arg1 = reinterpret_cast< wxWindow * >(argp1);
36208 {
36209 PyThreadState* __tstate = wxPyBeginAllowThreads();
36210 result = ((wxWindow const *)arg1)->GetBackgroundColour();
36211 wxPyEndAllowThreads(__tstate);
36212 if (PyErr_Occurred()) SWIG_fail;
36213 }
36214 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
36215 return resultobj;
36216 fail:
36217 return NULL;
36218 }
36219
36220
36221 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36222 PyObject *resultobj = 0;
36223 wxWindow *arg1 = (wxWindow *) 0 ;
36224 wxColour result;
36225 void *argp1 = 0 ;
36226 int res1 = 0 ;
36227 PyObject *swig_obj[1] ;
36228
36229 if (!args) SWIG_fail;
36230 swig_obj[0] = args;
36231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36232 if (!SWIG_IsOK(res1)) {
36233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36234 }
36235 arg1 = reinterpret_cast< wxWindow * >(argp1);
36236 {
36237 PyThreadState* __tstate = wxPyBeginAllowThreads();
36238 result = ((wxWindow const *)arg1)->GetForegroundColour();
36239 wxPyEndAllowThreads(__tstate);
36240 if (PyErr_Occurred()) SWIG_fail;
36241 }
36242 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
36243 return resultobj;
36244 fail:
36245 return NULL;
36246 }
36247
36248
36249 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36250 PyObject *resultobj = 0;
36251 wxWindow *arg1 = (wxWindow *) 0 ;
36252 bool result;
36253 void *argp1 = 0 ;
36254 int res1 = 0 ;
36255 PyObject *swig_obj[1] ;
36256
36257 if (!args) SWIG_fail;
36258 swig_obj[0] = args;
36259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36260 if (!SWIG_IsOK(res1)) {
36261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36262 }
36263 arg1 = reinterpret_cast< wxWindow * >(argp1);
36264 {
36265 PyThreadState* __tstate = wxPyBeginAllowThreads();
36266 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
36267 wxPyEndAllowThreads(__tstate);
36268 if (PyErr_Occurred()) SWIG_fail;
36269 }
36270 {
36271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36272 }
36273 return resultobj;
36274 fail:
36275 return NULL;
36276 }
36277
36278
36279 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36280 PyObject *resultobj = 0;
36281 wxWindow *arg1 = (wxWindow *) 0 ;
36282 bool result;
36283 void *argp1 = 0 ;
36284 int res1 = 0 ;
36285 PyObject *swig_obj[1] ;
36286
36287 if (!args) SWIG_fail;
36288 swig_obj[0] = args;
36289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36290 if (!SWIG_IsOK(res1)) {
36291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
36292 }
36293 arg1 = reinterpret_cast< wxWindow * >(argp1);
36294 {
36295 PyThreadState* __tstate = wxPyBeginAllowThreads();
36296 result = (bool)((wxWindow const *)arg1)->UseBgCol();
36297 wxPyEndAllowThreads(__tstate);
36298 if (PyErr_Occurred()) SWIG_fail;
36299 }
36300 {
36301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36302 }
36303 return resultobj;
36304 fail:
36305 return NULL;
36306 }
36307
36308
36309 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36310 PyObject *resultobj = 0;
36311 wxWindow *arg1 = (wxWindow *) 0 ;
36312 wxBackgroundStyle arg2 ;
36313 bool result;
36314 void *argp1 = 0 ;
36315 int res1 = 0 ;
36316 int val2 ;
36317 int ecode2 = 0 ;
36318 PyObject * obj0 = 0 ;
36319 PyObject * obj1 = 0 ;
36320 char * kwnames[] = {
36321 (char *) "self",(char *) "style", NULL
36322 };
36323
36324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36326 if (!SWIG_IsOK(res1)) {
36327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36328 }
36329 arg1 = reinterpret_cast< wxWindow * >(argp1);
36330 ecode2 = SWIG_AsVal_int(obj1, &val2);
36331 if (!SWIG_IsOK(ecode2)) {
36332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
36333 }
36334 arg2 = static_cast< wxBackgroundStyle >(val2);
36335 {
36336 PyThreadState* __tstate = wxPyBeginAllowThreads();
36337 result = (bool)(arg1)->SetBackgroundStyle(arg2);
36338 wxPyEndAllowThreads(__tstate);
36339 if (PyErr_Occurred()) SWIG_fail;
36340 }
36341 {
36342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36343 }
36344 return resultobj;
36345 fail:
36346 return NULL;
36347 }
36348
36349
36350 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36351 PyObject *resultobj = 0;
36352 wxWindow *arg1 = (wxWindow *) 0 ;
36353 wxBackgroundStyle result;
36354 void *argp1 = 0 ;
36355 int res1 = 0 ;
36356 PyObject *swig_obj[1] ;
36357
36358 if (!args) SWIG_fail;
36359 swig_obj[0] = args;
36360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36361 if (!SWIG_IsOK(res1)) {
36362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36363 }
36364 arg1 = reinterpret_cast< wxWindow * >(argp1);
36365 {
36366 PyThreadState* __tstate = wxPyBeginAllowThreads();
36367 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
36368 wxPyEndAllowThreads(__tstate);
36369 if (PyErr_Occurred()) SWIG_fail;
36370 }
36371 resultobj = SWIG_From_int(static_cast< int >(result));
36372 return resultobj;
36373 fail:
36374 return NULL;
36375 }
36376
36377
36378 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36379 PyObject *resultobj = 0;
36380 wxWindow *arg1 = (wxWindow *) 0 ;
36381 bool result;
36382 void *argp1 = 0 ;
36383 int res1 = 0 ;
36384 PyObject *swig_obj[1] ;
36385
36386 if (!args) SWIG_fail;
36387 swig_obj[0] = args;
36388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36389 if (!SWIG_IsOK(res1)) {
36390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
36391 }
36392 arg1 = reinterpret_cast< wxWindow * >(argp1);
36393 {
36394 PyThreadState* __tstate = wxPyBeginAllowThreads();
36395 result = (bool)(arg1)->HasTransparentBackground();
36396 wxPyEndAllowThreads(__tstate);
36397 if (PyErr_Occurred()) SWIG_fail;
36398 }
36399 {
36400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36401 }
36402 return resultobj;
36403 fail:
36404 return NULL;
36405 }
36406
36407
36408 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36409 PyObject *resultobj = 0;
36410 wxWindow *arg1 = (wxWindow *) 0 ;
36411 wxCursor *arg2 = 0 ;
36412 bool result;
36413 void *argp1 = 0 ;
36414 int res1 = 0 ;
36415 void *argp2 = 0 ;
36416 int res2 = 0 ;
36417 PyObject * obj0 = 0 ;
36418 PyObject * obj1 = 0 ;
36419 char * kwnames[] = {
36420 (char *) "self",(char *) "cursor", NULL
36421 };
36422
36423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
36424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36425 if (!SWIG_IsOK(res1)) {
36426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
36427 }
36428 arg1 = reinterpret_cast< wxWindow * >(argp1);
36429 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
36430 if (!SWIG_IsOK(res2)) {
36431 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
36432 }
36433 if (!argp2) {
36434 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
36435 }
36436 arg2 = reinterpret_cast< wxCursor * >(argp2);
36437 {
36438 PyThreadState* __tstate = wxPyBeginAllowThreads();
36439 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
36440 wxPyEndAllowThreads(__tstate);
36441 if (PyErr_Occurred()) SWIG_fail;
36442 }
36443 {
36444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36445 }
36446 return resultobj;
36447 fail:
36448 return NULL;
36449 }
36450
36451
36452 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36453 PyObject *resultobj = 0;
36454 wxWindow *arg1 = (wxWindow *) 0 ;
36455 wxCursor result;
36456 void *argp1 = 0 ;
36457 int res1 = 0 ;
36458 PyObject *swig_obj[1] ;
36459
36460 if (!args) SWIG_fail;
36461 swig_obj[0] = args;
36462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36463 if (!SWIG_IsOK(res1)) {
36464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
36465 }
36466 arg1 = reinterpret_cast< wxWindow * >(argp1);
36467 {
36468 PyThreadState* __tstate = wxPyBeginAllowThreads();
36469 result = (arg1)->GetCursor();
36470 wxPyEndAllowThreads(__tstate);
36471 if (PyErr_Occurred()) SWIG_fail;
36472 }
36473 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
36474 return resultobj;
36475 fail:
36476 return NULL;
36477 }
36478
36479
36480 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36481 PyObject *resultobj = 0;
36482 wxWindow *arg1 = (wxWindow *) 0 ;
36483 wxFont *arg2 = 0 ;
36484 bool result;
36485 void *argp1 = 0 ;
36486 int res1 = 0 ;
36487 void *argp2 = 0 ;
36488 int res2 = 0 ;
36489 PyObject * obj0 = 0 ;
36490 PyObject * obj1 = 0 ;
36491 char * kwnames[] = {
36492 (char *) "self",(char *) "font", NULL
36493 };
36494
36495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
36496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36497 if (!SWIG_IsOK(res1)) {
36498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36499 }
36500 arg1 = reinterpret_cast< wxWindow * >(argp1);
36501 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36502 if (!SWIG_IsOK(res2)) {
36503 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36504 }
36505 if (!argp2) {
36506 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36507 }
36508 arg2 = reinterpret_cast< wxFont * >(argp2);
36509 {
36510 PyThreadState* __tstate = wxPyBeginAllowThreads();
36511 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
36512 wxPyEndAllowThreads(__tstate);
36513 if (PyErr_Occurred()) SWIG_fail;
36514 }
36515 {
36516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36517 }
36518 return resultobj;
36519 fail:
36520 return NULL;
36521 }
36522
36523
36524 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36525 PyObject *resultobj = 0;
36526 wxWindow *arg1 = (wxWindow *) 0 ;
36527 wxFont *arg2 = 0 ;
36528 void *argp1 = 0 ;
36529 int res1 = 0 ;
36530 void *argp2 = 0 ;
36531 int res2 = 0 ;
36532 PyObject * obj0 = 0 ;
36533 PyObject * obj1 = 0 ;
36534 char * kwnames[] = {
36535 (char *) "self",(char *) "font", NULL
36536 };
36537
36538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
36539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36540 if (!SWIG_IsOK(res1)) {
36541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36542 }
36543 arg1 = reinterpret_cast< wxWindow * >(argp1);
36544 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36545 if (!SWIG_IsOK(res2)) {
36546 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36547 }
36548 if (!argp2) {
36549 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36550 }
36551 arg2 = reinterpret_cast< wxFont * >(argp2);
36552 {
36553 PyThreadState* __tstate = wxPyBeginAllowThreads();
36554 (arg1)->SetOwnFont((wxFont const &)*arg2);
36555 wxPyEndAllowThreads(__tstate);
36556 if (PyErr_Occurred()) SWIG_fail;
36557 }
36558 resultobj = SWIG_Py_Void();
36559 return resultobj;
36560 fail:
36561 return NULL;
36562 }
36563
36564
36565 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36566 PyObject *resultobj = 0;
36567 wxWindow *arg1 = (wxWindow *) 0 ;
36568 wxFont result;
36569 void *argp1 = 0 ;
36570 int res1 = 0 ;
36571 PyObject *swig_obj[1] ;
36572
36573 if (!args) SWIG_fail;
36574 swig_obj[0] = args;
36575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36576 if (!SWIG_IsOK(res1)) {
36577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36578 }
36579 arg1 = reinterpret_cast< wxWindow * >(argp1);
36580 {
36581 PyThreadState* __tstate = wxPyBeginAllowThreads();
36582 result = (arg1)->GetFont();
36583 wxPyEndAllowThreads(__tstate);
36584 if (PyErr_Occurred()) SWIG_fail;
36585 }
36586 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
36587 return resultobj;
36588 fail:
36589 return NULL;
36590 }
36591
36592
36593 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36594 PyObject *resultobj = 0;
36595 wxWindow *arg1 = (wxWindow *) 0 ;
36596 wxCaret *arg2 = (wxCaret *) 0 ;
36597 void *argp1 = 0 ;
36598 int res1 = 0 ;
36599 int res2 = 0 ;
36600 PyObject * obj0 = 0 ;
36601 PyObject * obj1 = 0 ;
36602 char * kwnames[] = {
36603 (char *) "self",(char *) "caret", NULL
36604 };
36605
36606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
36607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36608 if (!SWIG_IsOK(res1)) {
36609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
36610 }
36611 arg1 = reinterpret_cast< wxWindow * >(argp1);
36612 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
36613 if (!SWIG_IsOK(res2)) {
36614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
36615 }
36616 {
36617 PyThreadState* __tstate = wxPyBeginAllowThreads();
36618 (arg1)->SetCaret(arg2);
36619 wxPyEndAllowThreads(__tstate);
36620 if (PyErr_Occurred()) SWIG_fail;
36621 }
36622 resultobj = SWIG_Py_Void();
36623 return resultobj;
36624 fail:
36625 return NULL;
36626 }
36627
36628
36629 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36630 PyObject *resultobj = 0;
36631 wxWindow *arg1 = (wxWindow *) 0 ;
36632 wxCaret *result = 0 ;
36633 void *argp1 = 0 ;
36634 int res1 = 0 ;
36635 PyObject *swig_obj[1] ;
36636
36637 if (!args) SWIG_fail;
36638 swig_obj[0] = args;
36639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36640 if (!SWIG_IsOK(res1)) {
36641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
36642 }
36643 arg1 = reinterpret_cast< wxWindow * >(argp1);
36644 {
36645 PyThreadState* __tstate = wxPyBeginAllowThreads();
36646 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
36647 wxPyEndAllowThreads(__tstate);
36648 if (PyErr_Occurred()) SWIG_fail;
36649 }
36650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
36651 return resultobj;
36652 fail:
36653 return NULL;
36654 }
36655
36656
36657 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36658 PyObject *resultobj = 0;
36659 wxWindow *arg1 = (wxWindow *) 0 ;
36660 int result;
36661 void *argp1 = 0 ;
36662 int res1 = 0 ;
36663 PyObject *swig_obj[1] ;
36664
36665 if (!args) SWIG_fail;
36666 swig_obj[0] = args;
36667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36668 if (!SWIG_IsOK(res1)) {
36669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
36670 }
36671 arg1 = reinterpret_cast< wxWindow * >(argp1);
36672 {
36673 PyThreadState* __tstate = wxPyBeginAllowThreads();
36674 result = (int)((wxWindow const *)arg1)->GetCharHeight();
36675 wxPyEndAllowThreads(__tstate);
36676 if (PyErr_Occurred()) SWIG_fail;
36677 }
36678 resultobj = SWIG_From_int(static_cast< int >(result));
36679 return resultobj;
36680 fail:
36681 return NULL;
36682 }
36683
36684
36685 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36686 PyObject *resultobj = 0;
36687 wxWindow *arg1 = (wxWindow *) 0 ;
36688 int result;
36689 void *argp1 = 0 ;
36690 int res1 = 0 ;
36691 PyObject *swig_obj[1] ;
36692
36693 if (!args) SWIG_fail;
36694 swig_obj[0] = args;
36695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36696 if (!SWIG_IsOK(res1)) {
36697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36698 }
36699 arg1 = reinterpret_cast< wxWindow * >(argp1);
36700 {
36701 PyThreadState* __tstate = wxPyBeginAllowThreads();
36702 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36703 wxPyEndAllowThreads(__tstate);
36704 if (PyErr_Occurred()) SWIG_fail;
36705 }
36706 resultobj = SWIG_From_int(static_cast< int >(result));
36707 return resultobj;
36708 fail:
36709 return NULL;
36710 }
36711
36712
36713 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36714 PyObject *resultobj = 0;
36715 wxWindow *arg1 = (wxWindow *) 0 ;
36716 wxString *arg2 = 0 ;
36717 int *arg3 = (int *) 0 ;
36718 int *arg4 = (int *) 0 ;
36719 void *argp1 = 0 ;
36720 int res1 = 0 ;
36721 bool temp2 = false ;
36722 int temp3 ;
36723 int res3 = SWIG_TMPOBJ ;
36724 int temp4 ;
36725 int res4 = SWIG_TMPOBJ ;
36726 PyObject * obj0 = 0 ;
36727 PyObject * obj1 = 0 ;
36728 char * kwnames[] = {
36729 (char *) "self",(char *) "string", NULL
36730 };
36731
36732 arg3 = &temp3;
36733 arg4 = &temp4;
36734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36736 if (!SWIG_IsOK(res1)) {
36737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36738 }
36739 arg1 = reinterpret_cast< wxWindow * >(argp1);
36740 {
36741 arg2 = wxString_in_helper(obj1);
36742 if (arg2 == NULL) SWIG_fail;
36743 temp2 = true;
36744 }
36745 {
36746 PyThreadState* __tstate = wxPyBeginAllowThreads();
36747 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36748 wxPyEndAllowThreads(__tstate);
36749 if (PyErr_Occurred()) SWIG_fail;
36750 }
36751 resultobj = SWIG_Py_Void();
36752 if (SWIG_IsTmpObj(res3)) {
36753 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36754 } else {
36755 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36756 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36757 }
36758 if (SWIG_IsTmpObj(res4)) {
36759 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36760 } else {
36761 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36762 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36763 }
36764 {
36765 if (temp2)
36766 delete arg2;
36767 }
36768 return resultobj;
36769 fail:
36770 {
36771 if (temp2)
36772 delete arg2;
36773 }
36774 return NULL;
36775 }
36776
36777
36778 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36779 PyObject *resultobj = 0;
36780 wxWindow *arg1 = (wxWindow *) 0 ;
36781 wxString *arg2 = 0 ;
36782 int *arg3 = (int *) 0 ;
36783 int *arg4 = (int *) 0 ;
36784 int *arg5 = (int *) 0 ;
36785 int *arg6 = (int *) 0 ;
36786 wxFont *arg7 = (wxFont *) NULL ;
36787 void *argp1 = 0 ;
36788 int res1 = 0 ;
36789 bool temp2 = false ;
36790 int temp3 ;
36791 int res3 = SWIG_TMPOBJ ;
36792 int temp4 ;
36793 int res4 = SWIG_TMPOBJ ;
36794 int temp5 ;
36795 int res5 = SWIG_TMPOBJ ;
36796 int temp6 ;
36797 int res6 = SWIG_TMPOBJ ;
36798 void *argp7 = 0 ;
36799 int res7 = 0 ;
36800 PyObject * obj0 = 0 ;
36801 PyObject * obj1 = 0 ;
36802 PyObject * obj2 = 0 ;
36803 char * kwnames[] = {
36804 (char *) "self",(char *) "string",(char *) "font", NULL
36805 };
36806
36807 arg3 = &temp3;
36808 arg4 = &temp4;
36809 arg5 = &temp5;
36810 arg6 = &temp6;
36811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36813 if (!SWIG_IsOK(res1)) {
36814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36815 }
36816 arg1 = reinterpret_cast< wxWindow * >(argp1);
36817 {
36818 arg2 = wxString_in_helper(obj1);
36819 if (arg2 == NULL) SWIG_fail;
36820 temp2 = true;
36821 }
36822 if (obj2) {
36823 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36824 if (!SWIG_IsOK(res7)) {
36825 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36826 }
36827 arg7 = reinterpret_cast< wxFont * >(argp7);
36828 }
36829 {
36830 PyThreadState* __tstate = wxPyBeginAllowThreads();
36831 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36832 wxPyEndAllowThreads(__tstate);
36833 if (PyErr_Occurred()) SWIG_fail;
36834 }
36835 resultobj = SWIG_Py_Void();
36836 if (SWIG_IsTmpObj(res3)) {
36837 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36838 } else {
36839 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36840 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36841 }
36842 if (SWIG_IsTmpObj(res4)) {
36843 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36844 } else {
36845 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36846 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36847 }
36848 if (SWIG_IsTmpObj(res5)) {
36849 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36850 } else {
36851 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36852 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36853 }
36854 if (SWIG_IsTmpObj(res6)) {
36855 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36856 } else {
36857 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36858 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36859 }
36860 {
36861 if (temp2)
36862 delete arg2;
36863 }
36864 return resultobj;
36865 fail:
36866 {
36867 if (temp2)
36868 delete arg2;
36869 }
36870 return NULL;
36871 }
36872
36873
36874 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36875 PyObject *resultobj = 0;
36876 wxWindow *arg1 = (wxWindow *) 0 ;
36877 int *arg2 = (int *) 0 ;
36878 int *arg3 = (int *) 0 ;
36879 void *argp1 = 0 ;
36880 int res1 = 0 ;
36881 int temp2 ;
36882 int res2 = 0 ;
36883 int temp3 ;
36884 int res3 = 0 ;
36885 PyObject * obj0 = 0 ;
36886 PyObject * obj1 = 0 ;
36887 PyObject * obj2 = 0 ;
36888 char * kwnames[] = {
36889 (char *) "self",(char *) "x",(char *) "y", NULL
36890 };
36891
36892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36894 if (!SWIG_IsOK(res1)) {
36895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36896 }
36897 arg1 = reinterpret_cast< wxWindow * >(argp1);
36898 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36899 int val;
36900 int ecode = SWIG_AsVal_int(obj1, &val);
36901 if (!SWIG_IsOK(ecode)) {
36902 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36903 }
36904 temp2 = static_cast< int >(val);
36905 arg2 = &temp2;
36906 res2 = SWIG_AddTmpMask(ecode);
36907 }
36908 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36909 int val;
36910 int ecode = SWIG_AsVal_int(obj2, &val);
36911 if (!SWIG_IsOK(ecode)) {
36912 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36913 }
36914 temp3 = static_cast< int >(val);
36915 arg3 = &temp3;
36916 res3 = SWIG_AddTmpMask(ecode);
36917 }
36918 {
36919 PyThreadState* __tstate = wxPyBeginAllowThreads();
36920 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36921 wxPyEndAllowThreads(__tstate);
36922 if (PyErr_Occurred()) SWIG_fail;
36923 }
36924 resultobj = SWIG_Py_Void();
36925 if (SWIG_IsTmpObj(res2)) {
36926 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36927 } else {
36928 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36929 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36930 }
36931 if (SWIG_IsTmpObj(res3)) {
36932 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36933 } else {
36934 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36935 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36936 }
36937 return resultobj;
36938 fail:
36939 return NULL;
36940 }
36941
36942
36943 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36944 PyObject *resultobj = 0;
36945 wxWindow *arg1 = (wxWindow *) 0 ;
36946 int *arg2 = (int *) 0 ;
36947 int *arg3 = (int *) 0 ;
36948 void *argp1 = 0 ;
36949 int res1 = 0 ;
36950 int temp2 ;
36951 int res2 = 0 ;
36952 int temp3 ;
36953 int res3 = 0 ;
36954 PyObject * obj0 = 0 ;
36955 PyObject * obj1 = 0 ;
36956 PyObject * obj2 = 0 ;
36957 char * kwnames[] = {
36958 (char *) "self",(char *) "x",(char *) "y", NULL
36959 };
36960
36961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36963 if (!SWIG_IsOK(res1)) {
36964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36965 }
36966 arg1 = reinterpret_cast< wxWindow * >(argp1);
36967 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36968 int val;
36969 int ecode = SWIG_AsVal_int(obj1, &val);
36970 if (!SWIG_IsOK(ecode)) {
36971 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36972 }
36973 temp2 = static_cast< int >(val);
36974 arg2 = &temp2;
36975 res2 = SWIG_AddTmpMask(ecode);
36976 }
36977 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36978 int val;
36979 int ecode = SWIG_AsVal_int(obj2, &val);
36980 if (!SWIG_IsOK(ecode)) {
36981 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36982 }
36983 temp3 = static_cast< int >(val);
36984 arg3 = &temp3;
36985 res3 = SWIG_AddTmpMask(ecode);
36986 }
36987 {
36988 PyThreadState* __tstate = wxPyBeginAllowThreads();
36989 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36990 wxPyEndAllowThreads(__tstate);
36991 if (PyErr_Occurred()) SWIG_fail;
36992 }
36993 resultobj = SWIG_Py_Void();
36994 if (SWIG_IsTmpObj(res2)) {
36995 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36996 } else {
36997 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36998 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36999 }
37000 if (SWIG_IsTmpObj(res3)) {
37001 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
37002 } else {
37003 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
37004 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
37005 }
37006 return resultobj;
37007 fail:
37008 return NULL;
37009 }
37010
37011
37012 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37013 PyObject *resultobj = 0;
37014 wxWindow *arg1 = (wxWindow *) 0 ;
37015 wxPoint *arg2 = 0 ;
37016 wxPoint result;
37017 void *argp1 = 0 ;
37018 int res1 = 0 ;
37019 wxPoint temp2 ;
37020 PyObject * obj0 = 0 ;
37021 PyObject * obj1 = 0 ;
37022 char * kwnames[] = {
37023 (char *) "self",(char *) "pt", NULL
37024 };
37025
37026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
37027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37028 if (!SWIG_IsOK(res1)) {
37029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37030 }
37031 arg1 = reinterpret_cast< wxWindow * >(argp1);
37032 {
37033 arg2 = &temp2;
37034 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37035 }
37036 {
37037 PyThreadState* __tstate = wxPyBeginAllowThreads();
37038 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
37039 wxPyEndAllowThreads(__tstate);
37040 if (PyErr_Occurred()) SWIG_fail;
37041 }
37042 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37043 return resultobj;
37044 fail:
37045 return NULL;
37046 }
37047
37048
37049 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37050 PyObject *resultobj = 0;
37051 wxWindow *arg1 = (wxWindow *) 0 ;
37052 wxPoint *arg2 = 0 ;
37053 wxPoint result;
37054 void *argp1 = 0 ;
37055 int res1 = 0 ;
37056 wxPoint temp2 ;
37057 PyObject * obj0 = 0 ;
37058 PyObject * obj1 = 0 ;
37059 char * kwnames[] = {
37060 (char *) "self",(char *) "pt", NULL
37061 };
37062
37063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
37064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37065 if (!SWIG_IsOK(res1)) {
37066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
37067 }
37068 arg1 = reinterpret_cast< wxWindow * >(argp1);
37069 {
37070 arg2 = &temp2;
37071 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37072 }
37073 {
37074 PyThreadState* __tstate = wxPyBeginAllowThreads();
37075 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
37076 wxPyEndAllowThreads(__tstate);
37077 if (PyErr_Occurred()) SWIG_fail;
37078 }
37079 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37080 return resultobj;
37081 fail:
37082 return NULL;
37083 }
37084
37085
37086 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37087 PyObject *resultobj = 0;
37088 wxWindow *arg1 = (wxWindow *) 0 ;
37089 int arg2 ;
37090 int arg3 ;
37091 wxHitTest result;
37092 void *argp1 = 0 ;
37093 int res1 = 0 ;
37094 int val2 ;
37095 int ecode2 = 0 ;
37096 int val3 ;
37097 int ecode3 = 0 ;
37098 PyObject * obj0 = 0 ;
37099 PyObject * obj1 = 0 ;
37100 PyObject * obj2 = 0 ;
37101 char * kwnames[] = {
37102 (char *) "self",(char *) "x",(char *) "y", NULL
37103 };
37104
37105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37107 if (!SWIG_IsOK(res1)) {
37108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
37109 }
37110 arg1 = reinterpret_cast< wxWindow * >(argp1);
37111 ecode2 = SWIG_AsVal_int(obj1, &val2);
37112 if (!SWIG_IsOK(ecode2)) {
37113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
37114 }
37115 arg2 = static_cast< int >(val2);
37116 ecode3 = SWIG_AsVal_int(obj2, &val3);
37117 if (!SWIG_IsOK(ecode3)) {
37118 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
37119 }
37120 arg3 = static_cast< int >(val3);
37121 {
37122 PyThreadState* __tstate = wxPyBeginAllowThreads();
37123 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
37124 wxPyEndAllowThreads(__tstate);
37125 if (PyErr_Occurred()) SWIG_fail;
37126 }
37127 resultobj = SWIG_From_int(static_cast< int >(result));
37128 return resultobj;
37129 fail:
37130 return NULL;
37131 }
37132
37133
37134 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37135 PyObject *resultobj = 0;
37136 wxWindow *arg1 = (wxWindow *) 0 ;
37137 wxPoint *arg2 = 0 ;
37138 wxHitTest result;
37139 void *argp1 = 0 ;
37140 int res1 = 0 ;
37141 wxPoint temp2 ;
37142 PyObject * obj0 = 0 ;
37143 PyObject * obj1 = 0 ;
37144 char * kwnames[] = {
37145 (char *) "self",(char *) "pt", NULL
37146 };
37147
37148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
37149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37150 if (!SWIG_IsOK(res1)) {
37151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
37152 }
37153 arg1 = reinterpret_cast< wxWindow * >(argp1);
37154 {
37155 arg2 = &temp2;
37156 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37157 }
37158 {
37159 PyThreadState* __tstate = wxPyBeginAllowThreads();
37160 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
37161 wxPyEndAllowThreads(__tstate);
37162 if (PyErr_Occurred()) SWIG_fail;
37163 }
37164 resultobj = SWIG_From_int(static_cast< int >(result));
37165 return resultobj;
37166 fail:
37167 return NULL;
37168 }
37169
37170
37171 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
37172 PyObject *resultobj = 0;
37173 wxWindow *arg1 = (wxWindow *) 0 ;
37174 long arg2 ;
37175 wxBorder result;
37176 void *argp1 = 0 ;
37177 int res1 = 0 ;
37178 long val2 ;
37179 int ecode2 = 0 ;
37180
37181 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
37182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37183 if (!SWIG_IsOK(res1)) {
37184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
37185 }
37186 arg1 = reinterpret_cast< wxWindow * >(argp1);
37187 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
37188 if (!SWIG_IsOK(ecode2)) {
37189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
37190 }
37191 arg2 = static_cast< long >(val2);
37192 {
37193 PyThreadState* __tstate = wxPyBeginAllowThreads();
37194 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
37195 wxPyEndAllowThreads(__tstate);
37196 if (PyErr_Occurred()) SWIG_fail;
37197 }
37198 resultobj = SWIG_From_int(static_cast< int >(result));
37199 return resultobj;
37200 fail:
37201 return NULL;
37202 }
37203
37204
37205 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
37206 PyObject *resultobj = 0;
37207 wxWindow *arg1 = (wxWindow *) 0 ;
37208 wxBorder result;
37209 void *argp1 = 0 ;
37210 int res1 = 0 ;
37211
37212 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
37213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37214 if (!SWIG_IsOK(res1)) {
37215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
37216 }
37217 arg1 = reinterpret_cast< wxWindow * >(argp1);
37218 {
37219 PyThreadState* __tstate = wxPyBeginAllowThreads();
37220 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
37221 wxPyEndAllowThreads(__tstate);
37222 if (PyErr_Occurred()) SWIG_fail;
37223 }
37224 resultobj = SWIG_From_int(static_cast< int >(result));
37225 return resultobj;
37226 fail:
37227 return NULL;
37228 }
37229
37230
37231 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
37232 int argc;
37233 PyObject *argv[3];
37234
37235 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
37236 --argc;
37237 if (argc == 1) {
37238 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
37239 }
37240 if (argc == 2) {
37241 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
37242 }
37243
37244 fail:
37245 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
37246 return NULL;
37247 }
37248
37249
37250 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37251 PyObject *resultobj = 0;
37252 wxWindow *arg1 = (wxWindow *) 0 ;
37253 long arg2 = (long) wxUPDATE_UI_NONE ;
37254 void *argp1 = 0 ;
37255 int res1 = 0 ;
37256 long val2 ;
37257 int ecode2 = 0 ;
37258 PyObject * obj0 = 0 ;
37259 PyObject * obj1 = 0 ;
37260 char * kwnames[] = {
37261 (char *) "self",(char *) "flags", NULL
37262 };
37263
37264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
37265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37266 if (!SWIG_IsOK(res1)) {
37267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
37268 }
37269 arg1 = reinterpret_cast< wxWindow * >(argp1);
37270 if (obj1) {
37271 ecode2 = SWIG_AsVal_long(obj1, &val2);
37272 if (!SWIG_IsOK(ecode2)) {
37273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
37274 }
37275 arg2 = static_cast< long >(val2);
37276 }
37277 {
37278 PyThreadState* __tstate = wxPyBeginAllowThreads();
37279 (arg1)->UpdateWindowUI(arg2);
37280 wxPyEndAllowThreads(__tstate);
37281 if (PyErr_Occurred()) SWIG_fail;
37282 }
37283 resultobj = SWIG_Py_Void();
37284 return resultobj;
37285 fail:
37286 return NULL;
37287 }
37288
37289
37290 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37291 PyObject *resultobj = 0;
37292 wxWindow *arg1 = (wxWindow *) 0 ;
37293 wxMenu *arg2 = (wxMenu *) 0 ;
37294 int arg3 = (int) -1 ;
37295 int arg4 = (int) -1 ;
37296 bool result;
37297 void *argp1 = 0 ;
37298 int res1 = 0 ;
37299 void *argp2 = 0 ;
37300 int res2 = 0 ;
37301 int val3 ;
37302 int ecode3 = 0 ;
37303 int val4 ;
37304 int ecode4 = 0 ;
37305 PyObject * obj0 = 0 ;
37306 PyObject * obj1 = 0 ;
37307 PyObject * obj2 = 0 ;
37308 PyObject * obj3 = 0 ;
37309 char * kwnames[] = {
37310 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
37311 };
37312
37313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37315 if (!SWIG_IsOK(res1)) {
37316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
37317 }
37318 arg1 = reinterpret_cast< wxWindow * >(argp1);
37319 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
37320 if (!SWIG_IsOK(res2)) {
37321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
37322 }
37323 arg2 = reinterpret_cast< wxMenu * >(argp2);
37324 if (obj2) {
37325 ecode3 = SWIG_AsVal_int(obj2, &val3);
37326 if (!SWIG_IsOK(ecode3)) {
37327 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
37328 }
37329 arg3 = static_cast< int >(val3);
37330 }
37331 if (obj3) {
37332 ecode4 = SWIG_AsVal_int(obj3, &val4);
37333 if (!SWIG_IsOK(ecode4)) {
37334 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
37335 }
37336 arg4 = static_cast< int >(val4);
37337 }
37338 {
37339 PyThreadState* __tstate = wxPyBeginAllowThreads();
37340 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
37341 wxPyEndAllowThreads(__tstate);
37342 if (PyErr_Occurred()) SWIG_fail;
37343 }
37344 {
37345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37346 }
37347 return resultobj;
37348 fail:
37349 return NULL;
37350 }
37351
37352
37353 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37354 PyObject *resultobj = 0;
37355 wxWindow *arg1 = (wxWindow *) 0 ;
37356 wxMenu *arg2 = (wxMenu *) 0 ;
37357 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37358 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37359 bool result;
37360 void *argp1 = 0 ;
37361 int res1 = 0 ;
37362 void *argp2 = 0 ;
37363 int res2 = 0 ;
37364 wxPoint temp3 ;
37365 PyObject * obj0 = 0 ;
37366 PyObject * obj1 = 0 ;
37367 PyObject * obj2 = 0 ;
37368 char * kwnames[] = {
37369 (char *) "self",(char *) "menu",(char *) "pos", NULL
37370 };
37371
37372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37374 if (!SWIG_IsOK(res1)) {
37375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
37376 }
37377 arg1 = reinterpret_cast< wxWindow * >(argp1);
37378 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
37379 if (!SWIG_IsOK(res2)) {
37380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
37381 }
37382 arg2 = reinterpret_cast< wxMenu * >(argp2);
37383 if (obj2) {
37384 {
37385 arg3 = &temp3;
37386 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37387 }
37388 }
37389 {
37390 PyThreadState* __tstate = wxPyBeginAllowThreads();
37391 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
37392 wxPyEndAllowThreads(__tstate);
37393 if (PyErr_Occurred()) SWIG_fail;
37394 }
37395 {
37396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37397 }
37398 return resultobj;
37399 fail:
37400 return NULL;
37401 }
37402
37403
37404 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37405 PyObject *resultobj = 0;
37406 wxWindow *arg1 = (wxWindow *) 0 ;
37407 bool result;
37408 void *argp1 = 0 ;
37409 int res1 = 0 ;
37410 PyObject *swig_obj[1] ;
37411
37412 if (!args) SWIG_fail;
37413 swig_obj[0] = args;
37414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37415 if (!SWIG_IsOK(res1)) {
37416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
37417 }
37418 arg1 = reinterpret_cast< wxWindow * >(argp1);
37419 {
37420 PyThreadState* __tstate = wxPyBeginAllowThreads();
37421 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
37422 wxPyEndAllowThreads(__tstate);
37423 if (PyErr_Occurred()) SWIG_fail;
37424 }
37425 {
37426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37427 }
37428 return resultobj;
37429 fail:
37430 return NULL;
37431 }
37432
37433
37434 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37435 PyObject *resultobj = 0;
37436 wxWindow *arg1 = (wxWindow *) 0 ;
37437 long result;
37438 void *argp1 = 0 ;
37439 int res1 = 0 ;
37440 PyObject *swig_obj[1] ;
37441
37442 if (!args) SWIG_fail;
37443 swig_obj[0] = args;
37444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37445 if (!SWIG_IsOK(res1)) {
37446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37447 }
37448 arg1 = reinterpret_cast< wxWindow * >(argp1);
37449 {
37450 PyThreadState* __tstate = wxPyBeginAllowThreads();
37451 result = (long)wxWindow_GetHandle(arg1);
37452 wxPyEndAllowThreads(__tstate);
37453 if (PyErr_Occurred()) SWIG_fail;
37454 }
37455 resultobj = SWIG_From_long(static_cast< long >(result));
37456 return resultobj;
37457 fail:
37458 return NULL;
37459 }
37460
37461
37462 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37463 PyObject *resultobj = 0;
37464 wxWindow *arg1 = (wxWindow *) 0 ;
37465 long arg2 ;
37466 void *argp1 = 0 ;
37467 int res1 = 0 ;
37468 long val2 ;
37469 int ecode2 = 0 ;
37470 PyObject * obj0 = 0 ;
37471 PyObject * obj1 = 0 ;
37472 char * kwnames[] = {
37473 (char *) "self",(char *) "handle", NULL
37474 };
37475
37476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
37477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37478 if (!SWIG_IsOK(res1)) {
37479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37480 }
37481 arg1 = reinterpret_cast< wxWindow * >(argp1);
37482 ecode2 = SWIG_AsVal_long(obj1, &val2);
37483 if (!SWIG_IsOK(ecode2)) {
37484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
37485 }
37486 arg2 = static_cast< long >(val2);
37487 {
37488 PyThreadState* __tstate = wxPyBeginAllowThreads();
37489 wxWindow_AssociateHandle(arg1,arg2);
37490 wxPyEndAllowThreads(__tstate);
37491 if (PyErr_Occurred()) SWIG_fail;
37492 }
37493 resultobj = SWIG_Py_Void();
37494 return resultobj;
37495 fail:
37496 return NULL;
37497 }
37498
37499
37500 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37501 PyObject *resultobj = 0;
37502 wxWindow *arg1 = (wxWindow *) 0 ;
37503 void *argp1 = 0 ;
37504 int res1 = 0 ;
37505 PyObject *swig_obj[1] ;
37506
37507 if (!args) SWIG_fail;
37508 swig_obj[0] = args;
37509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37510 if (!SWIG_IsOK(res1)) {
37511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37512 }
37513 arg1 = reinterpret_cast< wxWindow * >(argp1);
37514 {
37515 PyThreadState* __tstate = wxPyBeginAllowThreads();
37516 (arg1)->DissociateHandle();
37517 wxPyEndAllowThreads(__tstate);
37518 if (PyErr_Occurred()) SWIG_fail;
37519 }
37520 resultobj = SWIG_Py_Void();
37521 return resultobj;
37522 fail:
37523 return NULL;
37524 }
37525
37526
37527 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37528 PyObject *resultobj = 0;
37529 wxWindow *arg1 = (wxWindow *) 0 ;
37530 int arg2 ;
37531 bool result;
37532 void *argp1 = 0 ;
37533 int res1 = 0 ;
37534 int val2 ;
37535 int ecode2 = 0 ;
37536 PyObject * obj0 = 0 ;
37537 PyObject * obj1 = 0 ;
37538 char * kwnames[] = {
37539 (char *) "self",(char *) "orient", NULL
37540 };
37541
37542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
37543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37544 if (!SWIG_IsOK(res1)) {
37545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
37546 }
37547 arg1 = reinterpret_cast< wxWindow * >(argp1);
37548 ecode2 = SWIG_AsVal_int(obj1, &val2);
37549 if (!SWIG_IsOK(ecode2)) {
37550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
37551 }
37552 arg2 = static_cast< int >(val2);
37553 {
37554 PyThreadState* __tstate = wxPyBeginAllowThreads();
37555 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
37556 wxPyEndAllowThreads(__tstate);
37557 if (PyErr_Occurred()) SWIG_fail;
37558 }
37559 {
37560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37561 }
37562 return resultobj;
37563 fail:
37564 return NULL;
37565 }
37566
37567
37568 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37569 PyObject *resultobj = 0;
37570 wxWindow *arg1 = (wxWindow *) 0 ;
37571 int arg2 ;
37572 int arg3 ;
37573 int arg4 ;
37574 int arg5 ;
37575 bool arg6 = (bool) true ;
37576 void *argp1 = 0 ;
37577 int res1 = 0 ;
37578 int val2 ;
37579 int ecode2 = 0 ;
37580 int val3 ;
37581 int ecode3 = 0 ;
37582 int val4 ;
37583 int ecode4 = 0 ;
37584 int val5 ;
37585 int ecode5 = 0 ;
37586 bool val6 ;
37587 int ecode6 = 0 ;
37588 PyObject * obj0 = 0 ;
37589 PyObject * obj1 = 0 ;
37590 PyObject * obj2 = 0 ;
37591 PyObject * obj3 = 0 ;
37592 PyObject * obj4 = 0 ;
37593 PyObject * obj5 = 0 ;
37594 char * kwnames[] = {
37595 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
37596 };
37597
37598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
37599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37600 if (!SWIG_IsOK(res1)) {
37601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
37602 }
37603 arg1 = reinterpret_cast< wxWindow * >(argp1);
37604 ecode2 = SWIG_AsVal_int(obj1, &val2);
37605 if (!SWIG_IsOK(ecode2)) {
37606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
37607 }
37608 arg2 = static_cast< int >(val2);
37609 ecode3 = SWIG_AsVal_int(obj2, &val3);
37610 if (!SWIG_IsOK(ecode3)) {
37611 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
37612 }
37613 arg3 = static_cast< int >(val3);
37614 ecode4 = SWIG_AsVal_int(obj3, &val4);
37615 if (!SWIG_IsOK(ecode4)) {
37616 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
37617 }
37618 arg4 = static_cast< int >(val4);
37619 ecode5 = SWIG_AsVal_int(obj4, &val5);
37620 if (!SWIG_IsOK(ecode5)) {
37621 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
37622 }
37623 arg5 = static_cast< int >(val5);
37624 if (obj5) {
37625 ecode6 = SWIG_AsVal_bool(obj5, &val6);
37626 if (!SWIG_IsOK(ecode6)) {
37627 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
37628 }
37629 arg6 = static_cast< bool >(val6);
37630 }
37631 {
37632 PyThreadState* __tstate = wxPyBeginAllowThreads();
37633 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
37634 wxPyEndAllowThreads(__tstate);
37635 if (PyErr_Occurred()) SWIG_fail;
37636 }
37637 resultobj = SWIG_Py_Void();
37638 return resultobj;
37639 fail:
37640 return NULL;
37641 }
37642
37643
37644 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37645 PyObject *resultobj = 0;
37646 wxWindow *arg1 = (wxWindow *) 0 ;
37647 int arg2 ;
37648 int arg3 ;
37649 bool arg4 = (bool) true ;
37650 void *argp1 = 0 ;
37651 int res1 = 0 ;
37652 int val2 ;
37653 int ecode2 = 0 ;
37654 int val3 ;
37655 int ecode3 = 0 ;
37656 bool val4 ;
37657 int ecode4 = 0 ;
37658 PyObject * obj0 = 0 ;
37659 PyObject * obj1 = 0 ;
37660 PyObject * obj2 = 0 ;
37661 PyObject * obj3 = 0 ;
37662 char * kwnames[] = {
37663 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
37664 };
37665
37666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37668 if (!SWIG_IsOK(res1)) {
37669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37670 }
37671 arg1 = reinterpret_cast< wxWindow * >(argp1);
37672 ecode2 = SWIG_AsVal_int(obj1, &val2);
37673 if (!SWIG_IsOK(ecode2)) {
37674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37675 }
37676 arg2 = static_cast< int >(val2);
37677 ecode3 = SWIG_AsVal_int(obj2, &val3);
37678 if (!SWIG_IsOK(ecode3)) {
37679 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37680 }
37681 arg3 = static_cast< int >(val3);
37682 if (obj3) {
37683 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37684 if (!SWIG_IsOK(ecode4)) {
37685 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37686 }
37687 arg4 = static_cast< bool >(val4);
37688 }
37689 {
37690 PyThreadState* __tstate = wxPyBeginAllowThreads();
37691 (arg1)->SetScrollPos(arg2,arg3,arg4);
37692 wxPyEndAllowThreads(__tstate);
37693 if (PyErr_Occurred()) SWIG_fail;
37694 }
37695 resultobj = SWIG_Py_Void();
37696 return resultobj;
37697 fail:
37698 return NULL;
37699 }
37700
37701
37702 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37703 PyObject *resultobj = 0;
37704 wxWindow *arg1 = (wxWindow *) 0 ;
37705 int arg2 ;
37706 int result;
37707 void *argp1 = 0 ;
37708 int res1 = 0 ;
37709 int val2 ;
37710 int ecode2 = 0 ;
37711 PyObject * obj0 = 0 ;
37712 PyObject * obj1 = 0 ;
37713 char * kwnames[] = {
37714 (char *) "self",(char *) "orientation", NULL
37715 };
37716
37717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37719 if (!SWIG_IsOK(res1)) {
37720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37721 }
37722 arg1 = reinterpret_cast< wxWindow * >(argp1);
37723 ecode2 = SWIG_AsVal_int(obj1, &val2);
37724 if (!SWIG_IsOK(ecode2)) {
37725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37726 }
37727 arg2 = static_cast< int >(val2);
37728 {
37729 PyThreadState* __tstate = wxPyBeginAllowThreads();
37730 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37731 wxPyEndAllowThreads(__tstate);
37732 if (PyErr_Occurred()) SWIG_fail;
37733 }
37734 resultobj = SWIG_From_int(static_cast< int >(result));
37735 return resultobj;
37736 fail:
37737 return NULL;
37738 }
37739
37740
37741 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37742 PyObject *resultobj = 0;
37743 wxWindow *arg1 = (wxWindow *) 0 ;
37744 int arg2 ;
37745 int result;
37746 void *argp1 = 0 ;
37747 int res1 = 0 ;
37748 int val2 ;
37749 int ecode2 = 0 ;
37750 PyObject * obj0 = 0 ;
37751 PyObject * obj1 = 0 ;
37752 char * kwnames[] = {
37753 (char *) "self",(char *) "orientation", NULL
37754 };
37755
37756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37758 if (!SWIG_IsOK(res1)) {
37759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37760 }
37761 arg1 = reinterpret_cast< wxWindow * >(argp1);
37762 ecode2 = SWIG_AsVal_int(obj1, &val2);
37763 if (!SWIG_IsOK(ecode2)) {
37764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37765 }
37766 arg2 = static_cast< int >(val2);
37767 {
37768 PyThreadState* __tstate = wxPyBeginAllowThreads();
37769 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37770 wxPyEndAllowThreads(__tstate);
37771 if (PyErr_Occurred()) SWIG_fail;
37772 }
37773 resultobj = SWIG_From_int(static_cast< int >(result));
37774 return resultobj;
37775 fail:
37776 return NULL;
37777 }
37778
37779
37780 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37781 PyObject *resultobj = 0;
37782 wxWindow *arg1 = (wxWindow *) 0 ;
37783 int arg2 ;
37784 int result;
37785 void *argp1 = 0 ;
37786 int res1 = 0 ;
37787 int val2 ;
37788 int ecode2 = 0 ;
37789 PyObject * obj0 = 0 ;
37790 PyObject * obj1 = 0 ;
37791 char * kwnames[] = {
37792 (char *) "self",(char *) "orientation", NULL
37793 };
37794
37795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37797 if (!SWIG_IsOK(res1)) {
37798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37799 }
37800 arg1 = reinterpret_cast< wxWindow * >(argp1);
37801 ecode2 = SWIG_AsVal_int(obj1, &val2);
37802 if (!SWIG_IsOK(ecode2)) {
37803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37804 }
37805 arg2 = static_cast< int >(val2);
37806 {
37807 PyThreadState* __tstate = wxPyBeginAllowThreads();
37808 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37809 wxPyEndAllowThreads(__tstate);
37810 if (PyErr_Occurred()) SWIG_fail;
37811 }
37812 resultobj = SWIG_From_int(static_cast< int >(result));
37813 return resultobj;
37814 fail:
37815 return NULL;
37816 }
37817
37818
37819 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37820 PyObject *resultobj = 0;
37821 wxWindow *arg1 = (wxWindow *) 0 ;
37822 int arg2 ;
37823 int arg3 ;
37824 wxRect *arg4 = (wxRect *) NULL ;
37825 void *argp1 = 0 ;
37826 int res1 = 0 ;
37827 int val2 ;
37828 int ecode2 = 0 ;
37829 int val3 ;
37830 int ecode3 = 0 ;
37831 void *argp4 = 0 ;
37832 int res4 = 0 ;
37833 PyObject * obj0 = 0 ;
37834 PyObject * obj1 = 0 ;
37835 PyObject * obj2 = 0 ;
37836 PyObject * obj3 = 0 ;
37837 char * kwnames[] = {
37838 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37839 };
37840
37841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37843 if (!SWIG_IsOK(res1)) {
37844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37845 }
37846 arg1 = reinterpret_cast< wxWindow * >(argp1);
37847 ecode2 = SWIG_AsVal_int(obj1, &val2);
37848 if (!SWIG_IsOK(ecode2)) {
37849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37850 }
37851 arg2 = static_cast< int >(val2);
37852 ecode3 = SWIG_AsVal_int(obj2, &val3);
37853 if (!SWIG_IsOK(ecode3)) {
37854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37855 }
37856 arg3 = static_cast< int >(val3);
37857 if (obj3) {
37858 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37859 if (!SWIG_IsOK(res4)) {
37860 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37861 }
37862 arg4 = reinterpret_cast< wxRect * >(argp4);
37863 }
37864 {
37865 PyThreadState* __tstate = wxPyBeginAllowThreads();
37866 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37867 wxPyEndAllowThreads(__tstate);
37868 if (PyErr_Occurred()) SWIG_fail;
37869 }
37870 resultobj = SWIG_Py_Void();
37871 return resultobj;
37872 fail:
37873 return NULL;
37874 }
37875
37876
37877 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37878 PyObject *resultobj = 0;
37879 wxWindow *arg1 = (wxWindow *) 0 ;
37880 int arg2 ;
37881 bool result;
37882 void *argp1 = 0 ;
37883 int res1 = 0 ;
37884 int val2 ;
37885 int ecode2 = 0 ;
37886 PyObject * obj0 = 0 ;
37887 PyObject * obj1 = 0 ;
37888 char * kwnames[] = {
37889 (char *) "self",(char *) "lines", NULL
37890 };
37891
37892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37894 if (!SWIG_IsOK(res1)) {
37895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37896 }
37897 arg1 = reinterpret_cast< wxWindow * >(argp1);
37898 ecode2 = SWIG_AsVal_int(obj1, &val2);
37899 if (!SWIG_IsOK(ecode2)) {
37900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37901 }
37902 arg2 = static_cast< int >(val2);
37903 {
37904 PyThreadState* __tstate = wxPyBeginAllowThreads();
37905 result = (bool)(arg1)->ScrollLines(arg2);
37906 wxPyEndAllowThreads(__tstate);
37907 if (PyErr_Occurred()) SWIG_fail;
37908 }
37909 {
37910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37911 }
37912 return resultobj;
37913 fail:
37914 return NULL;
37915 }
37916
37917
37918 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37919 PyObject *resultobj = 0;
37920 wxWindow *arg1 = (wxWindow *) 0 ;
37921 int arg2 ;
37922 bool result;
37923 void *argp1 = 0 ;
37924 int res1 = 0 ;
37925 int val2 ;
37926 int ecode2 = 0 ;
37927 PyObject * obj0 = 0 ;
37928 PyObject * obj1 = 0 ;
37929 char * kwnames[] = {
37930 (char *) "self",(char *) "pages", NULL
37931 };
37932
37933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37935 if (!SWIG_IsOK(res1)) {
37936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37937 }
37938 arg1 = reinterpret_cast< wxWindow * >(argp1);
37939 ecode2 = SWIG_AsVal_int(obj1, &val2);
37940 if (!SWIG_IsOK(ecode2)) {
37941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37942 }
37943 arg2 = static_cast< int >(val2);
37944 {
37945 PyThreadState* __tstate = wxPyBeginAllowThreads();
37946 result = (bool)(arg1)->ScrollPages(arg2);
37947 wxPyEndAllowThreads(__tstate);
37948 if (PyErr_Occurred()) SWIG_fail;
37949 }
37950 {
37951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37952 }
37953 return resultobj;
37954 fail:
37955 return NULL;
37956 }
37957
37958
37959 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37960 PyObject *resultobj = 0;
37961 wxWindow *arg1 = (wxWindow *) 0 ;
37962 bool result;
37963 void *argp1 = 0 ;
37964 int res1 = 0 ;
37965 PyObject *swig_obj[1] ;
37966
37967 if (!args) SWIG_fail;
37968 swig_obj[0] = args;
37969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37970 if (!SWIG_IsOK(res1)) {
37971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37972 }
37973 arg1 = reinterpret_cast< wxWindow * >(argp1);
37974 {
37975 PyThreadState* __tstate = wxPyBeginAllowThreads();
37976 result = (bool)(arg1)->LineUp();
37977 wxPyEndAllowThreads(__tstate);
37978 if (PyErr_Occurred()) SWIG_fail;
37979 }
37980 {
37981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37982 }
37983 return resultobj;
37984 fail:
37985 return NULL;
37986 }
37987
37988
37989 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37990 PyObject *resultobj = 0;
37991 wxWindow *arg1 = (wxWindow *) 0 ;
37992 bool result;
37993 void *argp1 = 0 ;
37994 int res1 = 0 ;
37995 PyObject *swig_obj[1] ;
37996
37997 if (!args) SWIG_fail;
37998 swig_obj[0] = args;
37999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38000 if (!SWIG_IsOK(res1)) {
38001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
38002 }
38003 arg1 = reinterpret_cast< wxWindow * >(argp1);
38004 {
38005 PyThreadState* __tstate = wxPyBeginAllowThreads();
38006 result = (bool)(arg1)->LineDown();
38007 wxPyEndAllowThreads(__tstate);
38008 if (PyErr_Occurred()) SWIG_fail;
38009 }
38010 {
38011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38012 }
38013 return resultobj;
38014 fail:
38015 return NULL;
38016 }
38017
38018
38019 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38020 PyObject *resultobj = 0;
38021 wxWindow *arg1 = (wxWindow *) 0 ;
38022 bool result;
38023 void *argp1 = 0 ;
38024 int res1 = 0 ;
38025 PyObject *swig_obj[1] ;
38026
38027 if (!args) SWIG_fail;
38028 swig_obj[0] = args;
38029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38030 if (!SWIG_IsOK(res1)) {
38031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
38032 }
38033 arg1 = reinterpret_cast< wxWindow * >(argp1);
38034 {
38035 PyThreadState* __tstate = wxPyBeginAllowThreads();
38036 result = (bool)(arg1)->PageUp();
38037 wxPyEndAllowThreads(__tstate);
38038 if (PyErr_Occurred()) SWIG_fail;
38039 }
38040 {
38041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38042 }
38043 return resultobj;
38044 fail:
38045 return NULL;
38046 }
38047
38048
38049 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38050 PyObject *resultobj = 0;
38051 wxWindow *arg1 = (wxWindow *) 0 ;
38052 bool result;
38053 void *argp1 = 0 ;
38054 int res1 = 0 ;
38055 PyObject *swig_obj[1] ;
38056
38057 if (!args) SWIG_fail;
38058 swig_obj[0] = args;
38059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38060 if (!SWIG_IsOK(res1)) {
38061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
38062 }
38063 arg1 = reinterpret_cast< wxWindow * >(argp1);
38064 {
38065 PyThreadState* __tstate = wxPyBeginAllowThreads();
38066 result = (bool)(arg1)->PageDown();
38067 wxPyEndAllowThreads(__tstate);
38068 if (PyErr_Occurred()) SWIG_fail;
38069 }
38070 {
38071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38072 }
38073 return resultobj;
38074 fail:
38075 return NULL;
38076 }
38077
38078
38079 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38080 PyObject *resultobj = 0;
38081 wxWindow *arg1 = (wxWindow *) 0 ;
38082 wxString *arg2 = 0 ;
38083 void *argp1 = 0 ;
38084 int res1 = 0 ;
38085 bool temp2 = false ;
38086 PyObject * obj0 = 0 ;
38087 PyObject * obj1 = 0 ;
38088 char * kwnames[] = {
38089 (char *) "self",(char *) "text", NULL
38090 };
38091
38092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
38093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38094 if (!SWIG_IsOK(res1)) {
38095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
38096 }
38097 arg1 = reinterpret_cast< wxWindow * >(argp1);
38098 {
38099 arg2 = wxString_in_helper(obj1);
38100 if (arg2 == NULL) SWIG_fail;
38101 temp2 = true;
38102 }
38103 {
38104 PyThreadState* __tstate = wxPyBeginAllowThreads();
38105 (arg1)->SetHelpText((wxString const &)*arg2);
38106 wxPyEndAllowThreads(__tstate);
38107 if (PyErr_Occurred()) SWIG_fail;
38108 }
38109 resultobj = SWIG_Py_Void();
38110 {
38111 if (temp2)
38112 delete arg2;
38113 }
38114 return resultobj;
38115 fail:
38116 {
38117 if (temp2)
38118 delete arg2;
38119 }
38120 return NULL;
38121 }
38122
38123
38124 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38125 PyObject *resultobj = 0;
38126 wxWindow *arg1 = (wxWindow *) 0 ;
38127 wxString *arg2 = 0 ;
38128 void *argp1 = 0 ;
38129 int res1 = 0 ;
38130 bool temp2 = false ;
38131 PyObject * obj0 = 0 ;
38132 PyObject * obj1 = 0 ;
38133 char * kwnames[] = {
38134 (char *) "self",(char *) "text", NULL
38135 };
38136
38137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
38138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38139 if (!SWIG_IsOK(res1)) {
38140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
38141 }
38142 arg1 = reinterpret_cast< wxWindow * >(argp1);
38143 {
38144 arg2 = wxString_in_helper(obj1);
38145 if (arg2 == NULL) SWIG_fail;
38146 temp2 = true;
38147 }
38148 {
38149 PyThreadState* __tstate = wxPyBeginAllowThreads();
38150 (arg1)->SetHelpTextForId((wxString const &)*arg2);
38151 wxPyEndAllowThreads(__tstate);
38152 if (PyErr_Occurred()) SWIG_fail;
38153 }
38154 resultobj = SWIG_Py_Void();
38155 {
38156 if (temp2)
38157 delete arg2;
38158 }
38159 return resultobj;
38160 fail:
38161 {
38162 if (temp2)
38163 delete arg2;
38164 }
38165 return NULL;
38166 }
38167
38168
38169 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38170 PyObject *resultobj = 0;
38171 wxWindow *arg1 = (wxWindow *) 0 ;
38172 wxPoint *arg2 = 0 ;
38173 wxHelpEvent::Origin arg3 ;
38174 wxString result;
38175 void *argp1 = 0 ;
38176 int res1 = 0 ;
38177 wxPoint temp2 ;
38178 void *argp3 ;
38179 int res3 = 0 ;
38180 PyObject * obj0 = 0 ;
38181 PyObject * obj1 = 0 ;
38182 PyObject * obj2 = 0 ;
38183 char * kwnames[] = {
38184 (char *) "self",(char *) "pt",(char *) "origin", NULL
38185 };
38186
38187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38189 if (!SWIG_IsOK(res1)) {
38190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38191 }
38192 arg1 = reinterpret_cast< wxWindow * >(argp1);
38193 {
38194 arg2 = &temp2;
38195 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38196 }
38197 {
38198 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
38199 if (!SWIG_IsOK(res3)) {
38200 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
38201 }
38202 if (!argp3) {
38203 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
38204 } else {
38205 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
38206 arg3 = *temp;
38207 if (SWIG_IsNewObj(res3)) delete temp;
38208 }
38209 }
38210 {
38211 PyThreadState* __tstate = wxPyBeginAllowThreads();
38212 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
38213 wxPyEndAllowThreads(__tstate);
38214 if (PyErr_Occurred()) SWIG_fail;
38215 }
38216 {
38217 #if wxUSE_UNICODE
38218 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38219 #else
38220 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38221 #endif
38222 }
38223 return resultobj;
38224 fail:
38225 return NULL;
38226 }
38227
38228
38229 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38230 PyObject *resultobj = 0;
38231 wxWindow *arg1 = (wxWindow *) 0 ;
38232 wxString result;
38233 void *argp1 = 0 ;
38234 int res1 = 0 ;
38235 PyObject *swig_obj[1] ;
38236
38237 if (!args) SWIG_fail;
38238 swig_obj[0] = args;
38239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38240 if (!SWIG_IsOK(res1)) {
38241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
38242 }
38243 arg1 = reinterpret_cast< wxWindow * >(argp1);
38244 {
38245 PyThreadState* __tstate = wxPyBeginAllowThreads();
38246 result = ((wxWindow const *)arg1)->GetHelpText();
38247 wxPyEndAllowThreads(__tstate);
38248 if (PyErr_Occurred()) SWIG_fail;
38249 }
38250 {
38251 #if wxUSE_UNICODE
38252 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38253 #else
38254 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38255 #endif
38256 }
38257 return resultobj;
38258 fail:
38259 return NULL;
38260 }
38261
38262
38263 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38264 PyObject *resultobj = 0;
38265 wxWindow *arg1 = (wxWindow *) 0 ;
38266 wxString *arg2 = 0 ;
38267 void *argp1 = 0 ;
38268 int res1 = 0 ;
38269 bool temp2 = false ;
38270 PyObject * obj0 = 0 ;
38271 PyObject * obj1 = 0 ;
38272 char * kwnames[] = {
38273 (char *) "self",(char *) "tip", NULL
38274 };
38275
38276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
38277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38278 if (!SWIG_IsOK(res1)) {
38279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
38280 }
38281 arg1 = reinterpret_cast< wxWindow * >(argp1);
38282 {
38283 arg2 = wxString_in_helper(obj1);
38284 if (arg2 == NULL) SWIG_fail;
38285 temp2 = true;
38286 }
38287 {
38288 PyThreadState* __tstate = wxPyBeginAllowThreads();
38289 (arg1)->SetToolTip((wxString const &)*arg2);
38290 wxPyEndAllowThreads(__tstate);
38291 if (PyErr_Occurred()) SWIG_fail;
38292 }
38293 resultobj = SWIG_Py_Void();
38294 {
38295 if (temp2)
38296 delete arg2;
38297 }
38298 return resultobj;
38299 fail:
38300 {
38301 if (temp2)
38302 delete arg2;
38303 }
38304 return NULL;
38305 }
38306
38307
38308 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38309 PyObject *resultobj = 0;
38310 wxWindow *arg1 = (wxWindow *) 0 ;
38311 wxToolTip *arg2 = (wxToolTip *) 0 ;
38312 void *argp1 = 0 ;
38313 int res1 = 0 ;
38314 int res2 = 0 ;
38315 PyObject * obj0 = 0 ;
38316 PyObject * obj1 = 0 ;
38317 char * kwnames[] = {
38318 (char *) "self",(char *) "tip", NULL
38319 };
38320
38321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
38322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38323 if (!SWIG_IsOK(res1)) {
38324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
38325 }
38326 arg1 = reinterpret_cast< wxWindow * >(argp1);
38327 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
38328 if (!SWIG_IsOK(res2)) {
38329 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
38330 }
38331 {
38332 PyThreadState* __tstate = wxPyBeginAllowThreads();
38333 (arg1)->SetToolTip(arg2);
38334 wxPyEndAllowThreads(__tstate);
38335 if (PyErr_Occurred()) SWIG_fail;
38336 }
38337 resultobj = SWIG_Py_Void();
38338 return resultobj;
38339 fail:
38340 return NULL;
38341 }
38342
38343
38344 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38345 PyObject *resultobj = 0;
38346 wxWindow *arg1 = (wxWindow *) 0 ;
38347 wxToolTip *result = 0 ;
38348 void *argp1 = 0 ;
38349 int res1 = 0 ;
38350 PyObject *swig_obj[1] ;
38351
38352 if (!args) SWIG_fail;
38353 swig_obj[0] = args;
38354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38355 if (!SWIG_IsOK(res1)) {
38356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
38357 }
38358 arg1 = reinterpret_cast< wxWindow * >(argp1);
38359 {
38360 PyThreadState* __tstate = wxPyBeginAllowThreads();
38361 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
38362 wxPyEndAllowThreads(__tstate);
38363 if (PyErr_Occurred()) SWIG_fail;
38364 }
38365 {
38366 resultobj = wxPyMake_wxObject(result, (bool)0);
38367 }
38368 return resultobj;
38369 fail:
38370 return NULL;
38371 }
38372
38373
38374 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38375 PyObject *resultobj = 0;
38376 wxWindow *arg1 = (wxWindow *) 0 ;
38377 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
38378 void *argp1 = 0 ;
38379 int res1 = 0 ;
38380 int res2 = 0 ;
38381 PyObject * obj0 = 0 ;
38382 PyObject * obj1 = 0 ;
38383 char * kwnames[] = {
38384 (char *) "self",(char *) "dropTarget", NULL
38385 };
38386
38387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
38388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38389 if (!SWIG_IsOK(res1)) {
38390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
38391 }
38392 arg1 = reinterpret_cast< wxWindow * >(argp1);
38393 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
38394 if (!SWIG_IsOK(res2)) {
38395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
38396 }
38397 {
38398 PyThreadState* __tstate = wxPyBeginAllowThreads();
38399 (arg1)->SetDropTarget(arg2);
38400 wxPyEndAllowThreads(__tstate);
38401 if (PyErr_Occurred()) SWIG_fail;
38402 }
38403 resultobj = SWIG_Py_Void();
38404 return resultobj;
38405 fail:
38406 return NULL;
38407 }
38408
38409
38410 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38411 PyObject *resultobj = 0;
38412 wxWindow *arg1 = (wxWindow *) 0 ;
38413 wxPyDropTarget *result = 0 ;
38414 void *argp1 = 0 ;
38415 int res1 = 0 ;
38416 PyObject *swig_obj[1] ;
38417
38418 if (!args) SWIG_fail;
38419 swig_obj[0] = args;
38420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38421 if (!SWIG_IsOK(res1)) {
38422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
38423 }
38424 arg1 = reinterpret_cast< wxWindow * >(argp1);
38425 {
38426 PyThreadState* __tstate = wxPyBeginAllowThreads();
38427 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
38428 wxPyEndAllowThreads(__tstate);
38429 if (PyErr_Occurred()) SWIG_fail;
38430 }
38431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
38432 return resultobj;
38433 fail:
38434 return NULL;
38435 }
38436
38437
38438 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38439 PyObject *resultobj = 0;
38440 wxWindow *arg1 = (wxWindow *) 0 ;
38441 bool arg2 ;
38442 void *argp1 = 0 ;
38443 int res1 = 0 ;
38444 bool val2 ;
38445 int ecode2 = 0 ;
38446 PyObject * obj0 = 0 ;
38447 PyObject * obj1 = 0 ;
38448 char * kwnames[] = {
38449 (char *) "self",(char *) "accept", NULL
38450 };
38451
38452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
38453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38454 if (!SWIG_IsOK(res1)) {
38455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
38456 }
38457 arg1 = reinterpret_cast< wxWindow * >(argp1);
38458 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38459 if (!SWIG_IsOK(ecode2)) {
38460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
38461 }
38462 arg2 = static_cast< bool >(val2);
38463 {
38464 PyThreadState* __tstate = wxPyBeginAllowThreads();
38465 wxWindow_DragAcceptFiles(arg1,arg2);
38466 wxPyEndAllowThreads(__tstate);
38467 if (PyErr_Occurred()) SWIG_fail;
38468 }
38469 resultobj = SWIG_Py_Void();
38470 return resultobj;
38471 fail:
38472 return NULL;
38473 }
38474
38475
38476 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38477 PyObject *resultobj = 0;
38478 wxWindow *arg1 = (wxWindow *) 0 ;
38479 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
38480 void *argp1 = 0 ;
38481 int res1 = 0 ;
38482 int res2 = 0 ;
38483 PyObject * obj0 = 0 ;
38484 PyObject * obj1 = 0 ;
38485 char * kwnames[] = {
38486 (char *) "self",(char *) "constraints", NULL
38487 };
38488
38489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
38490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38491 if (!SWIG_IsOK(res1)) {
38492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
38493 }
38494 arg1 = reinterpret_cast< wxWindow * >(argp1);
38495 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
38496 if (!SWIG_IsOK(res2)) {
38497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
38498 }
38499 {
38500 PyThreadState* __tstate = wxPyBeginAllowThreads();
38501 (arg1)->SetConstraints(arg2);
38502 wxPyEndAllowThreads(__tstate);
38503 if (PyErr_Occurred()) SWIG_fail;
38504 }
38505 resultobj = SWIG_Py_Void();
38506 return resultobj;
38507 fail:
38508 return NULL;
38509 }
38510
38511
38512 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38513 PyObject *resultobj = 0;
38514 wxWindow *arg1 = (wxWindow *) 0 ;
38515 wxLayoutConstraints *result = 0 ;
38516 void *argp1 = 0 ;
38517 int res1 = 0 ;
38518 PyObject *swig_obj[1] ;
38519
38520 if (!args) SWIG_fail;
38521 swig_obj[0] = args;
38522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38523 if (!SWIG_IsOK(res1)) {
38524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
38525 }
38526 arg1 = reinterpret_cast< wxWindow * >(argp1);
38527 {
38528 PyThreadState* __tstate = wxPyBeginAllowThreads();
38529 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
38530 wxPyEndAllowThreads(__tstate);
38531 if (PyErr_Occurred()) SWIG_fail;
38532 }
38533 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
38534 return resultobj;
38535 fail:
38536 return NULL;
38537 }
38538
38539
38540 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38541 PyObject *resultobj = 0;
38542 wxWindow *arg1 = (wxWindow *) 0 ;
38543 bool arg2 ;
38544 void *argp1 = 0 ;
38545 int res1 = 0 ;
38546 bool val2 ;
38547 int ecode2 = 0 ;
38548 PyObject * obj0 = 0 ;
38549 PyObject * obj1 = 0 ;
38550 char * kwnames[] = {
38551 (char *) "self",(char *) "autoLayout", NULL
38552 };
38553
38554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
38555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38556 if (!SWIG_IsOK(res1)) {
38557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
38558 }
38559 arg1 = reinterpret_cast< wxWindow * >(argp1);
38560 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38561 if (!SWIG_IsOK(ecode2)) {
38562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
38563 }
38564 arg2 = static_cast< bool >(val2);
38565 {
38566 PyThreadState* __tstate = wxPyBeginAllowThreads();
38567 (arg1)->SetAutoLayout(arg2);
38568 wxPyEndAllowThreads(__tstate);
38569 if (PyErr_Occurred()) SWIG_fail;
38570 }
38571 resultobj = SWIG_Py_Void();
38572 return resultobj;
38573 fail:
38574 return NULL;
38575 }
38576
38577
38578 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38579 PyObject *resultobj = 0;
38580 wxWindow *arg1 = (wxWindow *) 0 ;
38581 bool result;
38582 void *argp1 = 0 ;
38583 int res1 = 0 ;
38584 PyObject *swig_obj[1] ;
38585
38586 if (!args) SWIG_fail;
38587 swig_obj[0] = args;
38588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38589 if (!SWIG_IsOK(res1)) {
38590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
38591 }
38592 arg1 = reinterpret_cast< wxWindow * >(argp1);
38593 {
38594 PyThreadState* __tstate = wxPyBeginAllowThreads();
38595 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
38596 wxPyEndAllowThreads(__tstate);
38597 if (PyErr_Occurred()) SWIG_fail;
38598 }
38599 {
38600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38601 }
38602 return resultobj;
38603 fail:
38604 return NULL;
38605 }
38606
38607
38608 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38609 PyObject *resultobj = 0;
38610 wxWindow *arg1 = (wxWindow *) 0 ;
38611 bool result;
38612 void *argp1 = 0 ;
38613 int res1 = 0 ;
38614 PyObject *swig_obj[1] ;
38615
38616 if (!args) SWIG_fail;
38617 swig_obj[0] = args;
38618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38619 if (!SWIG_IsOK(res1)) {
38620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
38621 }
38622 arg1 = reinterpret_cast< wxWindow * >(argp1);
38623 {
38624 PyThreadState* __tstate = wxPyBeginAllowThreads();
38625 result = (bool)(arg1)->Layout();
38626 wxPyEndAllowThreads(__tstate);
38627 if (PyErr_Occurred()) SWIG_fail;
38628 }
38629 {
38630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38631 }
38632 return resultobj;
38633 fail:
38634 return NULL;
38635 }
38636
38637
38638 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38639 PyObject *resultobj = 0;
38640 wxWindow *arg1 = (wxWindow *) 0 ;
38641 wxSizer *arg2 = (wxSizer *) 0 ;
38642 bool arg3 = (bool) true ;
38643 void *argp1 = 0 ;
38644 int res1 = 0 ;
38645 int res2 = 0 ;
38646 bool val3 ;
38647 int ecode3 = 0 ;
38648 PyObject * obj0 = 0 ;
38649 PyObject * obj1 = 0 ;
38650 PyObject * obj2 = 0 ;
38651 char * kwnames[] = {
38652 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38653 };
38654
38655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38657 if (!SWIG_IsOK(res1)) {
38658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38659 }
38660 arg1 = reinterpret_cast< wxWindow * >(argp1);
38661 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38662 if (!SWIG_IsOK(res2)) {
38663 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38664 }
38665 if (obj2) {
38666 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38667 if (!SWIG_IsOK(ecode3)) {
38668 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38669 }
38670 arg3 = static_cast< bool >(val3);
38671 }
38672 {
38673 PyThreadState* __tstate = wxPyBeginAllowThreads();
38674 (arg1)->SetSizer(arg2,arg3);
38675 wxPyEndAllowThreads(__tstate);
38676 if (PyErr_Occurred()) SWIG_fail;
38677 }
38678 resultobj = SWIG_Py_Void();
38679 return resultobj;
38680 fail:
38681 return NULL;
38682 }
38683
38684
38685 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38686 PyObject *resultobj = 0;
38687 wxWindow *arg1 = (wxWindow *) 0 ;
38688 wxSizer *arg2 = (wxSizer *) 0 ;
38689 bool arg3 = (bool) true ;
38690 void *argp1 = 0 ;
38691 int res1 = 0 ;
38692 int res2 = 0 ;
38693 bool val3 ;
38694 int ecode3 = 0 ;
38695 PyObject * obj0 = 0 ;
38696 PyObject * obj1 = 0 ;
38697 PyObject * obj2 = 0 ;
38698 char * kwnames[] = {
38699 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38700 };
38701
38702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38704 if (!SWIG_IsOK(res1)) {
38705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38706 }
38707 arg1 = reinterpret_cast< wxWindow * >(argp1);
38708 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38709 if (!SWIG_IsOK(res2)) {
38710 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38711 }
38712 if (obj2) {
38713 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38714 if (!SWIG_IsOK(ecode3)) {
38715 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38716 }
38717 arg3 = static_cast< bool >(val3);
38718 }
38719 {
38720 PyThreadState* __tstate = wxPyBeginAllowThreads();
38721 (arg1)->SetSizerAndFit(arg2,arg3);
38722 wxPyEndAllowThreads(__tstate);
38723 if (PyErr_Occurred()) SWIG_fail;
38724 }
38725 resultobj = SWIG_Py_Void();
38726 return resultobj;
38727 fail:
38728 return NULL;
38729 }
38730
38731
38732 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38733 PyObject *resultobj = 0;
38734 wxWindow *arg1 = (wxWindow *) 0 ;
38735 wxSizer *result = 0 ;
38736 void *argp1 = 0 ;
38737 int res1 = 0 ;
38738 PyObject *swig_obj[1] ;
38739
38740 if (!args) SWIG_fail;
38741 swig_obj[0] = args;
38742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38743 if (!SWIG_IsOK(res1)) {
38744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38745 }
38746 arg1 = reinterpret_cast< wxWindow * >(argp1);
38747 {
38748 PyThreadState* __tstate = wxPyBeginAllowThreads();
38749 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38750 wxPyEndAllowThreads(__tstate);
38751 if (PyErr_Occurred()) SWIG_fail;
38752 }
38753 {
38754 resultobj = wxPyMake_wxObject(result, (bool)0);
38755 }
38756 return resultobj;
38757 fail:
38758 return NULL;
38759 }
38760
38761
38762 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38763 PyObject *resultobj = 0;
38764 wxWindow *arg1 = (wxWindow *) 0 ;
38765 wxSizer *arg2 = (wxSizer *) 0 ;
38766 void *argp1 = 0 ;
38767 int res1 = 0 ;
38768 void *argp2 = 0 ;
38769 int res2 = 0 ;
38770 PyObject * obj0 = 0 ;
38771 PyObject * obj1 = 0 ;
38772 char * kwnames[] = {
38773 (char *) "self",(char *) "sizer", NULL
38774 };
38775
38776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38778 if (!SWIG_IsOK(res1)) {
38779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38780 }
38781 arg1 = reinterpret_cast< wxWindow * >(argp1);
38782 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38783 if (!SWIG_IsOK(res2)) {
38784 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38785 }
38786 arg2 = reinterpret_cast< wxSizer * >(argp2);
38787 {
38788 PyThreadState* __tstate = wxPyBeginAllowThreads();
38789 (arg1)->SetContainingSizer(arg2);
38790 wxPyEndAllowThreads(__tstate);
38791 if (PyErr_Occurred()) SWIG_fail;
38792 }
38793 resultobj = SWIG_Py_Void();
38794 return resultobj;
38795 fail:
38796 return NULL;
38797 }
38798
38799
38800 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38801 PyObject *resultobj = 0;
38802 wxWindow *arg1 = (wxWindow *) 0 ;
38803 wxSizer *result = 0 ;
38804 void *argp1 = 0 ;
38805 int res1 = 0 ;
38806 PyObject *swig_obj[1] ;
38807
38808 if (!args) SWIG_fail;
38809 swig_obj[0] = args;
38810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38811 if (!SWIG_IsOK(res1)) {
38812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38813 }
38814 arg1 = reinterpret_cast< wxWindow * >(argp1);
38815 {
38816 PyThreadState* __tstate = wxPyBeginAllowThreads();
38817 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38818 wxPyEndAllowThreads(__tstate);
38819 if (PyErr_Occurred()) SWIG_fail;
38820 }
38821 {
38822 resultobj = wxPyMake_wxObject(result, (bool)0);
38823 }
38824 return resultobj;
38825 fail:
38826 return NULL;
38827 }
38828
38829
38830 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38831 PyObject *resultobj = 0;
38832 wxWindow *arg1 = (wxWindow *) 0 ;
38833 void *argp1 = 0 ;
38834 int res1 = 0 ;
38835 PyObject *swig_obj[1] ;
38836
38837 if (!args) SWIG_fail;
38838 swig_obj[0] = args;
38839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38840 if (!SWIG_IsOK(res1)) {
38841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38842 }
38843 arg1 = reinterpret_cast< wxWindow * >(argp1);
38844 {
38845 PyThreadState* __tstate = wxPyBeginAllowThreads();
38846 (arg1)->InheritAttributes();
38847 wxPyEndAllowThreads(__tstate);
38848 if (PyErr_Occurred()) SWIG_fail;
38849 }
38850 resultobj = SWIG_Py_Void();
38851 return resultobj;
38852 fail:
38853 return NULL;
38854 }
38855
38856
38857 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38858 PyObject *resultobj = 0;
38859 wxWindow *arg1 = (wxWindow *) 0 ;
38860 bool result;
38861 void *argp1 = 0 ;
38862 int res1 = 0 ;
38863 PyObject *swig_obj[1] ;
38864
38865 if (!args) SWIG_fail;
38866 swig_obj[0] = args;
38867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38868 if (!SWIG_IsOK(res1)) {
38869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38870 }
38871 arg1 = reinterpret_cast< wxWindow * >(argp1);
38872 {
38873 PyThreadState* __tstate = wxPyBeginAllowThreads();
38874 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38875 wxPyEndAllowThreads(__tstate);
38876 if (PyErr_Occurred()) SWIG_fail;
38877 }
38878 {
38879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38880 }
38881 return resultobj;
38882 fail:
38883 return NULL;
38884 }
38885
38886
38887 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38888 PyObject *resultobj = 0;
38889 wxWindow *arg1 = (wxWindow *) 0 ;
38890 bool result;
38891 void *argp1 = 0 ;
38892 int res1 = 0 ;
38893 PyObject *swig_obj[1] ;
38894
38895 if (!args) SWIG_fail;
38896 swig_obj[0] = args;
38897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38898 if (!SWIG_IsOK(res1)) {
38899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38900 }
38901 arg1 = reinterpret_cast< wxWindow * >(argp1);
38902 {
38903 PyThreadState* __tstate = wxPyBeginAllowThreads();
38904 result = (bool)(arg1)->CanSetTransparent();
38905 wxPyEndAllowThreads(__tstate);
38906 if (PyErr_Occurred()) SWIG_fail;
38907 }
38908 {
38909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38910 }
38911 return resultobj;
38912 fail:
38913 return NULL;
38914 }
38915
38916
38917 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38918 PyObject *resultobj = 0;
38919 wxWindow *arg1 = (wxWindow *) 0 ;
38920 byte arg2 ;
38921 bool result;
38922 void *argp1 = 0 ;
38923 int res1 = 0 ;
38924 unsigned char val2 ;
38925 int ecode2 = 0 ;
38926 PyObject * obj0 = 0 ;
38927 PyObject * obj1 = 0 ;
38928 char * kwnames[] = {
38929 (char *) "self",(char *) "alpha", NULL
38930 };
38931
38932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
38933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38934 if (!SWIG_IsOK(res1)) {
38935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38936 }
38937 arg1 = reinterpret_cast< wxWindow * >(argp1);
38938 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38939 if (!SWIG_IsOK(ecode2)) {
38940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38941 }
38942 arg2 = static_cast< byte >(val2);
38943 {
38944 PyThreadState* __tstate = wxPyBeginAllowThreads();
38945 result = (bool)(arg1)->SetTransparent(arg2);
38946 wxPyEndAllowThreads(__tstate);
38947 if (PyErr_Occurred()) SWIG_fail;
38948 }
38949 {
38950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38951 }
38952 return resultobj;
38953 fail:
38954 return NULL;
38955 }
38956
38957
38958 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38959 PyObject *obj;
38960 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38961 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38962 return SWIG_Py_Void();
38963 }
38964
38965 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38966 return SWIG_Python_InitShadowInstance(args);
38967 }
38968
38969 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38970 PyObject *resultobj = 0;
38971 long arg1 ;
38972 wxWindow *arg2 = (wxWindow *) NULL ;
38973 wxWindow *result = 0 ;
38974 long val1 ;
38975 int ecode1 = 0 ;
38976 void *argp2 = 0 ;
38977 int res2 = 0 ;
38978 PyObject * obj0 = 0 ;
38979 PyObject * obj1 = 0 ;
38980 char * kwnames[] = {
38981 (char *) "id",(char *) "parent", NULL
38982 };
38983
38984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
38985 ecode1 = SWIG_AsVal_long(obj0, &val1);
38986 if (!SWIG_IsOK(ecode1)) {
38987 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
38988 }
38989 arg1 = static_cast< long >(val1);
38990 if (obj1) {
38991 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38992 if (!SWIG_IsOK(res2)) {
38993 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
38994 }
38995 arg2 = reinterpret_cast< wxWindow * >(argp2);
38996 }
38997 {
38998 if (!wxPyCheckForApp()) SWIG_fail;
38999 PyThreadState* __tstate = wxPyBeginAllowThreads();
39000 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
39001 wxPyEndAllowThreads(__tstate);
39002 if (PyErr_Occurred()) SWIG_fail;
39003 }
39004 {
39005 resultobj = wxPyMake_wxObject(result, 0);
39006 }
39007 return resultobj;
39008 fail:
39009 return NULL;
39010 }
39011
39012
39013 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39014 PyObject *resultobj = 0;
39015 wxString *arg1 = 0 ;
39016 wxWindow *arg2 = (wxWindow *) NULL ;
39017 wxWindow *result = 0 ;
39018 bool temp1 = false ;
39019 void *argp2 = 0 ;
39020 int res2 = 0 ;
39021 PyObject * obj0 = 0 ;
39022 PyObject * obj1 = 0 ;
39023 char * kwnames[] = {
39024 (char *) "name",(char *) "parent", NULL
39025 };
39026
39027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
39028 {
39029 arg1 = wxString_in_helper(obj0);
39030 if (arg1 == NULL) SWIG_fail;
39031 temp1 = true;
39032 }
39033 if (obj1) {
39034 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39035 if (!SWIG_IsOK(res2)) {
39036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
39037 }
39038 arg2 = reinterpret_cast< wxWindow * >(argp2);
39039 }
39040 {
39041 if (!wxPyCheckForApp()) SWIG_fail;
39042 PyThreadState* __tstate = wxPyBeginAllowThreads();
39043 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
39044 wxPyEndAllowThreads(__tstate);
39045 if (PyErr_Occurred()) SWIG_fail;
39046 }
39047 {
39048 resultobj = wxPyMake_wxObject(result, 0);
39049 }
39050 {
39051 if (temp1)
39052 delete arg1;
39053 }
39054 return resultobj;
39055 fail:
39056 {
39057 if (temp1)
39058 delete arg1;
39059 }
39060 return NULL;
39061 }
39062
39063
39064 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39065 PyObject *resultobj = 0;
39066 wxString *arg1 = 0 ;
39067 wxWindow *arg2 = (wxWindow *) NULL ;
39068 wxWindow *result = 0 ;
39069 bool temp1 = false ;
39070 void *argp2 = 0 ;
39071 int res2 = 0 ;
39072 PyObject * obj0 = 0 ;
39073 PyObject * obj1 = 0 ;
39074 char * kwnames[] = {
39075 (char *) "label",(char *) "parent", NULL
39076 };
39077
39078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
39079 {
39080 arg1 = wxString_in_helper(obj0);
39081 if (arg1 == NULL) SWIG_fail;
39082 temp1 = true;
39083 }
39084 if (obj1) {
39085 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39086 if (!SWIG_IsOK(res2)) {
39087 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
39088 }
39089 arg2 = reinterpret_cast< wxWindow * >(argp2);
39090 }
39091 {
39092 if (!wxPyCheckForApp()) SWIG_fail;
39093 PyThreadState* __tstate = wxPyBeginAllowThreads();
39094 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
39095 wxPyEndAllowThreads(__tstate);
39096 if (PyErr_Occurred()) SWIG_fail;
39097 }
39098 {
39099 resultobj = wxPyMake_wxObject(result, 0);
39100 }
39101 {
39102 if (temp1)
39103 delete arg1;
39104 }
39105 return resultobj;
39106 fail:
39107 {
39108 if (temp1)
39109 delete arg1;
39110 }
39111 return NULL;
39112 }
39113
39114
39115 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39116 PyObject *resultobj = 0;
39117 wxWindow *arg1 = (wxWindow *) 0 ;
39118 unsigned long arg2 ;
39119 wxWindow *result = 0 ;
39120 void *argp1 = 0 ;
39121 int res1 = 0 ;
39122 unsigned long val2 ;
39123 int ecode2 = 0 ;
39124 PyObject * obj0 = 0 ;
39125 PyObject * obj1 = 0 ;
39126 char * kwnames[] = {
39127 (char *) "parent",(char *) "_hWnd", NULL
39128 };
39129
39130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
39131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39132 if (!SWIG_IsOK(res1)) {
39133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
39134 }
39135 arg1 = reinterpret_cast< wxWindow * >(argp1);
39136 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
39137 if (!SWIG_IsOK(ecode2)) {
39138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
39139 }
39140 arg2 = static_cast< unsigned long >(val2);
39141 {
39142 PyThreadState* __tstate = wxPyBeginAllowThreads();
39143 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
39144 wxPyEndAllowThreads(__tstate);
39145 if (PyErr_Occurred()) SWIG_fail;
39146 }
39147 {
39148 resultobj = wxPyMake_wxObject(result, 0);
39149 }
39150 return resultobj;
39151 fail:
39152 return NULL;
39153 }
39154
39155
39156 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39157 PyObject *resultobj = 0;
39158 PyObject *result = 0 ;
39159
39160 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
39161 {
39162 PyThreadState* __tstate = wxPyBeginAllowThreads();
39163 result = (PyObject *)GetTopLevelWindows();
39164 wxPyEndAllowThreads(__tstate);
39165 if (PyErr_Occurred()) SWIG_fail;
39166 }
39167 resultobj = result;
39168 return resultobj;
39169 fail:
39170 return NULL;
39171 }
39172
39173
39174 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39175 PyObject *resultobj = 0;
39176 wxValidator *result = 0 ;
39177
39178 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
39179 {
39180 PyThreadState* __tstate = wxPyBeginAllowThreads();
39181 result = (wxValidator *)new wxValidator();
39182 wxPyEndAllowThreads(__tstate);
39183 if (PyErr_Occurred()) SWIG_fail;
39184 }
39185 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
39186 return resultobj;
39187 fail:
39188 return NULL;
39189 }
39190
39191
39192 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39193 PyObject *resultobj = 0;
39194 wxValidator *arg1 = (wxValidator *) 0 ;
39195 wxValidator *result = 0 ;
39196 void *argp1 = 0 ;
39197 int res1 = 0 ;
39198 PyObject *swig_obj[1] ;
39199
39200 if (!args) SWIG_fail;
39201 swig_obj[0] = args;
39202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39203 if (!SWIG_IsOK(res1)) {
39204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
39205 }
39206 arg1 = reinterpret_cast< wxValidator * >(argp1);
39207 {
39208 PyThreadState* __tstate = wxPyBeginAllowThreads();
39209 result = (wxValidator *)(arg1)->Clone();
39210 wxPyEndAllowThreads(__tstate);
39211 if (PyErr_Occurred()) SWIG_fail;
39212 }
39213 {
39214 resultobj = wxPyMake_wxObject(result, 0);
39215 }
39216 return resultobj;
39217 fail:
39218 return NULL;
39219 }
39220
39221
39222 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39223 PyObject *resultobj = 0;
39224 wxValidator *arg1 = (wxValidator *) 0 ;
39225 wxWindow *arg2 = (wxWindow *) 0 ;
39226 bool result;
39227 void *argp1 = 0 ;
39228 int res1 = 0 ;
39229 void *argp2 = 0 ;
39230 int res2 = 0 ;
39231 PyObject * obj0 = 0 ;
39232 PyObject * obj1 = 0 ;
39233 char * kwnames[] = {
39234 (char *) "self",(char *) "parent", NULL
39235 };
39236
39237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
39238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39239 if (!SWIG_IsOK(res1)) {
39240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
39241 }
39242 arg1 = reinterpret_cast< wxValidator * >(argp1);
39243 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39244 if (!SWIG_IsOK(res2)) {
39245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
39246 }
39247 arg2 = reinterpret_cast< wxWindow * >(argp2);
39248 {
39249 PyThreadState* __tstate = wxPyBeginAllowThreads();
39250 result = (bool)(arg1)->Validate(arg2);
39251 wxPyEndAllowThreads(__tstate);
39252 if (PyErr_Occurred()) SWIG_fail;
39253 }
39254 {
39255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39256 }
39257 return resultobj;
39258 fail:
39259 return NULL;
39260 }
39261
39262
39263 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39264 PyObject *resultobj = 0;
39265 wxValidator *arg1 = (wxValidator *) 0 ;
39266 bool result;
39267 void *argp1 = 0 ;
39268 int res1 = 0 ;
39269 PyObject *swig_obj[1] ;
39270
39271 if (!args) SWIG_fail;
39272 swig_obj[0] = args;
39273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39274 if (!SWIG_IsOK(res1)) {
39275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39276 }
39277 arg1 = reinterpret_cast< wxValidator * >(argp1);
39278 {
39279 PyThreadState* __tstate = wxPyBeginAllowThreads();
39280 result = (bool)(arg1)->TransferToWindow();
39281 wxPyEndAllowThreads(__tstate);
39282 if (PyErr_Occurred()) SWIG_fail;
39283 }
39284 {
39285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39286 }
39287 return resultobj;
39288 fail:
39289 return NULL;
39290 }
39291
39292
39293 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39294 PyObject *resultobj = 0;
39295 wxValidator *arg1 = (wxValidator *) 0 ;
39296 bool result;
39297 void *argp1 = 0 ;
39298 int res1 = 0 ;
39299 PyObject *swig_obj[1] ;
39300
39301 if (!args) SWIG_fail;
39302 swig_obj[0] = args;
39303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39304 if (!SWIG_IsOK(res1)) {
39305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39306 }
39307 arg1 = reinterpret_cast< wxValidator * >(argp1);
39308 {
39309 PyThreadState* __tstate = wxPyBeginAllowThreads();
39310 result = (bool)(arg1)->TransferFromWindow();
39311 wxPyEndAllowThreads(__tstate);
39312 if (PyErr_Occurred()) SWIG_fail;
39313 }
39314 {
39315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39316 }
39317 return resultobj;
39318 fail:
39319 return NULL;
39320 }
39321
39322
39323 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39324 PyObject *resultobj = 0;
39325 wxValidator *arg1 = (wxValidator *) 0 ;
39326 wxWindow *result = 0 ;
39327 void *argp1 = 0 ;
39328 int res1 = 0 ;
39329 PyObject *swig_obj[1] ;
39330
39331 if (!args) SWIG_fail;
39332 swig_obj[0] = args;
39333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39334 if (!SWIG_IsOK(res1)) {
39335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39336 }
39337 arg1 = reinterpret_cast< wxValidator * >(argp1);
39338 {
39339 PyThreadState* __tstate = wxPyBeginAllowThreads();
39340 result = (wxWindow *)(arg1)->GetWindow();
39341 wxPyEndAllowThreads(__tstate);
39342 if (PyErr_Occurred()) SWIG_fail;
39343 }
39344 {
39345 resultobj = wxPyMake_wxObject(result, 0);
39346 }
39347 return resultobj;
39348 fail:
39349 return NULL;
39350 }
39351
39352
39353 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39354 PyObject *resultobj = 0;
39355 wxValidator *arg1 = (wxValidator *) 0 ;
39356 wxWindow *arg2 = (wxWindow *) 0 ;
39357 void *argp1 = 0 ;
39358 int res1 = 0 ;
39359 void *argp2 = 0 ;
39360 int res2 = 0 ;
39361 PyObject * obj0 = 0 ;
39362 PyObject * obj1 = 0 ;
39363 char * kwnames[] = {
39364 (char *) "self",(char *) "window", NULL
39365 };
39366
39367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
39368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39369 if (!SWIG_IsOK(res1)) {
39370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39371 }
39372 arg1 = reinterpret_cast< wxValidator * >(argp1);
39373 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39374 if (!SWIG_IsOK(res2)) {
39375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
39376 }
39377 arg2 = reinterpret_cast< wxWindow * >(argp2);
39378 {
39379 PyThreadState* __tstate = wxPyBeginAllowThreads();
39380 (arg1)->SetWindow(arg2);
39381 wxPyEndAllowThreads(__tstate);
39382 if (PyErr_Occurred()) SWIG_fail;
39383 }
39384 resultobj = SWIG_Py_Void();
39385 return resultobj;
39386 fail:
39387 return NULL;
39388 }
39389
39390
39391 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39392 PyObject *resultobj = 0;
39393 bool result;
39394
39395 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
39396 {
39397 PyThreadState* __tstate = wxPyBeginAllowThreads();
39398 result = (bool)wxValidator::IsSilent();
39399 wxPyEndAllowThreads(__tstate);
39400 if (PyErr_Occurred()) SWIG_fail;
39401 }
39402 {
39403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39404 }
39405 return resultobj;
39406 fail:
39407 return NULL;
39408 }
39409
39410
39411 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39412 PyObject *resultobj = 0;
39413 int arg1 = (int) true ;
39414 int val1 ;
39415 int ecode1 = 0 ;
39416 PyObject * obj0 = 0 ;
39417 char * kwnames[] = {
39418 (char *) "doIt", NULL
39419 };
39420
39421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
39422 if (obj0) {
39423 ecode1 = SWIG_AsVal_int(obj0, &val1);
39424 if (!SWIG_IsOK(ecode1)) {
39425 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
39426 }
39427 arg1 = static_cast< int >(val1);
39428 }
39429 {
39430 PyThreadState* __tstate = wxPyBeginAllowThreads();
39431 wxValidator::SetBellOnError(arg1);
39432 wxPyEndAllowThreads(__tstate);
39433 if (PyErr_Occurred()) SWIG_fail;
39434 }
39435 resultobj = SWIG_Py_Void();
39436 return resultobj;
39437 fail:
39438 return NULL;
39439 }
39440
39441
39442 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39443 PyObject *obj;
39444 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39445 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
39446 return SWIG_Py_Void();
39447 }
39448
39449 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39450 return SWIG_Python_InitShadowInstance(args);
39451 }
39452
39453 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39454 PyObject *resultobj = 0;
39455 wxPyValidator *result = 0 ;
39456
39457 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
39458 {
39459 PyThreadState* __tstate = wxPyBeginAllowThreads();
39460 result = (wxPyValidator *)new wxPyValidator();
39461 wxPyEndAllowThreads(__tstate);
39462 if (PyErr_Occurred()) SWIG_fail;
39463 }
39464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
39465 return resultobj;
39466 fail:
39467 return NULL;
39468 }
39469
39470
39471 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39472 PyObject *resultobj = 0;
39473 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
39474 PyObject *arg2 = (PyObject *) 0 ;
39475 PyObject *arg3 = (PyObject *) 0 ;
39476 int arg4 = (int) true ;
39477 void *argp1 = 0 ;
39478 int res1 = 0 ;
39479 int val4 ;
39480 int ecode4 = 0 ;
39481 PyObject * obj0 = 0 ;
39482 PyObject * obj1 = 0 ;
39483 PyObject * obj2 = 0 ;
39484 PyObject * obj3 = 0 ;
39485 char * kwnames[] = {
39486 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
39487 };
39488
39489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
39491 if (!SWIG_IsOK(res1)) {
39492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
39493 }
39494 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
39495 arg2 = obj1;
39496 arg3 = obj2;
39497 if (obj3) {
39498 ecode4 = SWIG_AsVal_int(obj3, &val4);
39499 if (!SWIG_IsOK(ecode4)) {
39500 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
39501 }
39502 arg4 = static_cast< int >(val4);
39503 }
39504 {
39505 PyThreadState* __tstate = wxPyBeginAllowThreads();
39506 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
39507 wxPyEndAllowThreads(__tstate);
39508 if (PyErr_Occurred()) SWIG_fail;
39509 }
39510 resultobj = SWIG_Py_Void();
39511 return resultobj;
39512 fail:
39513 return NULL;
39514 }
39515
39516
39517 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39518 PyObject *obj;
39519 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39520 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
39521 return SWIG_Py_Void();
39522 }
39523
39524 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39525 return SWIG_Python_InitShadowInstance(args);
39526 }
39527
39528 SWIGINTERN int DefaultValidator_set(PyObject *) {
39529 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
39530 return 1;
39531 }
39532
39533
39534 SWIGINTERN PyObject *DefaultValidator_get(void) {
39535 PyObject *pyobj = 0;
39536
39537 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
39538 return pyobj;
39539 }
39540
39541
39542 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39543 PyObject *resultobj = 0;
39544 wxString const &arg1_defvalue = wxPyEmptyString ;
39545 wxString *arg1 = (wxString *) &arg1_defvalue ;
39546 long arg2 = (long) 0 ;
39547 wxMenu *result = 0 ;
39548 bool temp1 = false ;
39549 long val2 ;
39550 int ecode2 = 0 ;
39551 PyObject * obj0 = 0 ;
39552 PyObject * obj1 = 0 ;
39553 char * kwnames[] = {
39554 (char *) "title",(char *) "style", NULL
39555 };
39556
39557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
39558 if (obj0) {
39559 {
39560 arg1 = wxString_in_helper(obj0);
39561 if (arg1 == NULL) SWIG_fail;
39562 temp1 = true;
39563 }
39564 }
39565 if (obj1) {
39566 ecode2 = SWIG_AsVal_long(obj1, &val2);
39567 if (!SWIG_IsOK(ecode2)) {
39568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
39569 }
39570 arg2 = static_cast< long >(val2);
39571 }
39572 {
39573 if (!wxPyCheckForApp()) SWIG_fail;
39574 PyThreadState* __tstate = wxPyBeginAllowThreads();
39575 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
39576 wxPyEndAllowThreads(__tstate);
39577 if (PyErr_Occurred()) SWIG_fail;
39578 }
39579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
39580 {
39581 if (temp1)
39582 delete arg1;
39583 }
39584 return resultobj;
39585 fail:
39586 {
39587 if (temp1)
39588 delete arg1;
39589 }
39590 return NULL;
39591 }
39592
39593
39594 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39595 PyObject *resultobj = 0;
39596 wxMenu *arg1 = (wxMenu *) 0 ;
39597 int arg2 ;
39598 wxString const &arg3_defvalue = wxPyEmptyString ;
39599 wxString *arg3 = (wxString *) &arg3_defvalue ;
39600 wxString const &arg4_defvalue = wxPyEmptyString ;
39601 wxString *arg4 = (wxString *) &arg4_defvalue ;
39602 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39603 wxMenuItem *result = 0 ;
39604 void *argp1 = 0 ;
39605 int res1 = 0 ;
39606 int val2 ;
39607 int ecode2 = 0 ;
39608 bool temp3 = false ;
39609 bool temp4 = false ;
39610 int val5 ;
39611 int ecode5 = 0 ;
39612 PyObject * obj0 = 0 ;
39613 PyObject * obj1 = 0 ;
39614 PyObject * obj2 = 0 ;
39615 PyObject * obj3 = 0 ;
39616 PyObject * obj4 = 0 ;
39617 char * kwnames[] = {
39618 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39619 };
39620
39621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39623 if (!SWIG_IsOK(res1)) {
39624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
39625 }
39626 arg1 = reinterpret_cast< wxMenu * >(argp1);
39627 ecode2 = SWIG_AsVal_int(obj1, &val2);
39628 if (!SWIG_IsOK(ecode2)) {
39629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
39630 }
39631 arg2 = static_cast< int >(val2);
39632 if (obj2) {
39633 {
39634 arg3 = wxString_in_helper(obj2);
39635 if (arg3 == NULL) SWIG_fail;
39636 temp3 = true;
39637 }
39638 }
39639 if (obj3) {
39640 {
39641 arg4 = wxString_in_helper(obj3);
39642 if (arg4 == NULL) SWIG_fail;
39643 temp4 = true;
39644 }
39645 }
39646 if (obj4) {
39647 ecode5 = SWIG_AsVal_int(obj4, &val5);
39648 if (!SWIG_IsOK(ecode5)) {
39649 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
39650 }
39651 arg5 = static_cast< wxItemKind >(val5);
39652 }
39653 {
39654 PyThreadState* __tstate = wxPyBeginAllowThreads();
39655 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39656 wxPyEndAllowThreads(__tstate);
39657 if (PyErr_Occurred()) SWIG_fail;
39658 }
39659 {
39660 resultobj = wxPyMake_wxObject(result, (bool)0);
39661 }
39662 {
39663 if (temp3)
39664 delete arg3;
39665 }
39666 {
39667 if (temp4)
39668 delete arg4;
39669 }
39670 return resultobj;
39671 fail:
39672 {
39673 if (temp3)
39674 delete arg3;
39675 }
39676 {
39677 if (temp4)
39678 delete arg4;
39679 }
39680 return NULL;
39681 }
39682
39683
39684 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39685 PyObject *resultobj = 0;
39686 wxMenu *arg1 = (wxMenu *) 0 ;
39687 wxMenuItem *result = 0 ;
39688 void *argp1 = 0 ;
39689 int res1 = 0 ;
39690 PyObject *swig_obj[1] ;
39691
39692 if (!args) SWIG_fail;
39693 swig_obj[0] = args;
39694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39695 if (!SWIG_IsOK(res1)) {
39696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39697 }
39698 arg1 = reinterpret_cast< wxMenu * >(argp1);
39699 {
39700 PyThreadState* __tstate = wxPyBeginAllowThreads();
39701 result = (wxMenuItem *)(arg1)->AppendSeparator();
39702 wxPyEndAllowThreads(__tstate);
39703 if (PyErr_Occurred()) SWIG_fail;
39704 }
39705 {
39706 resultobj = wxPyMake_wxObject(result, (bool)0);
39707 }
39708 return resultobj;
39709 fail:
39710 return NULL;
39711 }
39712
39713
39714 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39715 PyObject *resultobj = 0;
39716 wxMenu *arg1 = (wxMenu *) 0 ;
39717 int arg2 ;
39718 wxString *arg3 = 0 ;
39719 wxString const &arg4_defvalue = wxPyEmptyString ;
39720 wxString *arg4 = (wxString *) &arg4_defvalue ;
39721 wxMenuItem *result = 0 ;
39722 void *argp1 = 0 ;
39723 int res1 = 0 ;
39724 int val2 ;
39725 int ecode2 = 0 ;
39726 bool temp3 = false ;
39727 bool temp4 = false ;
39728 PyObject * obj0 = 0 ;
39729 PyObject * obj1 = 0 ;
39730 PyObject * obj2 = 0 ;
39731 PyObject * obj3 = 0 ;
39732 char * kwnames[] = {
39733 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39734 };
39735
39736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39738 if (!SWIG_IsOK(res1)) {
39739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39740 }
39741 arg1 = reinterpret_cast< wxMenu * >(argp1);
39742 ecode2 = SWIG_AsVal_int(obj1, &val2);
39743 if (!SWIG_IsOK(ecode2)) {
39744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39745 }
39746 arg2 = static_cast< int >(val2);
39747 {
39748 arg3 = wxString_in_helper(obj2);
39749 if (arg3 == NULL) SWIG_fail;
39750 temp3 = true;
39751 }
39752 if (obj3) {
39753 {
39754 arg4 = wxString_in_helper(obj3);
39755 if (arg4 == NULL) SWIG_fail;
39756 temp4 = true;
39757 }
39758 }
39759 {
39760 PyThreadState* __tstate = wxPyBeginAllowThreads();
39761 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39762 wxPyEndAllowThreads(__tstate);
39763 if (PyErr_Occurred()) SWIG_fail;
39764 }
39765 {
39766 resultobj = wxPyMake_wxObject(result, (bool)0);
39767 }
39768 {
39769 if (temp3)
39770 delete arg3;
39771 }
39772 {
39773 if (temp4)
39774 delete arg4;
39775 }
39776 return resultobj;
39777 fail:
39778 {
39779 if (temp3)
39780 delete arg3;
39781 }
39782 {
39783 if (temp4)
39784 delete arg4;
39785 }
39786 return NULL;
39787 }
39788
39789
39790 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39791 PyObject *resultobj = 0;
39792 wxMenu *arg1 = (wxMenu *) 0 ;
39793 int arg2 ;
39794 wxString *arg3 = 0 ;
39795 wxString const &arg4_defvalue = wxPyEmptyString ;
39796 wxString *arg4 = (wxString *) &arg4_defvalue ;
39797 wxMenuItem *result = 0 ;
39798 void *argp1 = 0 ;
39799 int res1 = 0 ;
39800 int val2 ;
39801 int ecode2 = 0 ;
39802 bool temp3 = false ;
39803 bool temp4 = false ;
39804 PyObject * obj0 = 0 ;
39805 PyObject * obj1 = 0 ;
39806 PyObject * obj2 = 0 ;
39807 PyObject * obj3 = 0 ;
39808 char * kwnames[] = {
39809 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39810 };
39811
39812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39814 if (!SWIG_IsOK(res1)) {
39815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39816 }
39817 arg1 = reinterpret_cast< wxMenu * >(argp1);
39818 ecode2 = SWIG_AsVal_int(obj1, &val2);
39819 if (!SWIG_IsOK(ecode2)) {
39820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
39821 }
39822 arg2 = static_cast< int >(val2);
39823 {
39824 arg3 = wxString_in_helper(obj2);
39825 if (arg3 == NULL) SWIG_fail;
39826 temp3 = true;
39827 }
39828 if (obj3) {
39829 {
39830 arg4 = wxString_in_helper(obj3);
39831 if (arg4 == NULL) SWIG_fail;
39832 temp4 = true;
39833 }
39834 }
39835 {
39836 PyThreadState* __tstate = wxPyBeginAllowThreads();
39837 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39838 wxPyEndAllowThreads(__tstate);
39839 if (PyErr_Occurred()) SWIG_fail;
39840 }
39841 {
39842 resultobj = wxPyMake_wxObject(result, (bool)0);
39843 }
39844 {
39845 if (temp3)
39846 delete arg3;
39847 }
39848 {
39849 if (temp4)
39850 delete arg4;
39851 }
39852 return resultobj;
39853 fail:
39854 {
39855 if (temp3)
39856 delete arg3;
39857 }
39858 {
39859 if (temp4)
39860 delete arg4;
39861 }
39862 return NULL;
39863 }
39864
39865
39866 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39867 PyObject *resultobj = 0;
39868 wxMenu *arg1 = (wxMenu *) 0 ;
39869 int arg2 ;
39870 wxString *arg3 = 0 ;
39871 wxMenu *arg4 = (wxMenu *) 0 ;
39872 wxString const &arg5_defvalue = wxPyEmptyString ;
39873 wxString *arg5 = (wxString *) &arg5_defvalue ;
39874 wxMenuItem *result = 0 ;
39875 void *argp1 = 0 ;
39876 int res1 = 0 ;
39877 int val2 ;
39878 int ecode2 = 0 ;
39879 bool temp3 = false ;
39880 void *argp4 = 0 ;
39881 int res4 = 0 ;
39882 bool temp5 = false ;
39883 PyObject * obj0 = 0 ;
39884 PyObject * obj1 = 0 ;
39885 PyObject * obj2 = 0 ;
39886 PyObject * obj3 = 0 ;
39887 PyObject * obj4 = 0 ;
39888 char * kwnames[] = {
39889 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39890 };
39891
39892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39894 if (!SWIG_IsOK(res1)) {
39895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39896 }
39897 arg1 = reinterpret_cast< wxMenu * >(argp1);
39898 ecode2 = SWIG_AsVal_int(obj1, &val2);
39899 if (!SWIG_IsOK(ecode2)) {
39900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
39901 }
39902 arg2 = static_cast< int >(val2);
39903 {
39904 arg3 = wxString_in_helper(obj2);
39905 if (arg3 == NULL) SWIG_fail;
39906 temp3 = true;
39907 }
39908 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39909 if (!SWIG_IsOK(res4)) {
39910 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39911 }
39912 arg4 = reinterpret_cast< wxMenu * >(argp4);
39913 if (obj4) {
39914 {
39915 arg5 = wxString_in_helper(obj4);
39916 if (arg5 == NULL) SWIG_fail;
39917 temp5 = true;
39918 }
39919 }
39920 {
39921 PyThreadState* __tstate = wxPyBeginAllowThreads();
39922 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39923 wxPyEndAllowThreads(__tstate);
39924 if (PyErr_Occurred()) SWIG_fail;
39925 }
39926 {
39927 resultobj = wxPyMake_wxObject(result, (bool)0);
39928 }
39929 {
39930 if (temp3)
39931 delete arg3;
39932 }
39933 {
39934 if (temp5)
39935 delete arg5;
39936 }
39937 return resultobj;
39938 fail:
39939 {
39940 if (temp3)
39941 delete arg3;
39942 }
39943 {
39944 if (temp5)
39945 delete arg5;
39946 }
39947 return NULL;
39948 }
39949
39950
39951 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39952 PyObject *resultobj = 0;
39953 wxMenu *arg1 = (wxMenu *) 0 ;
39954 wxMenu *arg2 = (wxMenu *) 0 ;
39955 wxString *arg3 = 0 ;
39956 wxString const &arg4_defvalue = wxPyEmptyString ;
39957 wxString *arg4 = (wxString *) &arg4_defvalue ;
39958 wxMenuItem *result = 0 ;
39959 void *argp1 = 0 ;
39960 int res1 = 0 ;
39961 void *argp2 = 0 ;
39962 int res2 = 0 ;
39963 bool temp3 = false ;
39964 bool temp4 = false ;
39965 PyObject * obj0 = 0 ;
39966 PyObject * obj1 = 0 ;
39967 PyObject * obj2 = 0 ;
39968 PyObject * obj3 = 0 ;
39969 char * kwnames[] = {
39970 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39971 };
39972
39973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39975 if (!SWIG_IsOK(res1)) {
39976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39977 }
39978 arg1 = reinterpret_cast< wxMenu * >(argp1);
39979 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39980 if (!SWIG_IsOK(res2)) {
39981 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39982 }
39983 arg2 = reinterpret_cast< wxMenu * >(argp2);
39984 {
39985 arg3 = wxString_in_helper(obj2);
39986 if (arg3 == NULL) SWIG_fail;
39987 temp3 = true;
39988 }
39989 if (obj3) {
39990 {
39991 arg4 = wxString_in_helper(obj3);
39992 if (arg4 == NULL) SWIG_fail;
39993 temp4 = true;
39994 }
39995 }
39996 {
39997 PyThreadState* __tstate = wxPyBeginAllowThreads();
39998 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39999 wxPyEndAllowThreads(__tstate);
40000 if (PyErr_Occurred()) SWIG_fail;
40001 }
40002 {
40003 resultobj = wxPyMake_wxObject(result, (bool)0);
40004 }
40005 {
40006 if (temp3)
40007 delete arg3;
40008 }
40009 {
40010 if (temp4)
40011 delete arg4;
40012 }
40013 return resultobj;
40014 fail:
40015 {
40016 if (temp3)
40017 delete arg3;
40018 }
40019 {
40020 if (temp4)
40021 delete arg4;
40022 }
40023 return NULL;
40024 }
40025
40026
40027 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40028 PyObject *resultobj = 0;
40029 wxMenu *arg1 = (wxMenu *) 0 ;
40030 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40031 wxMenuItem *result = 0 ;
40032 void *argp1 = 0 ;
40033 int res1 = 0 ;
40034 int res2 = 0 ;
40035 PyObject * obj0 = 0 ;
40036 PyObject * obj1 = 0 ;
40037 char * kwnames[] = {
40038 (char *) "self",(char *) "item", NULL
40039 };
40040
40041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
40042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40043 if (!SWIG_IsOK(res1)) {
40044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40045 }
40046 arg1 = reinterpret_cast< wxMenu * >(argp1);
40047 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40048 if (!SWIG_IsOK(res2)) {
40049 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40050 }
40051 {
40052 PyThreadState* __tstate = wxPyBeginAllowThreads();
40053 result = (wxMenuItem *)(arg1)->Append(arg2);
40054 wxPyEndAllowThreads(__tstate);
40055 if (PyErr_Occurred()) SWIG_fail;
40056 }
40057 {
40058 resultobj = wxPyMake_wxObject(result, (bool)0);
40059 }
40060 return resultobj;
40061 fail:
40062 return NULL;
40063 }
40064
40065
40066 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40067 PyObject *resultobj = 0;
40068 wxMenu *arg1 = (wxMenu *) 0 ;
40069 size_t arg2 ;
40070 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
40071 wxMenuItem *result = 0 ;
40072 void *argp1 = 0 ;
40073 int res1 = 0 ;
40074 size_t val2 ;
40075 int ecode2 = 0 ;
40076 int res3 = 0 ;
40077 PyObject * obj0 = 0 ;
40078 PyObject * obj1 = 0 ;
40079 PyObject * obj2 = 0 ;
40080 char * kwnames[] = {
40081 (char *) "self",(char *) "pos",(char *) "item", NULL
40082 };
40083
40084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40086 if (!SWIG_IsOK(res1)) {
40087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40088 }
40089 arg1 = reinterpret_cast< wxMenu * >(argp1);
40090 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40091 if (!SWIG_IsOK(ecode2)) {
40092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
40093 }
40094 arg2 = static_cast< size_t >(val2);
40095 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40096 if (!SWIG_IsOK(res3)) {
40097 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
40098 }
40099 {
40100 PyThreadState* __tstate = wxPyBeginAllowThreads();
40101 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
40102 wxPyEndAllowThreads(__tstate);
40103 if (PyErr_Occurred()) SWIG_fail;
40104 }
40105 {
40106 resultobj = wxPyMake_wxObject(result, (bool)0);
40107 }
40108 return resultobj;
40109 fail:
40110 return NULL;
40111 }
40112
40113
40114 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40115 PyObject *resultobj = 0;
40116 wxMenu *arg1 = (wxMenu *) 0 ;
40117 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40118 wxMenuItem *result = 0 ;
40119 void *argp1 = 0 ;
40120 int res1 = 0 ;
40121 int res2 = 0 ;
40122 PyObject * obj0 = 0 ;
40123 PyObject * obj1 = 0 ;
40124 char * kwnames[] = {
40125 (char *) "self",(char *) "item", NULL
40126 };
40127
40128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
40129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40130 if (!SWIG_IsOK(res1)) {
40131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40132 }
40133 arg1 = reinterpret_cast< wxMenu * >(argp1);
40134 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40135 if (!SWIG_IsOK(res2)) {
40136 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40137 }
40138 {
40139 PyThreadState* __tstate = wxPyBeginAllowThreads();
40140 result = (wxMenuItem *)(arg1)->Prepend(arg2);
40141 wxPyEndAllowThreads(__tstate);
40142 if (PyErr_Occurred()) SWIG_fail;
40143 }
40144 {
40145 resultobj = wxPyMake_wxObject(result, (bool)0);
40146 }
40147 return resultobj;
40148 fail:
40149 return NULL;
40150 }
40151
40152
40153 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40154 PyObject *resultobj = 0;
40155 wxMenu *arg1 = (wxMenu *) 0 ;
40156 void *argp1 = 0 ;
40157 int res1 = 0 ;
40158 PyObject *swig_obj[1] ;
40159
40160 if (!args) SWIG_fail;
40161 swig_obj[0] = args;
40162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40163 if (!SWIG_IsOK(res1)) {
40164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
40165 }
40166 arg1 = reinterpret_cast< wxMenu * >(argp1);
40167 {
40168 PyThreadState* __tstate = wxPyBeginAllowThreads();
40169 (arg1)->Break();
40170 wxPyEndAllowThreads(__tstate);
40171 if (PyErr_Occurred()) SWIG_fail;
40172 }
40173 resultobj = SWIG_Py_Void();
40174 return resultobj;
40175 fail:
40176 return NULL;
40177 }
40178
40179
40180 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40181 PyObject *resultobj = 0;
40182 wxMenu *arg1 = (wxMenu *) 0 ;
40183 size_t arg2 ;
40184 int arg3 ;
40185 wxString const &arg4_defvalue = wxPyEmptyString ;
40186 wxString *arg4 = (wxString *) &arg4_defvalue ;
40187 wxString const &arg5_defvalue = wxPyEmptyString ;
40188 wxString *arg5 = (wxString *) &arg5_defvalue ;
40189 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
40190 wxMenuItem *result = 0 ;
40191 void *argp1 = 0 ;
40192 int res1 = 0 ;
40193 size_t val2 ;
40194 int ecode2 = 0 ;
40195 int val3 ;
40196 int ecode3 = 0 ;
40197 bool temp4 = false ;
40198 bool temp5 = false ;
40199 int val6 ;
40200 int ecode6 = 0 ;
40201 PyObject * obj0 = 0 ;
40202 PyObject * obj1 = 0 ;
40203 PyObject * obj2 = 0 ;
40204 PyObject * obj3 = 0 ;
40205 PyObject * obj4 = 0 ;
40206 PyObject * obj5 = 0 ;
40207 char * kwnames[] = {
40208 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40209 };
40210
40211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40213 if (!SWIG_IsOK(res1)) {
40214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
40215 }
40216 arg1 = reinterpret_cast< wxMenu * >(argp1);
40217 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40218 if (!SWIG_IsOK(ecode2)) {
40219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
40220 }
40221 arg2 = static_cast< size_t >(val2);
40222 ecode3 = SWIG_AsVal_int(obj2, &val3);
40223 if (!SWIG_IsOK(ecode3)) {
40224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
40225 }
40226 arg3 = static_cast< int >(val3);
40227 if (obj3) {
40228 {
40229 arg4 = wxString_in_helper(obj3);
40230 if (arg4 == NULL) SWIG_fail;
40231 temp4 = true;
40232 }
40233 }
40234 if (obj4) {
40235 {
40236 arg5 = wxString_in_helper(obj4);
40237 if (arg5 == NULL) SWIG_fail;
40238 temp5 = true;
40239 }
40240 }
40241 if (obj5) {
40242 ecode6 = SWIG_AsVal_int(obj5, &val6);
40243 if (!SWIG_IsOK(ecode6)) {
40244 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
40245 }
40246 arg6 = static_cast< wxItemKind >(val6);
40247 }
40248 {
40249 PyThreadState* __tstate = wxPyBeginAllowThreads();
40250 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
40251 wxPyEndAllowThreads(__tstate);
40252 if (PyErr_Occurred()) SWIG_fail;
40253 }
40254 {
40255 resultobj = wxPyMake_wxObject(result, (bool)0);
40256 }
40257 {
40258 if (temp4)
40259 delete arg4;
40260 }
40261 {
40262 if (temp5)
40263 delete arg5;
40264 }
40265 return resultobj;
40266 fail:
40267 {
40268 if (temp4)
40269 delete arg4;
40270 }
40271 {
40272 if (temp5)
40273 delete arg5;
40274 }
40275 return NULL;
40276 }
40277
40278
40279 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40280 PyObject *resultobj = 0;
40281 wxMenu *arg1 = (wxMenu *) 0 ;
40282 size_t arg2 ;
40283 wxMenuItem *result = 0 ;
40284 void *argp1 = 0 ;
40285 int res1 = 0 ;
40286 size_t val2 ;
40287 int ecode2 = 0 ;
40288 PyObject * obj0 = 0 ;
40289 PyObject * obj1 = 0 ;
40290 char * kwnames[] = {
40291 (char *) "self",(char *) "pos", NULL
40292 };
40293
40294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
40295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40296 if (!SWIG_IsOK(res1)) {
40297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40298 }
40299 arg1 = reinterpret_cast< wxMenu * >(argp1);
40300 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40301 if (!SWIG_IsOK(ecode2)) {
40302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
40303 }
40304 arg2 = static_cast< size_t >(val2);
40305 {
40306 PyThreadState* __tstate = wxPyBeginAllowThreads();
40307 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
40308 wxPyEndAllowThreads(__tstate);
40309 if (PyErr_Occurred()) SWIG_fail;
40310 }
40311 {
40312 resultobj = wxPyMake_wxObject(result, (bool)0);
40313 }
40314 return resultobj;
40315 fail:
40316 return NULL;
40317 }
40318
40319
40320 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40321 PyObject *resultobj = 0;
40322 wxMenu *arg1 = (wxMenu *) 0 ;
40323 size_t arg2 ;
40324 int arg3 ;
40325 wxString *arg4 = 0 ;
40326 wxString const &arg5_defvalue = wxPyEmptyString ;
40327 wxString *arg5 = (wxString *) &arg5_defvalue ;
40328 wxMenuItem *result = 0 ;
40329 void *argp1 = 0 ;
40330 int res1 = 0 ;
40331 size_t val2 ;
40332 int ecode2 = 0 ;
40333 int val3 ;
40334 int ecode3 = 0 ;
40335 bool temp4 = false ;
40336 bool temp5 = false ;
40337 PyObject * obj0 = 0 ;
40338 PyObject * obj1 = 0 ;
40339 PyObject * obj2 = 0 ;
40340 PyObject * obj3 = 0 ;
40341 PyObject * obj4 = 0 ;
40342 char * kwnames[] = {
40343 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
40344 };
40345
40346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40348 if (!SWIG_IsOK(res1)) {
40349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40350 }
40351 arg1 = reinterpret_cast< wxMenu * >(argp1);
40352 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40353 if (!SWIG_IsOK(ecode2)) {
40354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
40355 }
40356 arg2 = static_cast< size_t >(val2);
40357 ecode3 = SWIG_AsVal_int(obj2, &val3);
40358 if (!SWIG_IsOK(ecode3)) {
40359 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
40360 }
40361 arg3 = static_cast< int >(val3);
40362 {
40363 arg4 = wxString_in_helper(obj3);
40364 if (arg4 == NULL) SWIG_fail;
40365 temp4 = true;
40366 }
40367 if (obj4) {
40368 {
40369 arg5 = wxString_in_helper(obj4);
40370 if (arg5 == NULL) SWIG_fail;
40371 temp5 = true;
40372 }
40373 }
40374 {
40375 PyThreadState* __tstate = wxPyBeginAllowThreads();
40376 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
40377 wxPyEndAllowThreads(__tstate);
40378 if (PyErr_Occurred()) SWIG_fail;
40379 }
40380 {
40381 resultobj = wxPyMake_wxObject(result, (bool)0);
40382 }
40383 {
40384 if (temp4)
40385 delete arg4;
40386 }
40387 {
40388 if (temp5)
40389 delete arg5;
40390 }
40391 return resultobj;
40392 fail:
40393 {
40394 if (temp4)
40395 delete arg4;
40396 }
40397 {
40398 if (temp5)
40399 delete arg5;
40400 }
40401 return NULL;
40402 }
40403
40404
40405 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40406 PyObject *resultobj = 0;
40407 wxMenu *arg1 = (wxMenu *) 0 ;
40408 size_t arg2 ;
40409 int arg3 ;
40410 wxString *arg4 = 0 ;
40411 wxString const &arg5_defvalue = wxPyEmptyString ;
40412 wxString *arg5 = (wxString *) &arg5_defvalue ;
40413 wxMenuItem *result = 0 ;
40414 void *argp1 = 0 ;
40415 int res1 = 0 ;
40416 size_t val2 ;
40417 int ecode2 = 0 ;
40418 int val3 ;
40419 int ecode3 = 0 ;
40420 bool temp4 = false ;
40421 bool temp5 = false ;
40422 PyObject * obj0 = 0 ;
40423 PyObject * obj1 = 0 ;
40424 PyObject * obj2 = 0 ;
40425 PyObject * obj3 = 0 ;
40426 PyObject * obj4 = 0 ;
40427 char * kwnames[] = {
40428 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
40429 };
40430
40431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40433 if (!SWIG_IsOK(res1)) {
40434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40435 }
40436 arg1 = reinterpret_cast< wxMenu * >(argp1);
40437 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40438 if (!SWIG_IsOK(ecode2)) {
40439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
40440 }
40441 arg2 = static_cast< size_t >(val2);
40442 ecode3 = SWIG_AsVal_int(obj2, &val3);
40443 if (!SWIG_IsOK(ecode3)) {
40444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
40445 }
40446 arg3 = static_cast< int >(val3);
40447 {
40448 arg4 = wxString_in_helper(obj3);
40449 if (arg4 == NULL) SWIG_fail;
40450 temp4 = true;
40451 }
40452 if (obj4) {
40453 {
40454 arg5 = wxString_in_helper(obj4);
40455 if (arg5 == NULL) SWIG_fail;
40456 temp5 = true;
40457 }
40458 }
40459 {
40460 PyThreadState* __tstate = wxPyBeginAllowThreads();
40461 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
40462 wxPyEndAllowThreads(__tstate);
40463 if (PyErr_Occurred()) SWIG_fail;
40464 }
40465 {
40466 resultobj = wxPyMake_wxObject(result, (bool)0);
40467 }
40468 {
40469 if (temp4)
40470 delete arg4;
40471 }
40472 {
40473 if (temp5)
40474 delete arg5;
40475 }
40476 return resultobj;
40477 fail:
40478 {
40479 if (temp4)
40480 delete arg4;
40481 }
40482 {
40483 if (temp5)
40484 delete arg5;
40485 }
40486 return NULL;
40487 }
40488
40489
40490 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40491 PyObject *resultobj = 0;
40492 wxMenu *arg1 = (wxMenu *) 0 ;
40493 size_t arg2 ;
40494 int arg3 ;
40495 wxString *arg4 = 0 ;
40496 wxMenu *arg5 = (wxMenu *) 0 ;
40497 wxString const &arg6_defvalue = wxPyEmptyString ;
40498 wxString *arg6 = (wxString *) &arg6_defvalue ;
40499 wxMenuItem *result = 0 ;
40500 void *argp1 = 0 ;
40501 int res1 = 0 ;
40502 size_t val2 ;
40503 int ecode2 = 0 ;
40504 int val3 ;
40505 int ecode3 = 0 ;
40506 bool temp4 = false ;
40507 void *argp5 = 0 ;
40508 int res5 = 0 ;
40509 bool temp6 = false ;
40510 PyObject * obj0 = 0 ;
40511 PyObject * obj1 = 0 ;
40512 PyObject * obj2 = 0 ;
40513 PyObject * obj3 = 0 ;
40514 PyObject * obj4 = 0 ;
40515 PyObject * obj5 = 0 ;
40516 char * kwnames[] = {
40517 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40518 };
40519
40520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40522 if (!SWIG_IsOK(res1)) {
40523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40524 }
40525 arg1 = reinterpret_cast< wxMenu * >(argp1);
40526 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40527 if (!SWIG_IsOK(ecode2)) {
40528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
40529 }
40530 arg2 = static_cast< size_t >(val2);
40531 ecode3 = SWIG_AsVal_int(obj2, &val3);
40532 if (!SWIG_IsOK(ecode3)) {
40533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
40534 }
40535 arg3 = static_cast< int >(val3);
40536 {
40537 arg4 = wxString_in_helper(obj3);
40538 if (arg4 == NULL) SWIG_fail;
40539 temp4 = true;
40540 }
40541 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
40542 if (!SWIG_IsOK(res5)) {
40543 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
40544 }
40545 arg5 = reinterpret_cast< wxMenu * >(argp5);
40546 if (obj5) {
40547 {
40548 arg6 = wxString_in_helper(obj5);
40549 if (arg6 == NULL) SWIG_fail;
40550 temp6 = true;
40551 }
40552 }
40553 {
40554 PyThreadState* __tstate = wxPyBeginAllowThreads();
40555 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
40556 wxPyEndAllowThreads(__tstate);
40557 if (PyErr_Occurred()) SWIG_fail;
40558 }
40559 {
40560 resultobj = wxPyMake_wxObject(result, (bool)0);
40561 }
40562 {
40563 if (temp4)
40564 delete arg4;
40565 }
40566 {
40567 if (temp6)
40568 delete arg6;
40569 }
40570 return resultobj;
40571 fail:
40572 {
40573 if (temp4)
40574 delete arg4;
40575 }
40576 {
40577 if (temp6)
40578 delete arg6;
40579 }
40580 return NULL;
40581 }
40582
40583
40584 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40585 PyObject *resultobj = 0;
40586 wxMenu *arg1 = (wxMenu *) 0 ;
40587 int arg2 ;
40588 wxString const &arg3_defvalue = wxPyEmptyString ;
40589 wxString *arg3 = (wxString *) &arg3_defvalue ;
40590 wxString const &arg4_defvalue = wxPyEmptyString ;
40591 wxString *arg4 = (wxString *) &arg4_defvalue ;
40592 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
40593 wxMenuItem *result = 0 ;
40594 void *argp1 = 0 ;
40595 int res1 = 0 ;
40596 int val2 ;
40597 int ecode2 = 0 ;
40598 bool temp3 = false ;
40599 bool temp4 = false ;
40600 int val5 ;
40601 int ecode5 = 0 ;
40602 PyObject * obj0 = 0 ;
40603 PyObject * obj1 = 0 ;
40604 PyObject * obj2 = 0 ;
40605 PyObject * obj3 = 0 ;
40606 PyObject * obj4 = 0 ;
40607 char * kwnames[] = {
40608 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40609 };
40610
40611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40613 if (!SWIG_IsOK(res1)) {
40614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
40615 }
40616 arg1 = reinterpret_cast< wxMenu * >(argp1);
40617 ecode2 = SWIG_AsVal_int(obj1, &val2);
40618 if (!SWIG_IsOK(ecode2)) {
40619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
40620 }
40621 arg2 = static_cast< int >(val2);
40622 if (obj2) {
40623 {
40624 arg3 = wxString_in_helper(obj2);
40625 if (arg3 == NULL) SWIG_fail;
40626 temp3 = true;
40627 }
40628 }
40629 if (obj3) {
40630 {
40631 arg4 = wxString_in_helper(obj3);
40632 if (arg4 == NULL) SWIG_fail;
40633 temp4 = true;
40634 }
40635 }
40636 if (obj4) {
40637 ecode5 = SWIG_AsVal_int(obj4, &val5);
40638 if (!SWIG_IsOK(ecode5)) {
40639 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
40640 }
40641 arg5 = static_cast< wxItemKind >(val5);
40642 }
40643 {
40644 PyThreadState* __tstate = wxPyBeginAllowThreads();
40645 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
40646 wxPyEndAllowThreads(__tstate);
40647 if (PyErr_Occurred()) SWIG_fail;
40648 }
40649 {
40650 resultobj = wxPyMake_wxObject(result, (bool)0);
40651 }
40652 {
40653 if (temp3)
40654 delete arg3;
40655 }
40656 {
40657 if (temp4)
40658 delete arg4;
40659 }
40660 return resultobj;
40661 fail:
40662 {
40663 if (temp3)
40664 delete arg3;
40665 }
40666 {
40667 if (temp4)
40668 delete arg4;
40669 }
40670 return NULL;
40671 }
40672
40673
40674 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40675 PyObject *resultobj = 0;
40676 wxMenu *arg1 = (wxMenu *) 0 ;
40677 wxMenuItem *result = 0 ;
40678 void *argp1 = 0 ;
40679 int res1 = 0 ;
40680 PyObject *swig_obj[1] ;
40681
40682 if (!args) SWIG_fail;
40683 swig_obj[0] = args;
40684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40685 if (!SWIG_IsOK(res1)) {
40686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40687 }
40688 arg1 = reinterpret_cast< wxMenu * >(argp1);
40689 {
40690 PyThreadState* __tstate = wxPyBeginAllowThreads();
40691 result = (wxMenuItem *)(arg1)->PrependSeparator();
40692 wxPyEndAllowThreads(__tstate);
40693 if (PyErr_Occurred()) SWIG_fail;
40694 }
40695 {
40696 resultobj = wxPyMake_wxObject(result, (bool)0);
40697 }
40698 return resultobj;
40699 fail:
40700 return NULL;
40701 }
40702
40703
40704 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40705 PyObject *resultobj = 0;
40706 wxMenu *arg1 = (wxMenu *) 0 ;
40707 int arg2 ;
40708 wxString *arg3 = 0 ;
40709 wxString const &arg4_defvalue = wxPyEmptyString ;
40710 wxString *arg4 = (wxString *) &arg4_defvalue ;
40711 wxMenuItem *result = 0 ;
40712 void *argp1 = 0 ;
40713 int res1 = 0 ;
40714 int val2 ;
40715 int ecode2 = 0 ;
40716 bool temp3 = false ;
40717 bool temp4 = false ;
40718 PyObject * obj0 = 0 ;
40719 PyObject * obj1 = 0 ;
40720 PyObject * obj2 = 0 ;
40721 PyObject * obj3 = 0 ;
40722 char * kwnames[] = {
40723 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40724 };
40725
40726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40728 if (!SWIG_IsOK(res1)) {
40729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40730 }
40731 arg1 = reinterpret_cast< wxMenu * >(argp1);
40732 ecode2 = SWIG_AsVal_int(obj1, &val2);
40733 if (!SWIG_IsOK(ecode2)) {
40734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40735 }
40736 arg2 = static_cast< int >(val2);
40737 {
40738 arg3 = wxString_in_helper(obj2);
40739 if (arg3 == NULL) SWIG_fail;
40740 temp3 = true;
40741 }
40742 if (obj3) {
40743 {
40744 arg4 = wxString_in_helper(obj3);
40745 if (arg4 == NULL) SWIG_fail;
40746 temp4 = true;
40747 }
40748 }
40749 {
40750 PyThreadState* __tstate = wxPyBeginAllowThreads();
40751 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40752 wxPyEndAllowThreads(__tstate);
40753 if (PyErr_Occurred()) SWIG_fail;
40754 }
40755 {
40756 resultobj = wxPyMake_wxObject(result, (bool)0);
40757 }
40758 {
40759 if (temp3)
40760 delete arg3;
40761 }
40762 {
40763 if (temp4)
40764 delete arg4;
40765 }
40766 return resultobj;
40767 fail:
40768 {
40769 if (temp3)
40770 delete arg3;
40771 }
40772 {
40773 if (temp4)
40774 delete arg4;
40775 }
40776 return NULL;
40777 }
40778
40779
40780 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40781 PyObject *resultobj = 0;
40782 wxMenu *arg1 = (wxMenu *) 0 ;
40783 int arg2 ;
40784 wxString *arg3 = 0 ;
40785 wxString const &arg4_defvalue = wxPyEmptyString ;
40786 wxString *arg4 = (wxString *) &arg4_defvalue ;
40787 wxMenuItem *result = 0 ;
40788 void *argp1 = 0 ;
40789 int res1 = 0 ;
40790 int val2 ;
40791 int ecode2 = 0 ;
40792 bool temp3 = false ;
40793 bool temp4 = false ;
40794 PyObject * obj0 = 0 ;
40795 PyObject * obj1 = 0 ;
40796 PyObject * obj2 = 0 ;
40797 PyObject * obj3 = 0 ;
40798 char * kwnames[] = {
40799 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40800 };
40801
40802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40804 if (!SWIG_IsOK(res1)) {
40805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40806 }
40807 arg1 = reinterpret_cast< wxMenu * >(argp1);
40808 ecode2 = SWIG_AsVal_int(obj1, &val2);
40809 if (!SWIG_IsOK(ecode2)) {
40810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
40811 }
40812 arg2 = static_cast< int >(val2);
40813 {
40814 arg3 = wxString_in_helper(obj2);
40815 if (arg3 == NULL) SWIG_fail;
40816 temp3 = true;
40817 }
40818 if (obj3) {
40819 {
40820 arg4 = wxString_in_helper(obj3);
40821 if (arg4 == NULL) SWIG_fail;
40822 temp4 = true;
40823 }
40824 }
40825 {
40826 PyThreadState* __tstate = wxPyBeginAllowThreads();
40827 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40828 wxPyEndAllowThreads(__tstate);
40829 if (PyErr_Occurred()) SWIG_fail;
40830 }
40831 {
40832 resultobj = wxPyMake_wxObject(result, (bool)0);
40833 }
40834 {
40835 if (temp3)
40836 delete arg3;
40837 }
40838 {
40839 if (temp4)
40840 delete arg4;
40841 }
40842 return resultobj;
40843 fail:
40844 {
40845 if (temp3)
40846 delete arg3;
40847 }
40848 {
40849 if (temp4)
40850 delete arg4;
40851 }
40852 return NULL;
40853 }
40854
40855
40856 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40857 PyObject *resultobj = 0;
40858 wxMenu *arg1 = (wxMenu *) 0 ;
40859 int arg2 ;
40860 wxString *arg3 = 0 ;
40861 wxMenu *arg4 = (wxMenu *) 0 ;
40862 wxString const &arg5_defvalue = wxPyEmptyString ;
40863 wxString *arg5 = (wxString *) &arg5_defvalue ;
40864 wxMenuItem *result = 0 ;
40865 void *argp1 = 0 ;
40866 int res1 = 0 ;
40867 int val2 ;
40868 int ecode2 = 0 ;
40869 bool temp3 = false ;
40870 void *argp4 = 0 ;
40871 int res4 = 0 ;
40872 bool temp5 = false ;
40873 PyObject * obj0 = 0 ;
40874 PyObject * obj1 = 0 ;
40875 PyObject * obj2 = 0 ;
40876 PyObject * obj3 = 0 ;
40877 PyObject * obj4 = 0 ;
40878 char * kwnames[] = {
40879 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40880 };
40881
40882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40884 if (!SWIG_IsOK(res1)) {
40885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40886 }
40887 arg1 = reinterpret_cast< wxMenu * >(argp1);
40888 ecode2 = SWIG_AsVal_int(obj1, &val2);
40889 if (!SWIG_IsOK(ecode2)) {
40890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
40891 }
40892 arg2 = static_cast< int >(val2);
40893 {
40894 arg3 = wxString_in_helper(obj2);
40895 if (arg3 == NULL) SWIG_fail;
40896 temp3 = true;
40897 }
40898 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40899 if (!SWIG_IsOK(res4)) {
40900 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40901 }
40902 arg4 = reinterpret_cast< wxMenu * >(argp4);
40903 if (obj4) {
40904 {
40905 arg5 = wxString_in_helper(obj4);
40906 if (arg5 == NULL) SWIG_fail;
40907 temp5 = true;
40908 }
40909 }
40910 {
40911 PyThreadState* __tstate = wxPyBeginAllowThreads();
40912 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40913 wxPyEndAllowThreads(__tstate);
40914 if (PyErr_Occurred()) SWIG_fail;
40915 }
40916 {
40917 resultobj = wxPyMake_wxObject(result, (bool)0);
40918 }
40919 {
40920 if (temp3)
40921 delete arg3;
40922 }
40923 {
40924 if (temp5)
40925 delete arg5;
40926 }
40927 return resultobj;
40928 fail:
40929 {
40930 if (temp3)
40931 delete arg3;
40932 }
40933 {
40934 if (temp5)
40935 delete arg5;
40936 }
40937 return NULL;
40938 }
40939
40940
40941 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40942 PyObject *resultobj = 0;
40943 wxMenu *arg1 = (wxMenu *) 0 ;
40944 int arg2 ;
40945 wxMenuItem *result = 0 ;
40946 void *argp1 = 0 ;
40947 int res1 = 0 ;
40948 int val2 ;
40949 int ecode2 = 0 ;
40950 PyObject * obj0 = 0 ;
40951 PyObject * obj1 = 0 ;
40952 char * kwnames[] = {
40953 (char *) "self",(char *) "id", NULL
40954 };
40955
40956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40958 if (!SWIG_IsOK(res1)) {
40959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40960 }
40961 arg1 = reinterpret_cast< wxMenu * >(argp1);
40962 ecode2 = SWIG_AsVal_int(obj1, &val2);
40963 if (!SWIG_IsOK(ecode2)) {
40964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40965 }
40966 arg2 = static_cast< int >(val2);
40967 {
40968 PyThreadState* __tstate = wxPyBeginAllowThreads();
40969 result = (wxMenuItem *)(arg1)->Remove(arg2);
40970 wxPyEndAllowThreads(__tstate);
40971 if (PyErr_Occurred()) SWIG_fail;
40972 }
40973 {
40974 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40975 }
40976 return resultobj;
40977 fail:
40978 return NULL;
40979 }
40980
40981
40982 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40983 PyObject *resultobj = 0;
40984 wxMenu *arg1 = (wxMenu *) 0 ;
40985 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40986 wxMenuItem *result = 0 ;
40987 void *argp1 = 0 ;
40988 int res1 = 0 ;
40989 void *argp2 = 0 ;
40990 int res2 = 0 ;
40991 PyObject * obj0 = 0 ;
40992 PyObject * obj1 = 0 ;
40993 char * kwnames[] = {
40994 (char *) "self",(char *) "item", NULL
40995 };
40996
40997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
40998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40999 if (!SWIG_IsOK(res1)) {
41000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41001 }
41002 arg1 = reinterpret_cast< wxMenu * >(argp1);
41003 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41004 if (!SWIG_IsOK(res2)) {
41005 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41006 }
41007 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41008 {
41009 PyThreadState* __tstate = wxPyBeginAllowThreads();
41010 result = (wxMenuItem *)(arg1)->Remove(arg2);
41011 wxPyEndAllowThreads(__tstate);
41012 if (PyErr_Occurred()) SWIG_fail;
41013 }
41014 {
41015 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
41016 }
41017 return resultobj;
41018 fail:
41019 return NULL;
41020 }
41021
41022
41023 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41024 PyObject *resultobj = 0;
41025 wxMenu *arg1 = (wxMenu *) 0 ;
41026 int arg2 ;
41027 bool result;
41028 void *argp1 = 0 ;
41029 int res1 = 0 ;
41030 int val2 ;
41031 int ecode2 = 0 ;
41032 PyObject * obj0 = 0 ;
41033 PyObject * obj1 = 0 ;
41034 char * kwnames[] = {
41035 (char *) "self",(char *) "id", NULL
41036 };
41037
41038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
41039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41040 if (!SWIG_IsOK(res1)) {
41041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
41042 }
41043 arg1 = reinterpret_cast< wxMenu * >(argp1);
41044 ecode2 = SWIG_AsVal_int(obj1, &val2);
41045 if (!SWIG_IsOK(ecode2)) {
41046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
41047 }
41048 arg2 = static_cast< int >(val2);
41049 {
41050 PyThreadState* __tstate = wxPyBeginAllowThreads();
41051 result = (bool)(arg1)->Delete(arg2);
41052 wxPyEndAllowThreads(__tstate);
41053 if (PyErr_Occurred()) SWIG_fail;
41054 }
41055 {
41056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41057 }
41058 return resultobj;
41059 fail:
41060 return NULL;
41061 }
41062
41063
41064 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41065 PyObject *resultobj = 0;
41066 wxMenu *arg1 = (wxMenu *) 0 ;
41067 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
41068 bool result;
41069 void *argp1 = 0 ;
41070 int res1 = 0 ;
41071 void *argp2 = 0 ;
41072 int res2 = 0 ;
41073 PyObject * obj0 = 0 ;
41074 PyObject * obj1 = 0 ;
41075 char * kwnames[] = {
41076 (char *) "self",(char *) "item", NULL
41077 };
41078
41079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
41080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41081 if (!SWIG_IsOK(res1)) {
41082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41083 }
41084 arg1 = reinterpret_cast< wxMenu * >(argp1);
41085 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41086 if (!SWIG_IsOK(res2)) {
41087 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41088 }
41089 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41090 {
41091 PyThreadState* __tstate = wxPyBeginAllowThreads();
41092 result = (bool)(arg1)->Delete(arg2);
41093 wxPyEndAllowThreads(__tstate);
41094 if (PyErr_Occurred()) SWIG_fail;
41095 }
41096 {
41097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41098 }
41099 return resultobj;
41100 fail:
41101 return NULL;
41102 }
41103
41104
41105 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41106 PyObject *resultobj = 0;
41107 wxMenu *arg1 = (wxMenu *) 0 ;
41108 void *argp1 = 0 ;
41109 int res1 = 0 ;
41110 PyObject *swig_obj[1] ;
41111
41112 if (!args) SWIG_fail;
41113 swig_obj[0] = args;
41114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41115 if (!SWIG_IsOK(res1)) {
41116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
41117 }
41118 arg1 = reinterpret_cast< wxMenu * >(argp1);
41119 {
41120 PyThreadState* __tstate = wxPyBeginAllowThreads();
41121 wxMenu_Destroy(arg1);
41122 wxPyEndAllowThreads(__tstate);
41123 if (PyErr_Occurred()) SWIG_fail;
41124 }
41125 resultobj = SWIG_Py_Void();
41126 return resultobj;
41127 fail:
41128 return NULL;
41129 }
41130
41131
41132 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41133 PyObject *resultobj = 0;
41134 wxMenu *arg1 = (wxMenu *) 0 ;
41135 int arg2 ;
41136 bool result;
41137 void *argp1 = 0 ;
41138 int res1 = 0 ;
41139 int val2 ;
41140 int ecode2 = 0 ;
41141 PyObject * obj0 = 0 ;
41142 PyObject * obj1 = 0 ;
41143 char * kwnames[] = {
41144 (char *) "self",(char *) "id", NULL
41145 };
41146
41147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
41148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41149 if (!SWIG_IsOK(res1)) {
41150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
41151 }
41152 arg1 = reinterpret_cast< wxMenu * >(argp1);
41153 ecode2 = SWIG_AsVal_int(obj1, &val2);
41154 if (!SWIG_IsOK(ecode2)) {
41155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
41156 }
41157 arg2 = static_cast< int >(val2);
41158 {
41159 PyThreadState* __tstate = wxPyBeginAllowThreads();
41160 result = (bool)(arg1)->Destroy(arg2);
41161 wxPyEndAllowThreads(__tstate);
41162 if (PyErr_Occurred()) SWIG_fail;
41163 }
41164 {
41165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41166 }
41167 return resultobj;
41168 fail:
41169 return NULL;
41170 }
41171
41172
41173 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41174 PyObject *resultobj = 0;
41175 wxMenu *arg1 = (wxMenu *) 0 ;
41176 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
41177 bool result;
41178 void *argp1 = 0 ;
41179 int res1 = 0 ;
41180 void *argp2 = 0 ;
41181 int res2 = 0 ;
41182 PyObject * obj0 = 0 ;
41183 PyObject * obj1 = 0 ;
41184 char * kwnames[] = {
41185 (char *) "self",(char *) "item", NULL
41186 };
41187
41188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
41189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41190 if (!SWIG_IsOK(res1)) {
41191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41192 }
41193 arg1 = reinterpret_cast< wxMenu * >(argp1);
41194 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41195 if (!SWIG_IsOK(res2)) {
41196 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41197 }
41198 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41199 {
41200 PyThreadState* __tstate = wxPyBeginAllowThreads();
41201 result = (bool)(arg1)->Destroy(arg2);
41202 wxPyEndAllowThreads(__tstate);
41203 if (PyErr_Occurred()) SWIG_fail;
41204 }
41205 {
41206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41207 }
41208 return resultobj;
41209 fail:
41210 return NULL;
41211 }
41212
41213
41214 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41215 PyObject *resultobj = 0;
41216 wxMenu *arg1 = (wxMenu *) 0 ;
41217 size_t result;
41218 void *argp1 = 0 ;
41219 int res1 = 0 ;
41220 PyObject *swig_obj[1] ;
41221
41222 if (!args) SWIG_fail;
41223 swig_obj[0] = args;
41224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41225 if (!SWIG_IsOK(res1)) {
41226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
41227 }
41228 arg1 = reinterpret_cast< wxMenu * >(argp1);
41229 {
41230 PyThreadState* __tstate = wxPyBeginAllowThreads();
41231 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
41232 wxPyEndAllowThreads(__tstate);
41233 if (PyErr_Occurred()) SWIG_fail;
41234 }
41235 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41236 return resultobj;
41237 fail:
41238 return NULL;
41239 }
41240
41241
41242 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41243 PyObject *resultobj = 0;
41244 wxMenu *arg1 = (wxMenu *) 0 ;
41245 PyObject *result = 0 ;
41246 void *argp1 = 0 ;
41247 int res1 = 0 ;
41248 PyObject *swig_obj[1] ;
41249
41250 if (!args) SWIG_fail;
41251 swig_obj[0] = args;
41252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41253 if (!SWIG_IsOK(res1)) {
41254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
41255 }
41256 arg1 = reinterpret_cast< wxMenu * >(argp1);
41257 {
41258 PyThreadState* __tstate = wxPyBeginAllowThreads();
41259 result = (PyObject *)wxMenu_GetMenuItems(arg1);
41260 wxPyEndAllowThreads(__tstate);
41261 if (PyErr_Occurred()) SWIG_fail;
41262 }
41263 resultobj = result;
41264 return resultobj;
41265 fail:
41266 return NULL;
41267 }
41268
41269
41270 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41271 PyObject *resultobj = 0;
41272 wxMenu *arg1 = (wxMenu *) 0 ;
41273 wxString *arg2 = 0 ;
41274 int result;
41275 void *argp1 = 0 ;
41276 int res1 = 0 ;
41277 bool temp2 = false ;
41278 PyObject * obj0 = 0 ;
41279 PyObject * obj1 = 0 ;
41280 char * kwnames[] = {
41281 (char *) "self",(char *) "item", NULL
41282 };
41283
41284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
41285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41286 if (!SWIG_IsOK(res1)) {
41287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
41288 }
41289 arg1 = reinterpret_cast< wxMenu * >(argp1);
41290 {
41291 arg2 = wxString_in_helper(obj1);
41292 if (arg2 == NULL) SWIG_fail;
41293 temp2 = true;
41294 }
41295 {
41296 PyThreadState* __tstate = wxPyBeginAllowThreads();
41297 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
41298 wxPyEndAllowThreads(__tstate);
41299 if (PyErr_Occurred()) SWIG_fail;
41300 }
41301 resultobj = SWIG_From_int(static_cast< int >(result));
41302 {
41303 if (temp2)
41304 delete arg2;
41305 }
41306 return resultobj;
41307 fail:
41308 {
41309 if (temp2)
41310 delete arg2;
41311 }
41312 return NULL;
41313 }
41314
41315
41316 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41317 PyObject *resultobj = 0;
41318 wxMenu *arg1 = (wxMenu *) 0 ;
41319 int arg2 ;
41320 wxMenuItem *result = 0 ;
41321 void *argp1 = 0 ;
41322 int res1 = 0 ;
41323 int val2 ;
41324 int ecode2 = 0 ;
41325 PyObject * obj0 = 0 ;
41326 PyObject * obj1 = 0 ;
41327 char * kwnames[] = {
41328 (char *) "self",(char *) "id", NULL
41329 };
41330
41331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41333 if (!SWIG_IsOK(res1)) {
41334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
41335 }
41336 arg1 = reinterpret_cast< wxMenu * >(argp1);
41337 ecode2 = SWIG_AsVal_int(obj1, &val2);
41338 if (!SWIG_IsOK(ecode2)) {
41339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
41340 }
41341 arg2 = static_cast< int >(val2);
41342 {
41343 PyThreadState* __tstate = wxPyBeginAllowThreads();
41344 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
41345 wxPyEndAllowThreads(__tstate);
41346 if (PyErr_Occurred()) SWIG_fail;
41347 }
41348 {
41349 resultobj = wxPyMake_wxObject(result, (bool)0);
41350 }
41351 return resultobj;
41352 fail:
41353 return NULL;
41354 }
41355
41356
41357 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41358 PyObject *resultobj = 0;
41359 wxMenu *arg1 = (wxMenu *) 0 ;
41360 size_t arg2 ;
41361 wxMenuItem *result = 0 ;
41362 void *argp1 = 0 ;
41363 int res1 = 0 ;
41364 size_t val2 ;
41365 int ecode2 = 0 ;
41366 PyObject * obj0 = 0 ;
41367 PyObject * obj1 = 0 ;
41368 char * kwnames[] = {
41369 (char *) "self",(char *) "position", NULL
41370 };
41371
41372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
41373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41374 if (!SWIG_IsOK(res1)) {
41375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
41376 }
41377 arg1 = reinterpret_cast< wxMenu * >(argp1);
41378 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41379 if (!SWIG_IsOK(ecode2)) {
41380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
41381 }
41382 arg2 = static_cast< size_t >(val2);
41383 {
41384 PyThreadState* __tstate = wxPyBeginAllowThreads();
41385 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
41386 wxPyEndAllowThreads(__tstate);
41387 if (PyErr_Occurred()) SWIG_fail;
41388 }
41389 {
41390 resultobj = wxPyMake_wxObject(result, (bool)0);
41391 }
41392 return resultobj;
41393 fail:
41394 return NULL;
41395 }
41396
41397
41398 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41399 PyObject *resultobj = 0;
41400 wxMenu *arg1 = (wxMenu *) 0 ;
41401 int arg2 ;
41402 bool arg3 ;
41403 void *argp1 = 0 ;
41404 int res1 = 0 ;
41405 int val2 ;
41406 int ecode2 = 0 ;
41407 bool val3 ;
41408 int ecode3 = 0 ;
41409 PyObject * obj0 = 0 ;
41410 PyObject * obj1 = 0 ;
41411 PyObject * obj2 = 0 ;
41412 char * kwnames[] = {
41413 (char *) "self",(char *) "id",(char *) "enable", NULL
41414 };
41415
41416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41418 if (!SWIG_IsOK(res1)) {
41419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
41420 }
41421 arg1 = reinterpret_cast< wxMenu * >(argp1);
41422 ecode2 = SWIG_AsVal_int(obj1, &val2);
41423 if (!SWIG_IsOK(ecode2)) {
41424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
41425 }
41426 arg2 = static_cast< int >(val2);
41427 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41428 if (!SWIG_IsOK(ecode3)) {
41429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
41430 }
41431 arg3 = static_cast< bool >(val3);
41432 {
41433 PyThreadState* __tstate = wxPyBeginAllowThreads();
41434 (arg1)->Enable(arg2,arg3);
41435 wxPyEndAllowThreads(__tstate);
41436 if (PyErr_Occurred()) SWIG_fail;
41437 }
41438 resultobj = SWIG_Py_Void();
41439 return resultobj;
41440 fail:
41441 return NULL;
41442 }
41443
41444
41445 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41446 PyObject *resultobj = 0;
41447 wxMenu *arg1 = (wxMenu *) 0 ;
41448 int arg2 ;
41449 bool result;
41450 void *argp1 = 0 ;
41451 int res1 = 0 ;
41452 int val2 ;
41453 int ecode2 = 0 ;
41454 PyObject * obj0 = 0 ;
41455 PyObject * obj1 = 0 ;
41456 char * kwnames[] = {
41457 (char *) "self",(char *) "id", NULL
41458 };
41459
41460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41462 if (!SWIG_IsOK(res1)) {
41463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
41464 }
41465 arg1 = reinterpret_cast< wxMenu * >(argp1);
41466 ecode2 = SWIG_AsVal_int(obj1, &val2);
41467 if (!SWIG_IsOK(ecode2)) {
41468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41469 }
41470 arg2 = static_cast< int >(val2);
41471 {
41472 PyThreadState* __tstate = wxPyBeginAllowThreads();
41473 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
41474 wxPyEndAllowThreads(__tstate);
41475 if (PyErr_Occurred()) SWIG_fail;
41476 }
41477 {
41478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41479 }
41480 return resultobj;
41481 fail:
41482 return NULL;
41483 }
41484
41485
41486 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41487 PyObject *resultobj = 0;
41488 wxMenu *arg1 = (wxMenu *) 0 ;
41489 int arg2 ;
41490 bool arg3 ;
41491 void *argp1 = 0 ;
41492 int res1 = 0 ;
41493 int val2 ;
41494 int ecode2 = 0 ;
41495 bool val3 ;
41496 int ecode3 = 0 ;
41497 PyObject * obj0 = 0 ;
41498 PyObject * obj1 = 0 ;
41499 PyObject * obj2 = 0 ;
41500 char * kwnames[] = {
41501 (char *) "self",(char *) "id",(char *) "check", NULL
41502 };
41503
41504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41506 if (!SWIG_IsOK(res1)) {
41507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
41508 }
41509 arg1 = reinterpret_cast< wxMenu * >(argp1);
41510 ecode2 = SWIG_AsVal_int(obj1, &val2);
41511 if (!SWIG_IsOK(ecode2)) {
41512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
41513 }
41514 arg2 = static_cast< int >(val2);
41515 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41516 if (!SWIG_IsOK(ecode3)) {
41517 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
41518 }
41519 arg3 = static_cast< bool >(val3);
41520 {
41521 PyThreadState* __tstate = wxPyBeginAllowThreads();
41522 (arg1)->Check(arg2,arg3);
41523 wxPyEndAllowThreads(__tstate);
41524 if (PyErr_Occurred()) SWIG_fail;
41525 }
41526 resultobj = SWIG_Py_Void();
41527 return resultobj;
41528 fail:
41529 return NULL;
41530 }
41531
41532
41533 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41534 PyObject *resultobj = 0;
41535 wxMenu *arg1 = (wxMenu *) 0 ;
41536 int arg2 ;
41537 bool result;
41538 void *argp1 = 0 ;
41539 int res1 = 0 ;
41540 int val2 ;
41541 int ecode2 = 0 ;
41542 PyObject * obj0 = 0 ;
41543 PyObject * obj1 = 0 ;
41544 char * kwnames[] = {
41545 (char *) "self",(char *) "id", NULL
41546 };
41547
41548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41550 if (!SWIG_IsOK(res1)) {
41551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
41552 }
41553 arg1 = reinterpret_cast< wxMenu * >(argp1);
41554 ecode2 = SWIG_AsVal_int(obj1, &val2);
41555 if (!SWIG_IsOK(ecode2)) {
41556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
41557 }
41558 arg2 = static_cast< int >(val2);
41559 {
41560 PyThreadState* __tstate = wxPyBeginAllowThreads();
41561 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
41562 wxPyEndAllowThreads(__tstate);
41563 if (PyErr_Occurred()) SWIG_fail;
41564 }
41565 {
41566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41567 }
41568 return resultobj;
41569 fail:
41570 return NULL;
41571 }
41572
41573
41574 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41575 PyObject *resultobj = 0;
41576 wxMenu *arg1 = (wxMenu *) 0 ;
41577 int arg2 ;
41578 wxString *arg3 = 0 ;
41579 void *argp1 = 0 ;
41580 int res1 = 0 ;
41581 int val2 ;
41582 int ecode2 = 0 ;
41583 bool temp3 = false ;
41584 PyObject * obj0 = 0 ;
41585 PyObject * obj1 = 0 ;
41586 PyObject * obj2 = 0 ;
41587 char * kwnames[] = {
41588 (char *) "self",(char *) "id",(char *) "label", NULL
41589 };
41590
41591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41593 if (!SWIG_IsOK(res1)) {
41594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
41595 }
41596 arg1 = reinterpret_cast< wxMenu * >(argp1);
41597 ecode2 = SWIG_AsVal_int(obj1, &val2);
41598 if (!SWIG_IsOK(ecode2)) {
41599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
41600 }
41601 arg2 = static_cast< int >(val2);
41602 {
41603 arg3 = wxString_in_helper(obj2);
41604 if (arg3 == NULL) SWIG_fail;
41605 temp3 = true;
41606 }
41607 {
41608 PyThreadState* __tstate = wxPyBeginAllowThreads();
41609 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41610 wxPyEndAllowThreads(__tstate);
41611 if (PyErr_Occurred()) SWIG_fail;
41612 }
41613 resultobj = SWIG_Py_Void();
41614 {
41615 if (temp3)
41616 delete arg3;
41617 }
41618 return resultobj;
41619 fail:
41620 {
41621 if (temp3)
41622 delete arg3;
41623 }
41624 return NULL;
41625 }
41626
41627
41628 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41629 PyObject *resultobj = 0;
41630 wxMenu *arg1 = (wxMenu *) 0 ;
41631 int arg2 ;
41632 wxString result;
41633 void *argp1 = 0 ;
41634 int res1 = 0 ;
41635 int val2 ;
41636 int ecode2 = 0 ;
41637 PyObject * obj0 = 0 ;
41638 PyObject * obj1 = 0 ;
41639 char * kwnames[] = {
41640 (char *) "self",(char *) "id", NULL
41641 };
41642
41643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41645 if (!SWIG_IsOK(res1)) {
41646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
41647 }
41648 arg1 = reinterpret_cast< wxMenu * >(argp1);
41649 ecode2 = SWIG_AsVal_int(obj1, &val2);
41650 if (!SWIG_IsOK(ecode2)) {
41651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
41652 }
41653 arg2 = static_cast< int >(val2);
41654 {
41655 PyThreadState* __tstate = wxPyBeginAllowThreads();
41656 result = ((wxMenu const *)arg1)->GetLabel(arg2);
41657 wxPyEndAllowThreads(__tstate);
41658 if (PyErr_Occurred()) SWIG_fail;
41659 }
41660 {
41661 #if wxUSE_UNICODE
41662 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41663 #else
41664 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41665 #endif
41666 }
41667 return resultobj;
41668 fail:
41669 return NULL;
41670 }
41671
41672
41673 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41674 PyObject *resultobj = 0;
41675 wxMenu *arg1 = (wxMenu *) 0 ;
41676 int arg2 ;
41677 wxString *arg3 = 0 ;
41678 void *argp1 = 0 ;
41679 int res1 = 0 ;
41680 int val2 ;
41681 int ecode2 = 0 ;
41682 bool temp3 = false ;
41683 PyObject * obj0 = 0 ;
41684 PyObject * obj1 = 0 ;
41685 PyObject * obj2 = 0 ;
41686 char * kwnames[] = {
41687 (char *) "self",(char *) "id",(char *) "helpString", NULL
41688 };
41689
41690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41692 if (!SWIG_IsOK(res1)) {
41693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41694 }
41695 arg1 = reinterpret_cast< wxMenu * >(argp1);
41696 ecode2 = SWIG_AsVal_int(obj1, &val2);
41697 if (!SWIG_IsOK(ecode2)) {
41698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41699 }
41700 arg2 = static_cast< int >(val2);
41701 {
41702 arg3 = wxString_in_helper(obj2);
41703 if (arg3 == NULL) SWIG_fail;
41704 temp3 = true;
41705 }
41706 {
41707 PyThreadState* __tstate = wxPyBeginAllowThreads();
41708 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41709 wxPyEndAllowThreads(__tstate);
41710 if (PyErr_Occurred()) SWIG_fail;
41711 }
41712 resultobj = SWIG_Py_Void();
41713 {
41714 if (temp3)
41715 delete arg3;
41716 }
41717 return resultobj;
41718 fail:
41719 {
41720 if (temp3)
41721 delete arg3;
41722 }
41723 return NULL;
41724 }
41725
41726
41727 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41728 PyObject *resultobj = 0;
41729 wxMenu *arg1 = (wxMenu *) 0 ;
41730 int arg2 ;
41731 wxString result;
41732 void *argp1 = 0 ;
41733 int res1 = 0 ;
41734 int val2 ;
41735 int ecode2 = 0 ;
41736 PyObject * obj0 = 0 ;
41737 PyObject * obj1 = 0 ;
41738 char * kwnames[] = {
41739 (char *) "self",(char *) "id", NULL
41740 };
41741
41742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41744 if (!SWIG_IsOK(res1)) {
41745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41746 }
41747 arg1 = reinterpret_cast< wxMenu * >(argp1);
41748 ecode2 = SWIG_AsVal_int(obj1, &val2);
41749 if (!SWIG_IsOK(ecode2)) {
41750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41751 }
41752 arg2 = static_cast< int >(val2);
41753 {
41754 PyThreadState* __tstate = wxPyBeginAllowThreads();
41755 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41756 wxPyEndAllowThreads(__tstate);
41757 if (PyErr_Occurred()) SWIG_fail;
41758 }
41759 {
41760 #if wxUSE_UNICODE
41761 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41762 #else
41763 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41764 #endif
41765 }
41766 return resultobj;
41767 fail:
41768 return NULL;
41769 }
41770
41771
41772 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41773 PyObject *resultobj = 0;
41774 wxMenu *arg1 = (wxMenu *) 0 ;
41775 wxString *arg2 = 0 ;
41776 void *argp1 = 0 ;
41777 int res1 = 0 ;
41778 bool temp2 = false ;
41779 PyObject * obj0 = 0 ;
41780 PyObject * obj1 = 0 ;
41781 char * kwnames[] = {
41782 (char *) "self",(char *) "title", NULL
41783 };
41784
41785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41787 if (!SWIG_IsOK(res1)) {
41788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41789 }
41790 arg1 = reinterpret_cast< wxMenu * >(argp1);
41791 {
41792 arg2 = wxString_in_helper(obj1);
41793 if (arg2 == NULL) SWIG_fail;
41794 temp2 = true;
41795 }
41796 {
41797 PyThreadState* __tstate = wxPyBeginAllowThreads();
41798 (arg1)->SetTitle((wxString const &)*arg2);
41799 wxPyEndAllowThreads(__tstate);
41800 if (PyErr_Occurred()) SWIG_fail;
41801 }
41802 resultobj = SWIG_Py_Void();
41803 {
41804 if (temp2)
41805 delete arg2;
41806 }
41807 return resultobj;
41808 fail:
41809 {
41810 if (temp2)
41811 delete arg2;
41812 }
41813 return NULL;
41814 }
41815
41816
41817 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41818 PyObject *resultobj = 0;
41819 wxMenu *arg1 = (wxMenu *) 0 ;
41820 wxString result;
41821 void *argp1 = 0 ;
41822 int res1 = 0 ;
41823 PyObject *swig_obj[1] ;
41824
41825 if (!args) SWIG_fail;
41826 swig_obj[0] = args;
41827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41828 if (!SWIG_IsOK(res1)) {
41829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41830 }
41831 arg1 = reinterpret_cast< wxMenu * >(argp1);
41832 {
41833 PyThreadState* __tstate = wxPyBeginAllowThreads();
41834 result = ((wxMenu const *)arg1)->GetTitle();
41835 wxPyEndAllowThreads(__tstate);
41836 if (PyErr_Occurred()) SWIG_fail;
41837 }
41838 {
41839 #if wxUSE_UNICODE
41840 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41841 #else
41842 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41843 #endif
41844 }
41845 return resultobj;
41846 fail:
41847 return NULL;
41848 }
41849
41850
41851 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41852 PyObject *resultobj = 0;
41853 wxMenu *arg1 = (wxMenu *) 0 ;
41854 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41855 void *argp1 = 0 ;
41856 int res1 = 0 ;
41857 void *argp2 = 0 ;
41858 int res2 = 0 ;
41859 PyObject * obj0 = 0 ;
41860 PyObject * obj1 = 0 ;
41861 char * kwnames[] = {
41862 (char *) "self",(char *) "handler", NULL
41863 };
41864
41865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41867 if (!SWIG_IsOK(res1)) {
41868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41869 }
41870 arg1 = reinterpret_cast< wxMenu * >(argp1);
41871 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41872 if (!SWIG_IsOK(res2)) {
41873 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41874 }
41875 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41876 {
41877 PyThreadState* __tstate = wxPyBeginAllowThreads();
41878 (arg1)->SetEventHandler(arg2);
41879 wxPyEndAllowThreads(__tstate);
41880 if (PyErr_Occurred()) SWIG_fail;
41881 }
41882 resultobj = SWIG_Py_Void();
41883 return resultobj;
41884 fail:
41885 return NULL;
41886 }
41887
41888
41889 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41890 PyObject *resultobj = 0;
41891 wxMenu *arg1 = (wxMenu *) 0 ;
41892 wxEvtHandler *result = 0 ;
41893 void *argp1 = 0 ;
41894 int res1 = 0 ;
41895 PyObject *swig_obj[1] ;
41896
41897 if (!args) SWIG_fail;
41898 swig_obj[0] = args;
41899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41900 if (!SWIG_IsOK(res1)) {
41901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41902 }
41903 arg1 = reinterpret_cast< wxMenu * >(argp1);
41904 {
41905 PyThreadState* __tstate = wxPyBeginAllowThreads();
41906 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41907 wxPyEndAllowThreads(__tstate);
41908 if (PyErr_Occurred()) SWIG_fail;
41909 }
41910 {
41911 resultobj = wxPyMake_wxObject(result, 0);
41912 }
41913 return resultobj;
41914 fail:
41915 return NULL;
41916 }
41917
41918
41919 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41920 PyObject *resultobj = 0;
41921 wxMenu *arg1 = (wxMenu *) 0 ;
41922 wxWindow *arg2 = (wxWindow *) 0 ;
41923 void *argp1 = 0 ;
41924 int res1 = 0 ;
41925 void *argp2 = 0 ;
41926 int res2 = 0 ;
41927 PyObject * obj0 = 0 ;
41928 PyObject * obj1 = 0 ;
41929 char * kwnames[] = {
41930 (char *) "self",(char *) "win", NULL
41931 };
41932
41933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41935 if (!SWIG_IsOK(res1)) {
41936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41937 }
41938 arg1 = reinterpret_cast< wxMenu * >(argp1);
41939 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41940 if (!SWIG_IsOK(res2)) {
41941 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41942 }
41943 arg2 = reinterpret_cast< wxWindow * >(argp2);
41944 {
41945 PyThreadState* __tstate = wxPyBeginAllowThreads();
41946 (arg1)->SetInvokingWindow(arg2);
41947 wxPyEndAllowThreads(__tstate);
41948 if (PyErr_Occurred()) SWIG_fail;
41949 }
41950 resultobj = SWIG_Py_Void();
41951 return resultobj;
41952 fail:
41953 return NULL;
41954 }
41955
41956
41957 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41958 PyObject *resultobj = 0;
41959 wxMenu *arg1 = (wxMenu *) 0 ;
41960 wxWindow *result = 0 ;
41961 void *argp1 = 0 ;
41962 int res1 = 0 ;
41963 PyObject *swig_obj[1] ;
41964
41965 if (!args) SWIG_fail;
41966 swig_obj[0] = args;
41967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41968 if (!SWIG_IsOK(res1)) {
41969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41970 }
41971 arg1 = reinterpret_cast< wxMenu * >(argp1);
41972 {
41973 PyThreadState* __tstate = wxPyBeginAllowThreads();
41974 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
41975 wxPyEndAllowThreads(__tstate);
41976 if (PyErr_Occurred()) SWIG_fail;
41977 }
41978 {
41979 resultobj = wxPyMake_wxObject(result, 0);
41980 }
41981 return resultobj;
41982 fail:
41983 return NULL;
41984 }
41985
41986
41987 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41988 PyObject *resultobj = 0;
41989 wxMenu *arg1 = (wxMenu *) 0 ;
41990 long result;
41991 void *argp1 = 0 ;
41992 int res1 = 0 ;
41993 PyObject *swig_obj[1] ;
41994
41995 if (!args) SWIG_fail;
41996 swig_obj[0] = args;
41997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41998 if (!SWIG_IsOK(res1)) {
41999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
42000 }
42001 arg1 = reinterpret_cast< wxMenu * >(argp1);
42002 {
42003 PyThreadState* __tstate = wxPyBeginAllowThreads();
42004 result = (long)((wxMenu const *)arg1)->GetStyle();
42005 wxPyEndAllowThreads(__tstate);
42006 if (PyErr_Occurred()) SWIG_fail;
42007 }
42008 resultobj = SWIG_From_long(static_cast< long >(result));
42009 return resultobj;
42010 fail:
42011 return NULL;
42012 }
42013
42014
42015 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42016 PyObject *resultobj = 0;
42017 wxMenu *arg1 = (wxMenu *) 0 ;
42018 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
42019 void *argp1 = 0 ;
42020 int res1 = 0 ;
42021 void *argp2 = 0 ;
42022 int res2 = 0 ;
42023 PyObject * obj0 = 0 ;
42024 PyObject * obj1 = 0 ;
42025 char * kwnames[] = {
42026 (char *) "self",(char *) "source", NULL
42027 };
42028
42029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
42030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42031 if (!SWIG_IsOK(res1)) {
42032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
42033 }
42034 arg1 = reinterpret_cast< wxMenu * >(argp1);
42035 if (obj1) {
42036 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
42037 if (!SWIG_IsOK(res2)) {
42038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
42039 }
42040 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
42041 }
42042 {
42043 PyThreadState* __tstate = wxPyBeginAllowThreads();
42044 (arg1)->UpdateUI(arg2);
42045 wxPyEndAllowThreads(__tstate);
42046 if (PyErr_Occurred()) SWIG_fail;
42047 }
42048 resultobj = SWIG_Py_Void();
42049 return resultobj;
42050 fail:
42051 return NULL;
42052 }
42053
42054
42055 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42056 PyObject *resultobj = 0;
42057 wxMenu *arg1 = (wxMenu *) 0 ;
42058 wxMenuBar *result = 0 ;
42059 void *argp1 = 0 ;
42060 int res1 = 0 ;
42061 PyObject *swig_obj[1] ;
42062
42063 if (!args) SWIG_fail;
42064 swig_obj[0] = args;
42065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42066 if (!SWIG_IsOK(res1)) {
42067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
42068 }
42069 arg1 = reinterpret_cast< wxMenu * >(argp1);
42070 {
42071 PyThreadState* __tstate = wxPyBeginAllowThreads();
42072 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
42073 wxPyEndAllowThreads(__tstate);
42074 if (PyErr_Occurred()) SWIG_fail;
42075 }
42076 {
42077 resultobj = wxPyMake_wxObject(result, (bool)0);
42078 }
42079 return resultobj;
42080 fail:
42081 return NULL;
42082 }
42083
42084
42085 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42086 PyObject *resultobj = 0;
42087 wxMenu *arg1 = (wxMenu *) 0 ;
42088 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
42089 void *argp1 = 0 ;
42090 int res1 = 0 ;
42091 void *argp2 = 0 ;
42092 int res2 = 0 ;
42093 PyObject * obj0 = 0 ;
42094 PyObject * obj1 = 0 ;
42095 char * kwnames[] = {
42096 (char *) "self",(char *) "menubar", NULL
42097 };
42098
42099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42101 if (!SWIG_IsOK(res1)) {
42102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
42103 }
42104 arg1 = reinterpret_cast< wxMenu * >(argp1);
42105 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
42106 if (!SWIG_IsOK(res2)) {
42107 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
42108 }
42109 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
42110 {
42111 PyThreadState* __tstate = wxPyBeginAllowThreads();
42112 (arg1)->Attach(arg2);
42113 wxPyEndAllowThreads(__tstate);
42114 if (PyErr_Occurred()) SWIG_fail;
42115 }
42116 resultobj = SWIG_Py_Void();
42117 return resultobj;
42118 fail:
42119 return NULL;
42120 }
42121
42122
42123 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42124 PyObject *resultobj = 0;
42125 wxMenu *arg1 = (wxMenu *) 0 ;
42126 void *argp1 = 0 ;
42127 int res1 = 0 ;
42128 PyObject *swig_obj[1] ;
42129
42130 if (!args) SWIG_fail;
42131 swig_obj[0] = args;
42132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42133 if (!SWIG_IsOK(res1)) {
42134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
42135 }
42136 arg1 = reinterpret_cast< wxMenu * >(argp1);
42137 {
42138 PyThreadState* __tstate = wxPyBeginAllowThreads();
42139 (arg1)->Detach();
42140 wxPyEndAllowThreads(__tstate);
42141 if (PyErr_Occurred()) SWIG_fail;
42142 }
42143 resultobj = SWIG_Py_Void();
42144 return resultobj;
42145 fail:
42146 return NULL;
42147 }
42148
42149
42150 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42151 PyObject *resultobj = 0;
42152 wxMenu *arg1 = (wxMenu *) 0 ;
42153 bool result;
42154 void *argp1 = 0 ;
42155 int res1 = 0 ;
42156 PyObject *swig_obj[1] ;
42157
42158 if (!args) SWIG_fail;
42159 swig_obj[0] = args;
42160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42161 if (!SWIG_IsOK(res1)) {
42162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
42163 }
42164 arg1 = reinterpret_cast< wxMenu * >(argp1);
42165 {
42166 PyThreadState* __tstate = wxPyBeginAllowThreads();
42167 result = (bool)((wxMenu const *)arg1)->IsAttached();
42168 wxPyEndAllowThreads(__tstate);
42169 if (PyErr_Occurred()) SWIG_fail;
42170 }
42171 {
42172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42173 }
42174 return resultobj;
42175 fail:
42176 return NULL;
42177 }
42178
42179
42180 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42181 PyObject *resultobj = 0;
42182 wxMenu *arg1 = (wxMenu *) 0 ;
42183 wxMenu *arg2 = (wxMenu *) 0 ;
42184 void *argp1 = 0 ;
42185 int res1 = 0 ;
42186 void *argp2 = 0 ;
42187 int res2 = 0 ;
42188 PyObject * obj0 = 0 ;
42189 PyObject * obj1 = 0 ;
42190 char * kwnames[] = {
42191 (char *) "self",(char *) "parent", NULL
42192 };
42193
42194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
42195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42196 if (!SWIG_IsOK(res1)) {
42197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
42198 }
42199 arg1 = reinterpret_cast< wxMenu * >(argp1);
42200 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42201 if (!SWIG_IsOK(res2)) {
42202 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
42203 }
42204 arg2 = reinterpret_cast< wxMenu * >(argp2);
42205 {
42206 PyThreadState* __tstate = wxPyBeginAllowThreads();
42207 (arg1)->SetParent(arg2);
42208 wxPyEndAllowThreads(__tstate);
42209 if (PyErr_Occurred()) SWIG_fail;
42210 }
42211 resultobj = SWIG_Py_Void();
42212 return resultobj;
42213 fail:
42214 return NULL;
42215 }
42216
42217
42218 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42219 PyObject *resultobj = 0;
42220 wxMenu *arg1 = (wxMenu *) 0 ;
42221 wxMenu *result = 0 ;
42222 void *argp1 = 0 ;
42223 int res1 = 0 ;
42224 PyObject *swig_obj[1] ;
42225
42226 if (!args) SWIG_fail;
42227 swig_obj[0] = args;
42228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42229 if (!SWIG_IsOK(res1)) {
42230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
42231 }
42232 arg1 = reinterpret_cast< wxMenu * >(argp1);
42233 {
42234 PyThreadState* __tstate = wxPyBeginAllowThreads();
42235 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
42236 wxPyEndAllowThreads(__tstate);
42237 if (PyErr_Occurred()) SWIG_fail;
42238 }
42239 {
42240 resultobj = wxPyMake_wxObject(result, 0);
42241 }
42242 return resultobj;
42243 fail:
42244 return NULL;
42245 }
42246
42247
42248 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42249 PyObject *obj;
42250 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42251 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
42252 return SWIG_Py_Void();
42253 }
42254
42255 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42256 return SWIG_Python_InitShadowInstance(args);
42257 }
42258
42259 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42260 PyObject *resultobj = 0;
42261 long arg1 = (long) 0 ;
42262 wxMenuBar *result = 0 ;
42263 long val1 ;
42264 int ecode1 = 0 ;
42265 PyObject * obj0 = 0 ;
42266 char * kwnames[] = {
42267 (char *) "style", NULL
42268 };
42269
42270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
42271 if (obj0) {
42272 ecode1 = SWIG_AsVal_long(obj0, &val1);
42273 if (!SWIG_IsOK(ecode1)) {
42274 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
42275 }
42276 arg1 = static_cast< long >(val1);
42277 }
42278 {
42279 if (!wxPyCheckForApp()) SWIG_fail;
42280 PyThreadState* __tstate = wxPyBeginAllowThreads();
42281 result = (wxMenuBar *)new wxMenuBar(arg1);
42282 wxPyEndAllowThreads(__tstate);
42283 if (PyErr_Occurred()) SWIG_fail;
42284 }
42285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
42286 return resultobj;
42287 fail:
42288 return NULL;
42289 }
42290
42291
42292 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42293 PyObject *resultobj = 0;
42294 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42295 wxMenu *arg2 = (wxMenu *) 0 ;
42296 wxString *arg3 = 0 ;
42297 bool result;
42298 void *argp1 = 0 ;
42299 int res1 = 0 ;
42300 void *argp2 = 0 ;
42301 int res2 = 0 ;
42302 bool temp3 = false ;
42303 PyObject * obj0 = 0 ;
42304 PyObject * obj1 = 0 ;
42305 PyObject * obj2 = 0 ;
42306 char * kwnames[] = {
42307 (char *) "self",(char *) "menu",(char *) "title", NULL
42308 };
42309
42310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42312 if (!SWIG_IsOK(res1)) {
42313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42314 }
42315 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42316 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42317 if (!SWIG_IsOK(res2)) {
42318 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
42319 }
42320 arg2 = reinterpret_cast< wxMenu * >(argp2);
42321 {
42322 arg3 = wxString_in_helper(obj2);
42323 if (arg3 == NULL) SWIG_fail;
42324 temp3 = true;
42325 }
42326 {
42327 PyThreadState* __tstate = wxPyBeginAllowThreads();
42328 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
42329 wxPyEndAllowThreads(__tstate);
42330 if (PyErr_Occurred()) SWIG_fail;
42331 }
42332 {
42333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42334 }
42335 {
42336 if (temp3)
42337 delete arg3;
42338 }
42339 return resultobj;
42340 fail:
42341 {
42342 if (temp3)
42343 delete arg3;
42344 }
42345 return NULL;
42346 }
42347
42348
42349 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42350 PyObject *resultobj = 0;
42351 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42352 size_t arg2 ;
42353 wxMenu *arg3 = (wxMenu *) 0 ;
42354 wxString *arg4 = 0 ;
42355 bool result;
42356 void *argp1 = 0 ;
42357 int res1 = 0 ;
42358 size_t val2 ;
42359 int ecode2 = 0 ;
42360 void *argp3 = 0 ;
42361 int res3 = 0 ;
42362 bool temp4 = false ;
42363 PyObject * obj0 = 0 ;
42364 PyObject * obj1 = 0 ;
42365 PyObject * obj2 = 0 ;
42366 PyObject * obj3 = 0 ;
42367 char * kwnames[] = {
42368 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42369 };
42370
42371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42373 if (!SWIG_IsOK(res1)) {
42374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42375 }
42376 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42377 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42378 if (!SWIG_IsOK(ecode2)) {
42379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
42380 }
42381 arg2 = static_cast< size_t >(val2);
42382 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42383 if (!SWIG_IsOK(res3)) {
42384 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
42385 }
42386 arg3 = reinterpret_cast< wxMenu * >(argp3);
42387 {
42388 arg4 = wxString_in_helper(obj3);
42389 if (arg4 == NULL) SWIG_fail;
42390 temp4 = true;
42391 }
42392 {
42393 PyThreadState* __tstate = wxPyBeginAllowThreads();
42394 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
42395 wxPyEndAllowThreads(__tstate);
42396 if (PyErr_Occurred()) SWIG_fail;
42397 }
42398 {
42399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42400 }
42401 {
42402 if (temp4)
42403 delete arg4;
42404 }
42405 return resultobj;
42406 fail:
42407 {
42408 if (temp4)
42409 delete arg4;
42410 }
42411 return NULL;
42412 }
42413
42414
42415 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42416 PyObject *resultobj = 0;
42417 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42418 size_t result;
42419 void *argp1 = 0 ;
42420 int res1 = 0 ;
42421 PyObject *swig_obj[1] ;
42422
42423 if (!args) SWIG_fail;
42424 swig_obj[0] = args;
42425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42426 if (!SWIG_IsOK(res1)) {
42427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42428 }
42429 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42430 {
42431 PyThreadState* __tstate = wxPyBeginAllowThreads();
42432 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
42433 wxPyEndAllowThreads(__tstate);
42434 if (PyErr_Occurred()) SWIG_fail;
42435 }
42436 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
42437 return resultobj;
42438 fail:
42439 return NULL;
42440 }
42441
42442
42443 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42444 PyObject *resultobj = 0;
42445 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42446 size_t arg2 ;
42447 wxMenu *result = 0 ;
42448 void *argp1 = 0 ;
42449 int res1 = 0 ;
42450 size_t val2 ;
42451 int ecode2 = 0 ;
42452 PyObject * obj0 = 0 ;
42453 PyObject * obj1 = 0 ;
42454 char * kwnames[] = {
42455 (char *) "self",(char *) "pos", NULL
42456 };
42457
42458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42460 if (!SWIG_IsOK(res1)) {
42461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42462 }
42463 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42464 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42465 if (!SWIG_IsOK(ecode2)) {
42466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
42467 }
42468 arg2 = static_cast< size_t >(val2);
42469 {
42470 PyThreadState* __tstate = wxPyBeginAllowThreads();
42471 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
42472 wxPyEndAllowThreads(__tstate);
42473 if (PyErr_Occurred()) SWIG_fail;
42474 }
42475 {
42476 resultobj = wxPyMake_wxObject(result, 0);
42477 }
42478 return resultobj;
42479 fail:
42480 return NULL;
42481 }
42482
42483
42484 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42485 PyObject *resultobj = 0;
42486 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42487 size_t arg2 ;
42488 wxMenu *arg3 = (wxMenu *) 0 ;
42489 wxString *arg4 = 0 ;
42490 wxMenu *result = 0 ;
42491 void *argp1 = 0 ;
42492 int res1 = 0 ;
42493 size_t val2 ;
42494 int ecode2 = 0 ;
42495 void *argp3 = 0 ;
42496 int res3 = 0 ;
42497 bool temp4 = false ;
42498 PyObject * obj0 = 0 ;
42499 PyObject * obj1 = 0 ;
42500 PyObject * obj2 = 0 ;
42501 PyObject * obj3 = 0 ;
42502 char * kwnames[] = {
42503 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42504 };
42505
42506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42508 if (!SWIG_IsOK(res1)) {
42509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42510 }
42511 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42512 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42513 if (!SWIG_IsOK(ecode2)) {
42514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
42515 }
42516 arg2 = static_cast< size_t >(val2);
42517 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42518 if (!SWIG_IsOK(res3)) {
42519 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
42520 }
42521 arg3 = reinterpret_cast< wxMenu * >(argp3);
42522 {
42523 arg4 = wxString_in_helper(obj3);
42524 if (arg4 == NULL) SWIG_fail;
42525 temp4 = true;
42526 }
42527 {
42528 PyThreadState* __tstate = wxPyBeginAllowThreads();
42529 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
42530 wxPyEndAllowThreads(__tstate);
42531 if (PyErr_Occurred()) SWIG_fail;
42532 }
42533 {
42534 resultobj = wxPyMake_wxObject(result, 0);
42535 }
42536 {
42537 if (temp4)
42538 delete arg4;
42539 }
42540 return resultobj;
42541 fail:
42542 {
42543 if (temp4)
42544 delete arg4;
42545 }
42546 return NULL;
42547 }
42548
42549
42550 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42551 PyObject *resultobj = 0;
42552 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42553 size_t arg2 ;
42554 wxMenu *result = 0 ;
42555 void *argp1 = 0 ;
42556 int res1 = 0 ;
42557 size_t val2 ;
42558 int ecode2 = 0 ;
42559 PyObject * obj0 = 0 ;
42560 PyObject * obj1 = 0 ;
42561 char * kwnames[] = {
42562 (char *) "self",(char *) "pos", NULL
42563 };
42564
42565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
42566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42567 if (!SWIG_IsOK(res1)) {
42568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42569 }
42570 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42571 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42572 if (!SWIG_IsOK(ecode2)) {
42573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
42574 }
42575 arg2 = static_cast< size_t >(val2);
42576 {
42577 PyThreadState* __tstate = wxPyBeginAllowThreads();
42578 result = (wxMenu *)(arg1)->Remove(arg2);
42579 wxPyEndAllowThreads(__tstate);
42580 if (PyErr_Occurred()) SWIG_fail;
42581 }
42582 {
42583 resultobj = wxPyMake_wxObject(result, 0);
42584 }
42585 return resultobj;
42586 fail:
42587 return NULL;
42588 }
42589
42590
42591 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42592 PyObject *resultobj = 0;
42593 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42594 size_t arg2 ;
42595 bool arg3 ;
42596 void *argp1 = 0 ;
42597 int res1 = 0 ;
42598 size_t val2 ;
42599 int ecode2 = 0 ;
42600 bool val3 ;
42601 int ecode3 = 0 ;
42602 PyObject * obj0 = 0 ;
42603 PyObject * obj1 = 0 ;
42604 PyObject * obj2 = 0 ;
42605 char * kwnames[] = {
42606 (char *) "self",(char *) "pos",(char *) "enable", NULL
42607 };
42608
42609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42611 if (!SWIG_IsOK(res1)) {
42612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42613 }
42614 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42615 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42616 if (!SWIG_IsOK(ecode2)) {
42617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
42618 }
42619 arg2 = static_cast< size_t >(val2);
42620 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42621 if (!SWIG_IsOK(ecode3)) {
42622 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
42623 }
42624 arg3 = static_cast< bool >(val3);
42625 {
42626 PyThreadState* __tstate = wxPyBeginAllowThreads();
42627 (arg1)->EnableTop(arg2,arg3);
42628 wxPyEndAllowThreads(__tstate);
42629 if (PyErr_Occurred()) SWIG_fail;
42630 }
42631 resultobj = SWIG_Py_Void();
42632 return resultobj;
42633 fail:
42634 return NULL;
42635 }
42636
42637
42638 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42639 PyObject *resultobj = 0;
42640 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42641 size_t arg2 ;
42642 bool result;
42643 void *argp1 = 0 ;
42644 int res1 = 0 ;
42645 size_t val2 ;
42646 int ecode2 = 0 ;
42647 PyObject * obj0 = 0 ;
42648 PyObject * obj1 = 0 ;
42649 char * kwnames[] = {
42650 (char *) "self",(char *) "pos", NULL
42651 };
42652
42653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
42654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42655 if (!SWIG_IsOK(res1)) {
42656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42657 }
42658 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42659 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42660 if (!SWIG_IsOK(ecode2)) {
42661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
42662 }
42663 arg2 = static_cast< size_t >(val2);
42664 {
42665 PyThreadState* __tstate = wxPyBeginAllowThreads();
42666 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
42667 wxPyEndAllowThreads(__tstate);
42668 if (PyErr_Occurred()) SWIG_fail;
42669 }
42670 {
42671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42672 }
42673 return resultobj;
42674 fail:
42675 return NULL;
42676 }
42677
42678
42679 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42680 PyObject *resultobj = 0;
42681 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42682 size_t arg2 ;
42683 wxString *arg3 = 0 ;
42684 void *argp1 = 0 ;
42685 int res1 = 0 ;
42686 size_t val2 ;
42687 int ecode2 = 0 ;
42688 bool temp3 = false ;
42689 PyObject * obj0 = 0 ;
42690 PyObject * obj1 = 0 ;
42691 PyObject * obj2 = 0 ;
42692 char * kwnames[] = {
42693 (char *) "self",(char *) "pos",(char *) "label", NULL
42694 };
42695
42696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42698 if (!SWIG_IsOK(res1)) {
42699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42700 }
42701 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42702 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42703 if (!SWIG_IsOK(ecode2)) {
42704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42705 }
42706 arg2 = static_cast< size_t >(val2);
42707 {
42708 arg3 = wxString_in_helper(obj2);
42709 if (arg3 == NULL) SWIG_fail;
42710 temp3 = true;
42711 }
42712 {
42713 PyThreadState* __tstate = wxPyBeginAllowThreads();
42714 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42715 wxPyEndAllowThreads(__tstate);
42716 if (PyErr_Occurred()) SWIG_fail;
42717 }
42718 resultobj = SWIG_Py_Void();
42719 {
42720 if (temp3)
42721 delete arg3;
42722 }
42723 return resultobj;
42724 fail:
42725 {
42726 if (temp3)
42727 delete arg3;
42728 }
42729 return NULL;
42730 }
42731
42732
42733 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42734 PyObject *resultobj = 0;
42735 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42736 size_t arg2 ;
42737 wxString result;
42738 void *argp1 = 0 ;
42739 int res1 = 0 ;
42740 size_t val2 ;
42741 int ecode2 = 0 ;
42742 PyObject * obj0 = 0 ;
42743 PyObject * obj1 = 0 ;
42744 char * kwnames[] = {
42745 (char *) "self",(char *) "pos", NULL
42746 };
42747
42748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42750 if (!SWIG_IsOK(res1)) {
42751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42752 }
42753 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42754 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42755 if (!SWIG_IsOK(ecode2)) {
42756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42757 }
42758 arg2 = static_cast< size_t >(val2);
42759 {
42760 PyThreadState* __tstate = wxPyBeginAllowThreads();
42761 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42762 wxPyEndAllowThreads(__tstate);
42763 if (PyErr_Occurred()) SWIG_fail;
42764 }
42765 {
42766 #if wxUSE_UNICODE
42767 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42768 #else
42769 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42770 #endif
42771 }
42772 return resultobj;
42773 fail:
42774 return NULL;
42775 }
42776
42777
42778 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42779 PyObject *resultobj = 0;
42780 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42781 wxString *arg2 = 0 ;
42782 wxString *arg3 = 0 ;
42783 int result;
42784 void *argp1 = 0 ;
42785 int res1 = 0 ;
42786 bool temp2 = false ;
42787 bool temp3 = false ;
42788 PyObject * obj0 = 0 ;
42789 PyObject * obj1 = 0 ;
42790 PyObject * obj2 = 0 ;
42791 char * kwnames[] = {
42792 (char *) "self",(char *) "menu",(char *) "item", NULL
42793 };
42794
42795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42797 if (!SWIG_IsOK(res1)) {
42798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42799 }
42800 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42801 {
42802 arg2 = wxString_in_helper(obj1);
42803 if (arg2 == NULL) SWIG_fail;
42804 temp2 = true;
42805 }
42806 {
42807 arg3 = wxString_in_helper(obj2);
42808 if (arg3 == NULL) SWIG_fail;
42809 temp3 = true;
42810 }
42811 {
42812 PyThreadState* __tstate = wxPyBeginAllowThreads();
42813 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42814 wxPyEndAllowThreads(__tstate);
42815 if (PyErr_Occurred()) SWIG_fail;
42816 }
42817 resultobj = SWIG_From_int(static_cast< int >(result));
42818 {
42819 if (temp2)
42820 delete arg2;
42821 }
42822 {
42823 if (temp3)
42824 delete arg3;
42825 }
42826 return resultobj;
42827 fail:
42828 {
42829 if (temp2)
42830 delete arg2;
42831 }
42832 {
42833 if (temp3)
42834 delete arg3;
42835 }
42836 return NULL;
42837 }
42838
42839
42840 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42841 PyObject *resultobj = 0;
42842 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42843 int arg2 ;
42844 wxMenuItem *result = 0 ;
42845 void *argp1 = 0 ;
42846 int res1 = 0 ;
42847 int val2 ;
42848 int ecode2 = 0 ;
42849 PyObject * obj0 = 0 ;
42850 PyObject * obj1 = 0 ;
42851 char * kwnames[] = {
42852 (char *) "self",(char *) "id", NULL
42853 };
42854
42855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42857 if (!SWIG_IsOK(res1)) {
42858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42859 }
42860 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42861 ecode2 = SWIG_AsVal_int(obj1, &val2);
42862 if (!SWIG_IsOK(ecode2)) {
42863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42864 }
42865 arg2 = static_cast< int >(val2);
42866 {
42867 PyThreadState* __tstate = wxPyBeginAllowThreads();
42868 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42869 wxPyEndAllowThreads(__tstate);
42870 if (PyErr_Occurred()) SWIG_fail;
42871 }
42872 {
42873 resultobj = wxPyMake_wxObject(result, (bool)0);
42874 }
42875 return resultobj;
42876 fail:
42877 return NULL;
42878 }
42879
42880
42881 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42882 PyObject *resultobj = 0;
42883 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42884 wxString *arg2 = 0 ;
42885 int result;
42886 void *argp1 = 0 ;
42887 int res1 = 0 ;
42888 bool temp2 = false ;
42889 PyObject * obj0 = 0 ;
42890 PyObject * obj1 = 0 ;
42891 char * kwnames[] = {
42892 (char *) "self",(char *) "title", NULL
42893 };
42894
42895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42897 if (!SWIG_IsOK(res1)) {
42898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42899 }
42900 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42901 {
42902 arg2 = wxString_in_helper(obj1);
42903 if (arg2 == NULL) SWIG_fail;
42904 temp2 = true;
42905 }
42906 {
42907 PyThreadState* __tstate = wxPyBeginAllowThreads();
42908 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42909 wxPyEndAllowThreads(__tstate);
42910 if (PyErr_Occurred()) SWIG_fail;
42911 }
42912 resultobj = SWIG_From_int(static_cast< int >(result));
42913 {
42914 if (temp2)
42915 delete arg2;
42916 }
42917 return resultobj;
42918 fail:
42919 {
42920 if (temp2)
42921 delete arg2;
42922 }
42923 return NULL;
42924 }
42925
42926
42927 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42928 PyObject *resultobj = 0;
42929 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42930 int arg2 ;
42931 bool arg3 ;
42932 void *argp1 = 0 ;
42933 int res1 = 0 ;
42934 int val2 ;
42935 int ecode2 = 0 ;
42936 bool val3 ;
42937 int ecode3 = 0 ;
42938 PyObject * obj0 = 0 ;
42939 PyObject * obj1 = 0 ;
42940 PyObject * obj2 = 0 ;
42941 char * kwnames[] = {
42942 (char *) "self",(char *) "id",(char *) "enable", NULL
42943 };
42944
42945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42947 if (!SWIG_IsOK(res1)) {
42948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42949 }
42950 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42951 ecode2 = SWIG_AsVal_int(obj1, &val2);
42952 if (!SWIG_IsOK(ecode2)) {
42953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42954 }
42955 arg2 = static_cast< int >(val2);
42956 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42957 if (!SWIG_IsOK(ecode3)) {
42958 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42959 }
42960 arg3 = static_cast< bool >(val3);
42961 {
42962 PyThreadState* __tstate = wxPyBeginAllowThreads();
42963 (arg1)->Enable(arg2,arg3);
42964 wxPyEndAllowThreads(__tstate);
42965 if (PyErr_Occurred()) SWIG_fail;
42966 }
42967 resultobj = SWIG_Py_Void();
42968 return resultobj;
42969 fail:
42970 return NULL;
42971 }
42972
42973
42974 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42975 PyObject *resultobj = 0;
42976 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42977 int arg2 ;
42978 bool arg3 ;
42979 void *argp1 = 0 ;
42980 int res1 = 0 ;
42981 int val2 ;
42982 int ecode2 = 0 ;
42983 bool val3 ;
42984 int ecode3 = 0 ;
42985 PyObject * obj0 = 0 ;
42986 PyObject * obj1 = 0 ;
42987 PyObject * obj2 = 0 ;
42988 char * kwnames[] = {
42989 (char *) "self",(char *) "id",(char *) "check", NULL
42990 };
42991
42992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42994 if (!SWIG_IsOK(res1)) {
42995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42996 }
42997 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42998 ecode2 = SWIG_AsVal_int(obj1, &val2);
42999 if (!SWIG_IsOK(ecode2)) {
43000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
43001 }
43002 arg2 = static_cast< int >(val2);
43003 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43004 if (!SWIG_IsOK(ecode3)) {
43005 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
43006 }
43007 arg3 = static_cast< bool >(val3);
43008 {
43009 PyThreadState* __tstate = wxPyBeginAllowThreads();
43010 (arg1)->Check(arg2,arg3);
43011 wxPyEndAllowThreads(__tstate);
43012 if (PyErr_Occurred()) SWIG_fail;
43013 }
43014 resultobj = SWIG_Py_Void();
43015 return resultobj;
43016 fail:
43017 return NULL;
43018 }
43019
43020
43021 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43022 PyObject *resultobj = 0;
43023 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43024 int arg2 ;
43025 bool result;
43026 void *argp1 = 0 ;
43027 int res1 = 0 ;
43028 int val2 ;
43029 int ecode2 = 0 ;
43030 PyObject * obj0 = 0 ;
43031 PyObject * obj1 = 0 ;
43032 char * kwnames[] = {
43033 (char *) "self",(char *) "id", NULL
43034 };
43035
43036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43038 if (!SWIG_IsOK(res1)) {
43039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43040 }
43041 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43042 ecode2 = SWIG_AsVal_int(obj1, &val2);
43043 if (!SWIG_IsOK(ecode2)) {
43044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
43045 }
43046 arg2 = static_cast< int >(val2);
43047 {
43048 PyThreadState* __tstate = wxPyBeginAllowThreads();
43049 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
43050 wxPyEndAllowThreads(__tstate);
43051 if (PyErr_Occurred()) SWIG_fail;
43052 }
43053 {
43054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43055 }
43056 return resultobj;
43057 fail:
43058 return NULL;
43059 }
43060
43061
43062 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43063 PyObject *resultobj = 0;
43064 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43065 int arg2 ;
43066 bool result;
43067 void *argp1 = 0 ;
43068 int res1 = 0 ;
43069 int val2 ;
43070 int ecode2 = 0 ;
43071 PyObject * obj0 = 0 ;
43072 PyObject * obj1 = 0 ;
43073 char * kwnames[] = {
43074 (char *) "self",(char *) "id", NULL
43075 };
43076
43077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43079 if (!SWIG_IsOK(res1)) {
43080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43081 }
43082 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43083 ecode2 = SWIG_AsVal_int(obj1, &val2);
43084 if (!SWIG_IsOK(ecode2)) {
43085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43086 }
43087 arg2 = static_cast< int >(val2);
43088 {
43089 PyThreadState* __tstate = wxPyBeginAllowThreads();
43090 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
43091 wxPyEndAllowThreads(__tstate);
43092 if (PyErr_Occurred()) SWIG_fail;
43093 }
43094 {
43095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43096 }
43097 return resultobj;
43098 fail:
43099 return NULL;
43100 }
43101
43102
43103 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43104 PyObject *resultobj = 0;
43105 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43106 int arg2 ;
43107 wxString *arg3 = 0 ;
43108 void *argp1 = 0 ;
43109 int res1 = 0 ;
43110 int val2 ;
43111 int ecode2 = 0 ;
43112 bool temp3 = false ;
43113 PyObject * obj0 = 0 ;
43114 PyObject * obj1 = 0 ;
43115 PyObject * obj2 = 0 ;
43116 char * kwnames[] = {
43117 (char *) "self",(char *) "id",(char *) "label", NULL
43118 };
43119
43120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43122 if (!SWIG_IsOK(res1)) {
43123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43124 }
43125 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43126 ecode2 = SWIG_AsVal_int(obj1, &val2);
43127 if (!SWIG_IsOK(ecode2)) {
43128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
43129 }
43130 arg2 = static_cast< int >(val2);
43131 {
43132 arg3 = wxString_in_helper(obj2);
43133 if (arg3 == NULL) SWIG_fail;
43134 temp3 = true;
43135 }
43136 {
43137 PyThreadState* __tstate = wxPyBeginAllowThreads();
43138 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43139 wxPyEndAllowThreads(__tstate);
43140 if (PyErr_Occurred()) SWIG_fail;
43141 }
43142 resultobj = SWIG_Py_Void();
43143 {
43144 if (temp3)
43145 delete arg3;
43146 }
43147 return resultobj;
43148 fail:
43149 {
43150 if (temp3)
43151 delete arg3;
43152 }
43153 return NULL;
43154 }
43155
43156
43157 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43158 PyObject *resultobj = 0;
43159 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43160 int arg2 ;
43161 wxString result;
43162 void *argp1 = 0 ;
43163 int res1 = 0 ;
43164 int val2 ;
43165 int ecode2 = 0 ;
43166 PyObject * obj0 = 0 ;
43167 PyObject * obj1 = 0 ;
43168 char * kwnames[] = {
43169 (char *) "self",(char *) "id", NULL
43170 };
43171
43172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43174 if (!SWIG_IsOK(res1)) {
43175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43176 }
43177 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43178 ecode2 = SWIG_AsVal_int(obj1, &val2);
43179 if (!SWIG_IsOK(ecode2)) {
43180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
43181 }
43182 arg2 = static_cast< int >(val2);
43183 {
43184 PyThreadState* __tstate = wxPyBeginAllowThreads();
43185 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
43186 wxPyEndAllowThreads(__tstate);
43187 if (PyErr_Occurred()) SWIG_fail;
43188 }
43189 {
43190 #if wxUSE_UNICODE
43191 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43192 #else
43193 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43194 #endif
43195 }
43196 return resultobj;
43197 fail:
43198 return NULL;
43199 }
43200
43201
43202 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43203 PyObject *resultobj = 0;
43204 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43205 int arg2 ;
43206 wxString *arg3 = 0 ;
43207 void *argp1 = 0 ;
43208 int res1 = 0 ;
43209 int val2 ;
43210 int ecode2 = 0 ;
43211 bool temp3 = false ;
43212 PyObject * obj0 = 0 ;
43213 PyObject * obj1 = 0 ;
43214 PyObject * obj2 = 0 ;
43215 char * kwnames[] = {
43216 (char *) "self",(char *) "id",(char *) "helpString", NULL
43217 };
43218
43219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43221 if (!SWIG_IsOK(res1)) {
43222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43223 }
43224 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43225 ecode2 = SWIG_AsVal_int(obj1, &val2);
43226 if (!SWIG_IsOK(ecode2)) {
43227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43228 }
43229 arg2 = static_cast< int >(val2);
43230 {
43231 arg3 = wxString_in_helper(obj2);
43232 if (arg3 == NULL) SWIG_fail;
43233 temp3 = true;
43234 }
43235 {
43236 PyThreadState* __tstate = wxPyBeginAllowThreads();
43237 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43238 wxPyEndAllowThreads(__tstate);
43239 if (PyErr_Occurred()) SWIG_fail;
43240 }
43241 resultobj = SWIG_Py_Void();
43242 {
43243 if (temp3)
43244 delete arg3;
43245 }
43246 return resultobj;
43247 fail:
43248 {
43249 if (temp3)
43250 delete arg3;
43251 }
43252 return NULL;
43253 }
43254
43255
43256 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43257 PyObject *resultobj = 0;
43258 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43259 int arg2 ;
43260 wxString result;
43261 void *argp1 = 0 ;
43262 int res1 = 0 ;
43263 int val2 ;
43264 int ecode2 = 0 ;
43265 PyObject * obj0 = 0 ;
43266 PyObject * obj1 = 0 ;
43267 char * kwnames[] = {
43268 (char *) "self",(char *) "id", NULL
43269 };
43270
43271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43273 if (!SWIG_IsOK(res1)) {
43274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43275 }
43276 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43277 ecode2 = SWIG_AsVal_int(obj1, &val2);
43278 if (!SWIG_IsOK(ecode2)) {
43279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43280 }
43281 arg2 = static_cast< int >(val2);
43282 {
43283 PyThreadState* __tstate = wxPyBeginAllowThreads();
43284 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
43285 wxPyEndAllowThreads(__tstate);
43286 if (PyErr_Occurred()) SWIG_fail;
43287 }
43288 {
43289 #if wxUSE_UNICODE
43290 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43291 #else
43292 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43293 #endif
43294 }
43295 return resultobj;
43296 fail:
43297 return NULL;
43298 }
43299
43300
43301 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43302 PyObject *resultobj = 0;
43303 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43304 wxFrame *result = 0 ;
43305 void *argp1 = 0 ;
43306 int res1 = 0 ;
43307 PyObject *swig_obj[1] ;
43308
43309 if (!args) SWIG_fail;
43310 swig_obj[0] = args;
43311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43312 if (!SWIG_IsOK(res1)) {
43313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43314 }
43315 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43316 {
43317 PyThreadState* __tstate = wxPyBeginAllowThreads();
43318 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
43319 wxPyEndAllowThreads(__tstate);
43320 if (PyErr_Occurred()) SWIG_fail;
43321 }
43322 {
43323 resultobj = wxPyMake_wxObject(result, (bool)0);
43324 }
43325 return resultobj;
43326 fail:
43327 return NULL;
43328 }
43329
43330
43331 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43332 PyObject *resultobj = 0;
43333 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43334 bool result;
43335 void *argp1 = 0 ;
43336 int res1 = 0 ;
43337 PyObject *swig_obj[1] ;
43338
43339 if (!args) SWIG_fail;
43340 swig_obj[0] = args;
43341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43342 if (!SWIG_IsOK(res1)) {
43343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43344 }
43345 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43346 {
43347 PyThreadState* __tstate = wxPyBeginAllowThreads();
43348 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
43349 wxPyEndAllowThreads(__tstate);
43350 if (PyErr_Occurred()) SWIG_fail;
43351 }
43352 {
43353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43354 }
43355 return resultobj;
43356 fail:
43357 return NULL;
43358 }
43359
43360
43361 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43362 PyObject *resultobj = 0;
43363 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43364 wxFrame *arg2 = (wxFrame *) 0 ;
43365 void *argp1 = 0 ;
43366 int res1 = 0 ;
43367 void *argp2 = 0 ;
43368 int res2 = 0 ;
43369 PyObject * obj0 = 0 ;
43370 PyObject * obj1 = 0 ;
43371 char * kwnames[] = {
43372 (char *) "self",(char *) "frame", NULL
43373 };
43374
43375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
43376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43377 if (!SWIG_IsOK(res1)) {
43378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43379 }
43380 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43381 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
43382 if (!SWIG_IsOK(res2)) {
43383 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
43384 }
43385 arg2 = reinterpret_cast< wxFrame * >(argp2);
43386 {
43387 PyThreadState* __tstate = wxPyBeginAllowThreads();
43388 (arg1)->Attach(arg2);
43389 wxPyEndAllowThreads(__tstate);
43390 if (PyErr_Occurred()) SWIG_fail;
43391 }
43392 resultobj = SWIG_Py_Void();
43393 return resultobj;
43394 fail:
43395 return NULL;
43396 }
43397
43398
43399 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43400 PyObject *resultobj = 0;
43401 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43402 void *argp1 = 0 ;
43403 int res1 = 0 ;
43404 PyObject *swig_obj[1] ;
43405
43406 if (!args) SWIG_fail;
43407 swig_obj[0] = args;
43408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43409 if (!SWIG_IsOK(res1)) {
43410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43411 }
43412 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43413 {
43414 PyThreadState* __tstate = wxPyBeginAllowThreads();
43415 (arg1)->Detach();
43416 wxPyEndAllowThreads(__tstate);
43417 if (PyErr_Occurred()) SWIG_fail;
43418 }
43419 resultobj = SWIG_Py_Void();
43420 return resultobj;
43421 fail:
43422 return NULL;
43423 }
43424
43425
43426 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43427 PyObject *resultobj = 0;
43428 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43429 void *argp1 = 0 ;
43430 int res1 = 0 ;
43431 PyObject *swig_obj[1] ;
43432
43433 if (!args) SWIG_fail;
43434 swig_obj[0] = args;
43435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43436 if (!SWIG_IsOK(res1)) {
43437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43438 }
43439 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43440 {
43441 PyThreadState* __tstate = wxPyBeginAllowThreads();
43442 (arg1)->UpdateMenus();
43443 wxPyEndAllowThreads(__tstate);
43444 if (PyErr_Occurred()) SWIG_fail;
43445 }
43446 resultobj = SWIG_Py_Void();
43447 return resultobj;
43448 fail:
43449 return NULL;
43450 }
43451
43452
43453 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43454 PyObject *resultobj = 0;
43455 bool arg1 ;
43456 bool val1 ;
43457 int ecode1 = 0 ;
43458 PyObject * obj0 = 0 ;
43459 char * kwnames[] = {
43460 (char *) "enable", NULL
43461 };
43462
43463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
43464 ecode1 = SWIG_AsVal_bool(obj0, &val1);
43465 if (!SWIG_IsOK(ecode1)) {
43466 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
43467 }
43468 arg1 = static_cast< bool >(val1);
43469 {
43470 PyThreadState* __tstate = wxPyBeginAllowThreads();
43471 wxMenuBar_SetAutoWindowMenu(arg1);
43472 wxPyEndAllowThreads(__tstate);
43473 if (PyErr_Occurred()) SWIG_fail;
43474 }
43475 resultobj = SWIG_Py_Void();
43476 return resultobj;
43477 fail:
43478 return NULL;
43479 }
43480
43481
43482 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43483 PyObject *resultobj = 0;
43484 bool result;
43485
43486 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
43487 {
43488 PyThreadState* __tstate = wxPyBeginAllowThreads();
43489 result = (bool)wxMenuBar_GetAutoWindowMenu();
43490 wxPyEndAllowThreads(__tstate);
43491 if (PyErr_Occurred()) SWIG_fail;
43492 }
43493 {
43494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43495 }
43496 return resultobj;
43497 fail:
43498 return NULL;
43499 }
43500
43501
43502 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43503 PyObject *obj;
43504 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43505 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
43506 return SWIG_Py_Void();
43507 }
43508
43509 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43510 return SWIG_Python_InitShadowInstance(args);
43511 }
43512
43513 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43514 PyObject *resultobj = 0;
43515 wxMenu *arg1 = (wxMenu *) NULL ;
43516 int arg2 = (int) wxID_ANY ;
43517 wxString const &arg3_defvalue = wxPyEmptyString ;
43518 wxString *arg3 = (wxString *) &arg3_defvalue ;
43519 wxString const &arg4_defvalue = wxPyEmptyString ;
43520 wxString *arg4 = (wxString *) &arg4_defvalue ;
43521 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43522 wxMenu *arg6 = (wxMenu *) NULL ;
43523 wxMenuItem *result = 0 ;
43524 void *argp1 = 0 ;
43525 int res1 = 0 ;
43526 int val2 ;
43527 int ecode2 = 0 ;
43528 bool temp3 = false ;
43529 bool temp4 = false ;
43530 int val5 ;
43531 int ecode5 = 0 ;
43532 void *argp6 = 0 ;
43533 int res6 = 0 ;
43534 PyObject * obj0 = 0 ;
43535 PyObject * obj1 = 0 ;
43536 PyObject * obj2 = 0 ;
43537 PyObject * obj3 = 0 ;
43538 PyObject * obj4 = 0 ;
43539 PyObject * obj5 = 0 ;
43540 char * kwnames[] = {
43541 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
43542 };
43543
43544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43545 if (obj0) {
43546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43547 if (!SWIG_IsOK(res1)) {
43548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43549 }
43550 arg1 = reinterpret_cast< wxMenu * >(argp1);
43551 }
43552 if (obj1) {
43553 ecode2 = SWIG_AsVal_int(obj1, &val2);
43554 if (!SWIG_IsOK(ecode2)) {
43555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
43556 }
43557 arg2 = static_cast< int >(val2);
43558 }
43559 if (obj2) {
43560 {
43561 arg3 = wxString_in_helper(obj2);
43562 if (arg3 == NULL) SWIG_fail;
43563 temp3 = true;
43564 }
43565 }
43566 if (obj3) {
43567 {
43568 arg4 = wxString_in_helper(obj3);
43569 if (arg4 == NULL) SWIG_fail;
43570 temp4 = true;
43571 }
43572 }
43573 if (obj4) {
43574 ecode5 = SWIG_AsVal_int(obj4, &val5);
43575 if (!SWIG_IsOK(ecode5)) {
43576 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
43577 }
43578 arg5 = static_cast< wxItemKind >(val5);
43579 }
43580 if (obj5) {
43581 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
43582 if (!SWIG_IsOK(res6)) {
43583 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
43584 }
43585 arg6 = reinterpret_cast< wxMenu * >(argp6);
43586 }
43587 {
43588 PyThreadState* __tstate = wxPyBeginAllowThreads();
43589 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
43590 wxPyEndAllowThreads(__tstate);
43591 if (PyErr_Occurred()) SWIG_fail;
43592 }
43593 {
43594 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
43595 }
43596 {
43597 if (temp3)
43598 delete arg3;
43599 }
43600 {
43601 if (temp4)
43602 delete arg4;
43603 }
43604 return resultobj;
43605 fail:
43606 {
43607 if (temp3)
43608 delete arg3;
43609 }
43610 {
43611 if (temp4)
43612 delete arg4;
43613 }
43614 return NULL;
43615 }
43616
43617
43618 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43619 PyObject *resultobj = 0;
43620 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43621 void *argp1 = 0 ;
43622 int res1 = 0 ;
43623 PyObject *swig_obj[1] ;
43624
43625 if (!args) SWIG_fail;
43626 swig_obj[0] = args;
43627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43628 if (!SWIG_IsOK(res1)) {
43629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43630 }
43631 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43632 {
43633 PyThreadState* __tstate = wxPyBeginAllowThreads();
43634 delete arg1;
43635
43636 wxPyEndAllowThreads(__tstate);
43637 if (PyErr_Occurred()) SWIG_fail;
43638 }
43639 resultobj = SWIG_Py_Void();
43640 return resultobj;
43641 fail:
43642 return NULL;
43643 }
43644
43645
43646 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43647 PyObject *resultobj = 0;
43648 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43649 wxMenu *result = 0 ;
43650 void *argp1 = 0 ;
43651 int res1 = 0 ;
43652 PyObject *swig_obj[1] ;
43653
43654 if (!args) SWIG_fail;
43655 swig_obj[0] = args;
43656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43657 if (!SWIG_IsOK(res1)) {
43658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43659 }
43660 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43661 {
43662 PyThreadState* __tstate = wxPyBeginAllowThreads();
43663 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
43664 wxPyEndAllowThreads(__tstate);
43665 if (PyErr_Occurred()) SWIG_fail;
43666 }
43667 {
43668 resultobj = wxPyMake_wxObject(result, 0);
43669 }
43670 return resultobj;
43671 fail:
43672 return NULL;
43673 }
43674
43675
43676 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43677 PyObject *resultobj = 0;
43678 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43679 wxMenu *arg2 = (wxMenu *) 0 ;
43680 void *argp1 = 0 ;
43681 int res1 = 0 ;
43682 void *argp2 = 0 ;
43683 int res2 = 0 ;
43684 PyObject * obj0 = 0 ;
43685 PyObject * obj1 = 0 ;
43686 char * kwnames[] = {
43687 (char *) "self",(char *) "menu", NULL
43688 };
43689
43690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43692 if (!SWIG_IsOK(res1)) {
43693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43694 }
43695 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43696 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43697 if (!SWIG_IsOK(res2)) {
43698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43699 }
43700 arg2 = reinterpret_cast< wxMenu * >(argp2);
43701 {
43702 PyThreadState* __tstate = wxPyBeginAllowThreads();
43703 (arg1)->SetMenu(arg2);
43704 wxPyEndAllowThreads(__tstate);
43705 if (PyErr_Occurred()) SWIG_fail;
43706 }
43707 resultobj = SWIG_Py_Void();
43708 return resultobj;
43709 fail:
43710 return NULL;
43711 }
43712
43713
43714 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43715 PyObject *resultobj = 0;
43716 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43717 int arg2 ;
43718 void *argp1 = 0 ;
43719 int res1 = 0 ;
43720 int val2 ;
43721 int ecode2 = 0 ;
43722 PyObject * obj0 = 0 ;
43723 PyObject * obj1 = 0 ;
43724 char * kwnames[] = {
43725 (char *) "self",(char *) "id", NULL
43726 };
43727
43728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43730 if (!SWIG_IsOK(res1)) {
43731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43732 }
43733 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43734 ecode2 = SWIG_AsVal_int(obj1, &val2);
43735 if (!SWIG_IsOK(ecode2)) {
43736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43737 }
43738 arg2 = static_cast< int >(val2);
43739 {
43740 PyThreadState* __tstate = wxPyBeginAllowThreads();
43741 (arg1)->SetId(arg2);
43742 wxPyEndAllowThreads(__tstate);
43743 if (PyErr_Occurred()) SWIG_fail;
43744 }
43745 resultobj = SWIG_Py_Void();
43746 return resultobj;
43747 fail:
43748 return NULL;
43749 }
43750
43751
43752 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43753 PyObject *resultobj = 0;
43754 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43755 int result;
43756 void *argp1 = 0 ;
43757 int res1 = 0 ;
43758 PyObject *swig_obj[1] ;
43759
43760 if (!args) SWIG_fail;
43761 swig_obj[0] = args;
43762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43763 if (!SWIG_IsOK(res1)) {
43764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43765 }
43766 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43767 {
43768 PyThreadState* __tstate = wxPyBeginAllowThreads();
43769 result = (int)((wxMenuItem const *)arg1)->GetId();
43770 wxPyEndAllowThreads(__tstate);
43771 if (PyErr_Occurred()) SWIG_fail;
43772 }
43773 resultobj = SWIG_From_int(static_cast< int >(result));
43774 return resultobj;
43775 fail:
43776 return NULL;
43777 }
43778
43779
43780 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43781 PyObject *resultobj = 0;
43782 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43783 bool result;
43784 void *argp1 = 0 ;
43785 int res1 = 0 ;
43786 PyObject *swig_obj[1] ;
43787
43788 if (!args) SWIG_fail;
43789 swig_obj[0] = args;
43790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43791 if (!SWIG_IsOK(res1)) {
43792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43793 }
43794 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43795 {
43796 PyThreadState* __tstate = wxPyBeginAllowThreads();
43797 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43798 wxPyEndAllowThreads(__tstate);
43799 if (PyErr_Occurred()) SWIG_fail;
43800 }
43801 {
43802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43803 }
43804 return resultobj;
43805 fail:
43806 return NULL;
43807 }
43808
43809
43810 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43811 PyObject *resultobj = 0;
43812 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43813 wxString *arg2 = 0 ;
43814 void *argp1 = 0 ;
43815 int res1 = 0 ;
43816 bool temp2 = false ;
43817 PyObject * obj0 = 0 ;
43818 PyObject * obj1 = 0 ;
43819 char * kwnames[] = {
43820 (char *) "self",(char *) "str", NULL
43821 };
43822
43823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43825 if (!SWIG_IsOK(res1)) {
43826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43827 }
43828 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43829 {
43830 arg2 = wxString_in_helper(obj1);
43831 if (arg2 == NULL) SWIG_fail;
43832 temp2 = true;
43833 }
43834 {
43835 PyThreadState* __tstate = wxPyBeginAllowThreads();
43836 (arg1)->SetText((wxString const &)*arg2);
43837 wxPyEndAllowThreads(__tstate);
43838 if (PyErr_Occurred()) SWIG_fail;
43839 }
43840 resultobj = SWIG_Py_Void();
43841 {
43842 if (temp2)
43843 delete arg2;
43844 }
43845 return resultobj;
43846 fail:
43847 {
43848 if (temp2)
43849 delete arg2;
43850 }
43851 return NULL;
43852 }
43853
43854
43855 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43856 PyObject *resultobj = 0;
43857 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43858 wxString result;
43859 void *argp1 = 0 ;
43860 int res1 = 0 ;
43861 PyObject *swig_obj[1] ;
43862
43863 if (!args) SWIG_fail;
43864 swig_obj[0] = args;
43865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43866 if (!SWIG_IsOK(res1)) {
43867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43868 }
43869 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43870 {
43871 PyThreadState* __tstate = wxPyBeginAllowThreads();
43872 result = ((wxMenuItem const *)arg1)->GetLabel();
43873 wxPyEndAllowThreads(__tstate);
43874 if (PyErr_Occurred()) SWIG_fail;
43875 }
43876 {
43877 #if wxUSE_UNICODE
43878 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43879 #else
43880 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43881 #endif
43882 }
43883 return resultobj;
43884 fail:
43885 return NULL;
43886 }
43887
43888
43889 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43890 PyObject *resultobj = 0;
43891 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43892 wxString *result = 0 ;
43893 void *argp1 = 0 ;
43894 int res1 = 0 ;
43895 PyObject *swig_obj[1] ;
43896
43897 if (!args) SWIG_fail;
43898 swig_obj[0] = args;
43899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43900 if (!SWIG_IsOK(res1)) {
43901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43902 }
43903 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43904 {
43905 PyThreadState* __tstate = wxPyBeginAllowThreads();
43906 {
43907 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43908 result = (wxString *) &_result_ref;
43909 }
43910 wxPyEndAllowThreads(__tstate);
43911 if (PyErr_Occurred()) SWIG_fail;
43912 }
43913 {
43914 #if wxUSE_UNICODE
43915 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43916 #else
43917 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43918 #endif
43919 }
43920 return resultobj;
43921 fail:
43922 return NULL;
43923 }
43924
43925
43926 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43927 PyObject *resultobj = 0;
43928 wxString *arg1 = 0 ;
43929 wxString result;
43930 bool temp1 = false ;
43931 PyObject * obj0 = 0 ;
43932 char * kwnames[] = {
43933 (char *) "text", NULL
43934 };
43935
43936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43937 {
43938 arg1 = wxString_in_helper(obj0);
43939 if (arg1 == NULL) SWIG_fail;
43940 temp1 = true;
43941 }
43942 {
43943 PyThreadState* __tstate = wxPyBeginAllowThreads();
43944 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43945 wxPyEndAllowThreads(__tstate);
43946 if (PyErr_Occurred()) SWIG_fail;
43947 }
43948 {
43949 #if wxUSE_UNICODE
43950 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43951 #else
43952 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43953 #endif
43954 }
43955 {
43956 if (temp1)
43957 delete arg1;
43958 }
43959 return resultobj;
43960 fail:
43961 {
43962 if (temp1)
43963 delete arg1;
43964 }
43965 return NULL;
43966 }
43967
43968
43969 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43970 PyObject *resultobj = 0;
43971 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43972 wxItemKind result;
43973 void *argp1 = 0 ;
43974 int res1 = 0 ;
43975 PyObject *swig_obj[1] ;
43976
43977 if (!args) SWIG_fail;
43978 swig_obj[0] = args;
43979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43980 if (!SWIG_IsOK(res1)) {
43981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43982 }
43983 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43984 {
43985 PyThreadState* __tstate = wxPyBeginAllowThreads();
43986 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
43987 wxPyEndAllowThreads(__tstate);
43988 if (PyErr_Occurred()) SWIG_fail;
43989 }
43990 resultobj = SWIG_From_int(static_cast< int >(result));
43991 return resultobj;
43992 fail:
43993 return NULL;
43994 }
43995
43996
43997 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43998 PyObject *resultobj = 0;
43999 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44000 wxItemKind arg2 ;
44001 void *argp1 = 0 ;
44002 int res1 = 0 ;
44003 int val2 ;
44004 int ecode2 = 0 ;
44005 PyObject * obj0 = 0 ;
44006 PyObject * obj1 = 0 ;
44007 char * kwnames[] = {
44008 (char *) "self",(char *) "kind", NULL
44009 };
44010
44011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
44012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44013 if (!SWIG_IsOK(res1)) {
44014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44015 }
44016 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44017 ecode2 = SWIG_AsVal_int(obj1, &val2);
44018 if (!SWIG_IsOK(ecode2)) {
44019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
44020 }
44021 arg2 = static_cast< wxItemKind >(val2);
44022 {
44023 PyThreadState* __tstate = wxPyBeginAllowThreads();
44024 (arg1)->SetKind(arg2);
44025 wxPyEndAllowThreads(__tstate);
44026 if (PyErr_Occurred()) SWIG_fail;
44027 }
44028 resultobj = SWIG_Py_Void();
44029 return resultobj;
44030 fail:
44031 return NULL;
44032 }
44033
44034
44035 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44036 PyObject *resultobj = 0;
44037 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44038 bool arg2 ;
44039 void *argp1 = 0 ;
44040 int res1 = 0 ;
44041 bool val2 ;
44042 int ecode2 = 0 ;
44043 PyObject * obj0 = 0 ;
44044 PyObject * obj1 = 0 ;
44045 char * kwnames[] = {
44046 (char *) "self",(char *) "checkable", NULL
44047 };
44048
44049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
44050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44051 if (!SWIG_IsOK(res1)) {
44052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44053 }
44054 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44055 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44056 if (!SWIG_IsOK(ecode2)) {
44057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
44058 }
44059 arg2 = static_cast< bool >(val2);
44060 {
44061 PyThreadState* __tstate = wxPyBeginAllowThreads();
44062 (arg1)->SetCheckable(arg2);
44063 wxPyEndAllowThreads(__tstate);
44064 if (PyErr_Occurred()) SWIG_fail;
44065 }
44066 resultobj = SWIG_Py_Void();
44067 return resultobj;
44068 fail:
44069 return NULL;
44070 }
44071
44072
44073 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44074 PyObject *resultobj = 0;
44075 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44076 bool result;
44077 void *argp1 = 0 ;
44078 int res1 = 0 ;
44079 PyObject *swig_obj[1] ;
44080
44081 if (!args) SWIG_fail;
44082 swig_obj[0] = args;
44083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44084 if (!SWIG_IsOK(res1)) {
44085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44086 }
44087 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44088 {
44089 PyThreadState* __tstate = wxPyBeginAllowThreads();
44090 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
44091 wxPyEndAllowThreads(__tstate);
44092 if (PyErr_Occurred()) SWIG_fail;
44093 }
44094 {
44095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44096 }
44097 return resultobj;
44098 fail:
44099 return NULL;
44100 }
44101
44102
44103 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44104 PyObject *resultobj = 0;
44105 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44106 bool result;
44107 void *argp1 = 0 ;
44108 int res1 = 0 ;
44109 PyObject *swig_obj[1] ;
44110
44111 if (!args) SWIG_fail;
44112 swig_obj[0] = args;
44113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44114 if (!SWIG_IsOK(res1)) {
44115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44116 }
44117 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44118 {
44119 PyThreadState* __tstate = wxPyBeginAllowThreads();
44120 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
44121 wxPyEndAllowThreads(__tstate);
44122 if (PyErr_Occurred()) SWIG_fail;
44123 }
44124 {
44125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44126 }
44127 return resultobj;
44128 fail:
44129 return NULL;
44130 }
44131
44132
44133 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44134 PyObject *resultobj = 0;
44135 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44136 wxMenu *arg2 = (wxMenu *) 0 ;
44137 void *argp1 = 0 ;
44138 int res1 = 0 ;
44139 void *argp2 = 0 ;
44140 int res2 = 0 ;
44141 PyObject * obj0 = 0 ;
44142 PyObject * obj1 = 0 ;
44143 char * kwnames[] = {
44144 (char *) "self",(char *) "menu", NULL
44145 };
44146
44147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44149 if (!SWIG_IsOK(res1)) {
44150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44151 }
44152 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44153 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44154 if (!SWIG_IsOK(res2)) {
44155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
44156 }
44157 arg2 = reinterpret_cast< wxMenu * >(argp2);
44158 {
44159 PyThreadState* __tstate = wxPyBeginAllowThreads();
44160 (arg1)->SetSubMenu(arg2);
44161 wxPyEndAllowThreads(__tstate);
44162 if (PyErr_Occurred()) SWIG_fail;
44163 }
44164 resultobj = SWIG_Py_Void();
44165 return resultobj;
44166 fail:
44167 return NULL;
44168 }
44169
44170
44171 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44172 PyObject *resultobj = 0;
44173 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44174 wxMenu *result = 0 ;
44175 void *argp1 = 0 ;
44176 int res1 = 0 ;
44177 PyObject *swig_obj[1] ;
44178
44179 if (!args) SWIG_fail;
44180 swig_obj[0] = args;
44181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44182 if (!SWIG_IsOK(res1)) {
44183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44184 }
44185 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44186 {
44187 PyThreadState* __tstate = wxPyBeginAllowThreads();
44188 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
44189 wxPyEndAllowThreads(__tstate);
44190 if (PyErr_Occurred()) SWIG_fail;
44191 }
44192 {
44193 resultobj = wxPyMake_wxObject(result, 0);
44194 }
44195 return resultobj;
44196 fail:
44197 return NULL;
44198 }
44199
44200
44201 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44202 PyObject *resultobj = 0;
44203 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44204 bool arg2 = (bool) true ;
44205 void *argp1 = 0 ;
44206 int res1 = 0 ;
44207 bool val2 ;
44208 int ecode2 = 0 ;
44209 PyObject * obj0 = 0 ;
44210 PyObject * obj1 = 0 ;
44211 char * kwnames[] = {
44212 (char *) "self",(char *) "enable", NULL
44213 };
44214
44215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
44216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44217 if (!SWIG_IsOK(res1)) {
44218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44219 }
44220 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44221 if (obj1) {
44222 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44223 if (!SWIG_IsOK(ecode2)) {
44224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
44225 }
44226 arg2 = static_cast< bool >(val2);
44227 }
44228 {
44229 PyThreadState* __tstate = wxPyBeginAllowThreads();
44230 (arg1)->Enable(arg2);
44231 wxPyEndAllowThreads(__tstate);
44232 if (PyErr_Occurred()) SWIG_fail;
44233 }
44234 resultobj = SWIG_Py_Void();
44235 return resultobj;
44236 fail:
44237 return NULL;
44238 }
44239
44240
44241 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44242 PyObject *resultobj = 0;
44243 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44244 bool result;
44245 void *argp1 = 0 ;
44246 int res1 = 0 ;
44247 PyObject *swig_obj[1] ;
44248
44249 if (!args) SWIG_fail;
44250 swig_obj[0] = args;
44251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44252 if (!SWIG_IsOK(res1)) {
44253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44254 }
44255 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44256 {
44257 PyThreadState* __tstate = wxPyBeginAllowThreads();
44258 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
44259 wxPyEndAllowThreads(__tstate);
44260 if (PyErr_Occurred()) SWIG_fail;
44261 }
44262 {
44263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44264 }
44265 return resultobj;
44266 fail:
44267 return NULL;
44268 }
44269
44270
44271 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44272 PyObject *resultobj = 0;
44273 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44274 bool arg2 = (bool) true ;
44275 void *argp1 = 0 ;
44276 int res1 = 0 ;
44277 bool val2 ;
44278 int ecode2 = 0 ;
44279 PyObject * obj0 = 0 ;
44280 PyObject * obj1 = 0 ;
44281 char * kwnames[] = {
44282 (char *) "self",(char *) "check", NULL
44283 };
44284
44285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
44286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44287 if (!SWIG_IsOK(res1)) {
44288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44289 }
44290 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44291 if (obj1) {
44292 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44293 if (!SWIG_IsOK(ecode2)) {
44294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
44295 }
44296 arg2 = static_cast< bool >(val2);
44297 }
44298 {
44299 PyThreadState* __tstate = wxPyBeginAllowThreads();
44300 (arg1)->Check(arg2);
44301 wxPyEndAllowThreads(__tstate);
44302 if (PyErr_Occurred()) SWIG_fail;
44303 }
44304 resultobj = SWIG_Py_Void();
44305 return resultobj;
44306 fail:
44307 return NULL;
44308 }
44309
44310
44311 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44312 PyObject *resultobj = 0;
44313 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44314 bool result;
44315 void *argp1 = 0 ;
44316 int res1 = 0 ;
44317 PyObject *swig_obj[1] ;
44318
44319 if (!args) SWIG_fail;
44320 swig_obj[0] = args;
44321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44322 if (!SWIG_IsOK(res1)) {
44323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44324 }
44325 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44326 {
44327 PyThreadState* __tstate = wxPyBeginAllowThreads();
44328 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
44329 wxPyEndAllowThreads(__tstate);
44330 if (PyErr_Occurred()) SWIG_fail;
44331 }
44332 {
44333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44334 }
44335 return resultobj;
44336 fail:
44337 return NULL;
44338 }
44339
44340
44341 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44342 PyObject *resultobj = 0;
44343 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44344 void *argp1 = 0 ;
44345 int res1 = 0 ;
44346 PyObject *swig_obj[1] ;
44347
44348 if (!args) SWIG_fail;
44349 swig_obj[0] = args;
44350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44351 if (!SWIG_IsOK(res1)) {
44352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44353 }
44354 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44355 {
44356 PyThreadState* __tstate = wxPyBeginAllowThreads();
44357 (arg1)->Toggle();
44358 wxPyEndAllowThreads(__tstate);
44359 if (PyErr_Occurred()) SWIG_fail;
44360 }
44361 resultobj = SWIG_Py_Void();
44362 return resultobj;
44363 fail:
44364 return NULL;
44365 }
44366
44367
44368 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44369 PyObject *resultobj = 0;
44370 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44371 wxString *arg2 = 0 ;
44372 void *argp1 = 0 ;
44373 int res1 = 0 ;
44374 bool temp2 = false ;
44375 PyObject * obj0 = 0 ;
44376 PyObject * obj1 = 0 ;
44377 char * kwnames[] = {
44378 (char *) "self",(char *) "str", NULL
44379 };
44380
44381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
44382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44383 if (!SWIG_IsOK(res1)) {
44384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44385 }
44386 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44387 {
44388 arg2 = wxString_in_helper(obj1);
44389 if (arg2 == NULL) SWIG_fail;
44390 temp2 = true;
44391 }
44392 {
44393 PyThreadState* __tstate = wxPyBeginAllowThreads();
44394 (arg1)->SetHelp((wxString const &)*arg2);
44395 wxPyEndAllowThreads(__tstate);
44396 if (PyErr_Occurred()) SWIG_fail;
44397 }
44398 resultobj = SWIG_Py_Void();
44399 {
44400 if (temp2)
44401 delete arg2;
44402 }
44403 return resultobj;
44404 fail:
44405 {
44406 if (temp2)
44407 delete arg2;
44408 }
44409 return NULL;
44410 }
44411
44412
44413 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44414 PyObject *resultobj = 0;
44415 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44416 wxString *result = 0 ;
44417 void *argp1 = 0 ;
44418 int res1 = 0 ;
44419 PyObject *swig_obj[1] ;
44420
44421 if (!args) SWIG_fail;
44422 swig_obj[0] = args;
44423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44424 if (!SWIG_IsOK(res1)) {
44425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44426 }
44427 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44428 {
44429 PyThreadState* __tstate = wxPyBeginAllowThreads();
44430 {
44431 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
44432 result = (wxString *) &_result_ref;
44433 }
44434 wxPyEndAllowThreads(__tstate);
44435 if (PyErr_Occurred()) SWIG_fail;
44436 }
44437 {
44438 #if wxUSE_UNICODE
44439 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
44440 #else
44441 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
44442 #endif
44443 }
44444 return resultobj;
44445 fail:
44446 return NULL;
44447 }
44448
44449
44450 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44451 PyObject *resultobj = 0;
44452 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44453 wxAcceleratorEntry *result = 0 ;
44454 void *argp1 = 0 ;
44455 int res1 = 0 ;
44456 PyObject *swig_obj[1] ;
44457
44458 if (!args) SWIG_fail;
44459 swig_obj[0] = args;
44460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44461 if (!SWIG_IsOK(res1)) {
44462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44463 }
44464 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44465 {
44466 PyThreadState* __tstate = wxPyBeginAllowThreads();
44467 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
44468 wxPyEndAllowThreads(__tstate);
44469 if (PyErr_Occurred()) SWIG_fail;
44470 }
44471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44472 return resultobj;
44473 fail:
44474 return NULL;
44475 }
44476
44477
44478 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44479 PyObject *resultobj = 0;
44480 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44481 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
44482 void *argp1 = 0 ;
44483 int res1 = 0 ;
44484 void *argp2 = 0 ;
44485 int res2 = 0 ;
44486 PyObject * obj0 = 0 ;
44487 PyObject * obj1 = 0 ;
44488 char * kwnames[] = {
44489 (char *) "self",(char *) "accel", NULL
44490 };
44491
44492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
44493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44494 if (!SWIG_IsOK(res1)) {
44495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44496 }
44497 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44498 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44499 if (!SWIG_IsOK(res2)) {
44500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
44501 }
44502 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
44503 {
44504 PyThreadState* __tstate = wxPyBeginAllowThreads();
44505 (arg1)->SetAccel(arg2);
44506 wxPyEndAllowThreads(__tstate);
44507 if (PyErr_Occurred()) SWIG_fail;
44508 }
44509 resultobj = SWIG_Py_Void();
44510 return resultobj;
44511 fail:
44512 return NULL;
44513 }
44514
44515
44516 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44517 PyObject *resultobj = 0;
44518 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44519 wxBitmap *arg2 = 0 ;
44520 void *argp1 = 0 ;
44521 int res1 = 0 ;
44522 void *argp2 = 0 ;
44523 int res2 = 0 ;
44524 PyObject * obj0 = 0 ;
44525 PyObject * obj1 = 0 ;
44526 char * kwnames[] = {
44527 (char *) "self",(char *) "bitmap", NULL
44528 };
44529
44530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44532 if (!SWIG_IsOK(res1)) {
44533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44534 }
44535 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44536 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44537 if (!SWIG_IsOK(res2)) {
44538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44539 }
44540 if (!argp2) {
44541 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44542 }
44543 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44544 {
44545 PyThreadState* __tstate = wxPyBeginAllowThreads();
44546 (arg1)->SetBitmap((wxBitmap const &)*arg2);
44547 wxPyEndAllowThreads(__tstate);
44548 if (PyErr_Occurred()) SWIG_fail;
44549 }
44550 resultobj = SWIG_Py_Void();
44551 return resultobj;
44552 fail:
44553 return NULL;
44554 }
44555
44556
44557 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44558 PyObject *resultobj = 0;
44559 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44560 wxBitmap *result = 0 ;
44561 void *argp1 = 0 ;
44562 int res1 = 0 ;
44563 PyObject *swig_obj[1] ;
44564
44565 if (!args) SWIG_fail;
44566 swig_obj[0] = args;
44567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44568 if (!SWIG_IsOK(res1)) {
44569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44570 }
44571 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44572 {
44573 PyThreadState* __tstate = wxPyBeginAllowThreads();
44574 {
44575 wxBitmap const &_result_ref = (arg1)->GetBitmap();
44576 result = (wxBitmap *) &_result_ref;
44577 }
44578 wxPyEndAllowThreads(__tstate);
44579 if (PyErr_Occurred()) SWIG_fail;
44580 }
44581 {
44582 wxBitmap* resultptr = new wxBitmap(*result);
44583 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44584 }
44585 return resultobj;
44586 fail:
44587 return NULL;
44588 }
44589
44590
44591 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44592 PyObject *resultobj = 0;
44593 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44594 wxFont *arg2 = 0 ;
44595 void *argp1 = 0 ;
44596 int res1 = 0 ;
44597 void *argp2 = 0 ;
44598 int res2 = 0 ;
44599 PyObject * obj0 = 0 ;
44600 PyObject * obj1 = 0 ;
44601 char * kwnames[] = {
44602 (char *) "self",(char *) "font", NULL
44603 };
44604
44605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
44606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44607 if (!SWIG_IsOK(res1)) {
44608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44609 }
44610 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44611 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
44612 if (!SWIG_IsOK(res2)) {
44613 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44614 }
44615 if (!argp2) {
44616 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44617 }
44618 arg2 = reinterpret_cast< wxFont * >(argp2);
44619 {
44620 PyThreadState* __tstate = wxPyBeginAllowThreads();
44621 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
44622 wxPyEndAllowThreads(__tstate);
44623 if (PyErr_Occurred()) SWIG_fail;
44624 }
44625 resultobj = SWIG_Py_Void();
44626 return resultobj;
44627 fail:
44628 return NULL;
44629 }
44630
44631
44632 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44633 PyObject *resultobj = 0;
44634 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44635 wxFont result;
44636 void *argp1 = 0 ;
44637 int res1 = 0 ;
44638 PyObject *swig_obj[1] ;
44639
44640 if (!args) SWIG_fail;
44641 swig_obj[0] = args;
44642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44643 if (!SWIG_IsOK(res1)) {
44644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44645 }
44646 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44647 {
44648 PyThreadState* __tstate = wxPyBeginAllowThreads();
44649 result = wxMenuItem_GetFont(arg1);
44650 wxPyEndAllowThreads(__tstate);
44651 if (PyErr_Occurred()) SWIG_fail;
44652 }
44653 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
44654 return resultobj;
44655 fail:
44656 return NULL;
44657 }
44658
44659
44660 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44661 PyObject *resultobj = 0;
44662 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44663 wxColour *arg2 = 0 ;
44664 void *argp1 = 0 ;
44665 int res1 = 0 ;
44666 wxColour temp2 ;
44667 PyObject * obj0 = 0 ;
44668 PyObject * obj1 = 0 ;
44669 char * kwnames[] = {
44670 (char *) "self",(char *) "colText", NULL
44671 };
44672
44673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44675 if (!SWIG_IsOK(res1)) {
44676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44677 }
44678 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44679 {
44680 arg2 = &temp2;
44681 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44682 }
44683 {
44684 PyThreadState* __tstate = wxPyBeginAllowThreads();
44685 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
44686 wxPyEndAllowThreads(__tstate);
44687 if (PyErr_Occurred()) SWIG_fail;
44688 }
44689 resultobj = SWIG_Py_Void();
44690 return resultobj;
44691 fail:
44692 return NULL;
44693 }
44694
44695
44696 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44697 PyObject *resultobj = 0;
44698 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44699 wxColour result;
44700 void *argp1 = 0 ;
44701 int res1 = 0 ;
44702 PyObject *swig_obj[1] ;
44703
44704 if (!args) SWIG_fail;
44705 swig_obj[0] = args;
44706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44707 if (!SWIG_IsOK(res1)) {
44708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44709 }
44710 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44711 {
44712 PyThreadState* __tstate = wxPyBeginAllowThreads();
44713 result = wxMenuItem_GetTextColour(arg1);
44714 wxPyEndAllowThreads(__tstate);
44715 if (PyErr_Occurred()) SWIG_fail;
44716 }
44717 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44718 return resultobj;
44719 fail:
44720 return NULL;
44721 }
44722
44723
44724 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44725 PyObject *resultobj = 0;
44726 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44727 wxColour *arg2 = 0 ;
44728 void *argp1 = 0 ;
44729 int res1 = 0 ;
44730 wxColour temp2 ;
44731 PyObject * obj0 = 0 ;
44732 PyObject * obj1 = 0 ;
44733 char * kwnames[] = {
44734 (char *) "self",(char *) "colBack", NULL
44735 };
44736
44737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44739 if (!SWIG_IsOK(res1)) {
44740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44741 }
44742 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44743 {
44744 arg2 = &temp2;
44745 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44746 }
44747 {
44748 PyThreadState* __tstate = wxPyBeginAllowThreads();
44749 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
44750 wxPyEndAllowThreads(__tstate);
44751 if (PyErr_Occurred()) SWIG_fail;
44752 }
44753 resultobj = SWIG_Py_Void();
44754 return resultobj;
44755 fail:
44756 return NULL;
44757 }
44758
44759
44760 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44761 PyObject *resultobj = 0;
44762 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44763 wxColour result;
44764 void *argp1 = 0 ;
44765 int res1 = 0 ;
44766 PyObject *swig_obj[1] ;
44767
44768 if (!args) SWIG_fail;
44769 swig_obj[0] = args;
44770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44771 if (!SWIG_IsOK(res1)) {
44772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44773 }
44774 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44775 {
44776 PyThreadState* __tstate = wxPyBeginAllowThreads();
44777 result = wxMenuItem_GetBackgroundColour(arg1);
44778 wxPyEndAllowThreads(__tstate);
44779 if (PyErr_Occurred()) SWIG_fail;
44780 }
44781 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44782 return resultobj;
44783 fail:
44784 return NULL;
44785 }
44786
44787
44788 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44789 PyObject *resultobj = 0;
44790 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44791 wxBitmap *arg2 = 0 ;
44792 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44793 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44794 void *argp1 = 0 ;
44795 int res1 = 0 ;
44796 void *argp2 = 0 ;
44797 int res2 = 0 ;
44798 void *argp3 = 0 ;
44799 int res3 = 0 ;
44800 PyObject * obj0 = 0 ;
44801 PyObject * obj1 = 0 ;
44802 PyObject * obj2 = 0 ;
44803 char * kwnames[] = {
44804 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44805 };
44806
44807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44809 if (!SWIG_IsOK(res1)) {
44810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44811 }
44812 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44813 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44814 if (!SWIG_IsOK(res2)) {
44815 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44816 }
44817 if (!argp2) {
44818 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44819 }
44820 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44821 if (obj2) {
44822 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44823 if (!SWIG_IsOK(res3)) {
44824 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44825 }
44826 if (!argp3) {
44827 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44828 }
44829 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44830 }
44831 {
44832 PyThreadState* __tstate = wxPyBeginAllowThreads();
44833 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44834 wxPyEndAllowThreads(__tstate);
44835 if (PyErr_Occurred()) SWIG_fail;
44836 }
44837 resultobj = SWIG_Py_Void();
44838 return resultobj;
44839 fail:
44840 return NULL;
44841 }
44842
44843
44844 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44845 PyObject *resultobj = 0;
44846 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44847 wxBitmap *arg2 = 0 ;
44848 void *argp1 = 0 ;
44849 int res1 = 0 ;
44850 void *argp2 = 0 ;
44851 int res2 = 0 ;
44852 PyObject * obj0 = 0 ;
44853 PyObject * obj1 = 0 ;
44854 char * kwnames[] = {
44855 (char *) "self",(char *) "bmpDisabled", NULL
44856 };
44857
44858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44860 if (!SWIG_IsOK(res1)) {
44861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44862 }
44863 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44864 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44865 if (!SWIG_IsOK(res2)) {
44866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44867 }
44868 if (!argp2) {
44869 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44870 }
44871 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44872 {
44873 PyThreadState* __tstate = wxPyBeginAllowThreads();
44874 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
44875 wxPyEndAllowThreads(__tstate);
44876 if (PyErr_Occurred()) SWIG_fail;
44877 }
44878 resultobj = SWIG_Py_Void();
44879 return resultobj;
44880 fail:
44881 return NULL;
44882 }
44883
44884
44885 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44886 PyObject *resultobj = 0;
44887 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44888 wxBitmap *result = 0 ;
44889 void *argp1 = 0 ;
44890 int res1 = 0 ;
44891 PyObject *swig_obj[1] ;
44892
44893 if (!args) SWIG_fail;
44894 swig_obj[0] = args;
44895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44896 if (!SWIG_IsOK(res1)) {
44897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44898 }
44899 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44900 {
44901 PyThreadState* __tstate = wxPyBeginAllowThreads();
44902 {
44903 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
44904 result = (wxBitmap *) &_result_ref;
44905 }
44906 wxPyEndAllowThreads(__tstate);
44907 if (PyErr_Occurred()) SWIG_fail;
44908 }
44909 {
44910 wxBitmap* resultptr = new wxBitmap(*result);
44911 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44912 }
44913 return resultobj;
44914 fail:
44915 return NULL;
44916 }
44917
44918
44919 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44920 PyObject *resultobj = 0;
44921 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44922 int arg2 ;
44923 void *argp1 = 0 ;
44924 int res1 = 0 ;
44925 int val2 ;
44926 int ecode2 = 0 ;
44927 PyObject * obj0 = 0 ;
44928 PyObject * obj1 = 0 ;
44929 char * kwnames[] = {
44930 (char *) "self",(char *) "nWidth", NULL
44931 };
44932
44933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44935 if (!SWIG_IsOK(res1)) {
44936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44937 }
44938 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44939 ecode2 = SWIG_AsVal_int(obj1, &val2);
44940 if (!SWIG_IsOK(ecode2)) {
44941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44942 }
44943 arg2 = static_cast< int >(val2);
44944 {
44945 PyThreadState* __tstate = wxPyBeginAllowThreads();
44946 wxMenuItem_SetMarginWidth(arg1,arg2);
44947 wxPyEndAllowThreads(__tstate);
44948 if (PyErr_Occurred()) SWIG_fail;
44949 }
44950 resultobj = SWIG_Py_Void();
44951 return resultobj;
44952 fail:
44953 return NULL;
44954 }
44955
44956
44957 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44958 PyObject *resultobj = 0;
44959 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44960 int result;
44961 void *argp1 = 0 ;
44962 int res1 = 0 ;
44963 PyObject *swig_obj[1] ;
44964
44965 if (!args) SWIG_fail;
44966 swig_obj[0] = args;
44967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44968 if (!SWIG_IsOK(res1)) {
44969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44970 }
44971 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44972 {
44973 PyThreadState* __tstate = wxPyBeginAllowThreads();
44974 result = (int)wxMenuItem_GetMarginWidth(arg1);
44975 wxPyEndAllowThreads(__tstate);
44976 if (PyErr_Occurred()) SWIG_fail;
44977 }
44978 resultobj = SWIG_From_int(static_cast< int >(result));
44979 return resultobj;
44980 fail:
44981 return NULL;
44982 }
44983
44984
44985 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44986 PyObject *resultobj = 0;
44987 int result;
44988
44989 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
44990 {
44991 PyThreadState* __tstate = wxPyBeginAllowThreads();
44992 result = (int)wxMenuItem_GetDefaultMarginWidth();
44993 wxPyEndAllowThreads(__tstate);
44994 if (PyErr_Occurred()) SWIG_fail;
44995 }
44996 resultobj = SWIG_From_int(static_cast< int >(result));
44997 return resultobj;
44998 fail:
44999 return NULL;
45000 }
45001
45002
45003 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45004 PyObject *resultobj = 0;
45005 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45006 bool result;
45007 void *argp1 = 0 ;
45008 int res1 = 0 ;
45009 PyObject *swig_obj[1] ;
45010
45011 if (!args) SWIG_fail;
45012 swig_obj[0] = args;
45013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45014 if (!SWIG_IsOK(res1)) {
45015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45016 }
45017 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45018 {
45019 PyThreadState* __tstate = wxPyBeginAllowThreads();
45020 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
45021 wxPyEndAllowThreads(__tstate);
45022 if (PyErr_Occurred()) SWIG_fail;
45023 }
45024 {
45025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45026 }
45027 return resultobj;
45028 fail:
45029 return NULL;
45030 }
45031
45032
45033 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45034 PyObject *resultobj = 0;
45035 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45036 bool arg2 = (bool) true ;
45037 void *argp1 = 0 ;
45038 int res1 = 0 ;
45039 bool val2 ;
45040 int ecode2 = 0 ;
45041 PyObject * obj0 = 0 ;
45042 PyObject * obj1 = 0 ;
45043 char * kwnames[] = {
45044 (char *) "self",(char *) "ownerDrawn", NULL
45045 };
45046
45047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
45048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45049 if (!SWIG_IsOK(res1)) {
45050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45051 }
45052 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45053 if (obj1) {
45054 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45055 if (!SWIG_IsOK(ecode2)) {
45056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
45057 }
45058 arg2 = static_cast< bool >(val2);
45059 }
45060 {
45061 PyThreadState* __tstate = wxPyBeginAllowThreads();
45062 wxMenuItem_SetOwnerDrawn(arg1,arg2);
45063 wxPyEndAllowThreads(__tstate);
45064 if (PyErr_Occurred()) SWIG_fail;
45065 }
45066 resultobj = SWIG_Py_Void();
45067 return resultobj;
45068 fail:
45069 return NULL;
45070 }
45071
45072
45073 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45074 PyObject *resultobj = 0;
45075 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45076 void *argp1 = 0 ;
45077 int res1 = 0 ;
45078 PyObject *swig_obj[1] ;
45079
45080 if (!args) SWIG_fail;
45081 swig_obj[0] = args;
45082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45083 if (!SWIG_IsOK(res1)) {
45084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45085 }
45086 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45087 {
45088 PyThreadState* __tstate = wxPyBeginAllowThreads();
45089 wxMenuItem_ResetOwnerDrawn(arg1);
45090 wxPyEndAllowThreads(__tstate);
45091 if (PyErr_Occurred()) SWIG_fail;
45092 }
45093 resultobj = SWIG_Py_Void();
45094 return resultobj;
45095 fail:
45096 return NULL;
45097 }
45098
45099
45100 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45101 PyObject *obj;
45102 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45103 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
45104 return SWIG_Py_Void();
45105 }
45106
45107 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45108 return SWIG_Python_InitShadowInstance(args);
45109 }
45110
45111 SWIGINTERN int ControlNameStr_set(PyObject *) {
45112 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
45113 return 1;
45114 }
45115
45116
45117 SWIGINTERN PyObject *ControlNameStr_get(void) {
45118 PyObject *pyobj = 0;
45119
45120 {
45121 #if wxUSE_UNICODE
45122 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
45123 #else
45124 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
45125 #endif
45126 }
45127 return pyobj;
45128 }
45129
45130
45131 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45132 PyObject *resultobj = 0;
45133 wxWindow *arg1 = (wxWindow *) 0 ;
45134 int arg2 = (int) -1 ;
45135 wxPoint const &arg3_defvalue = wxDefaultPosition ;
45136 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
45137 wxSize const &arg4_defvalue = wxDefaultSize ;
45138 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
45139 long arg5 = (long) 0 ;
45140 wxValidator const &arg6_defvalue = wxDefaultValidator ;
45141 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
45142 wxString const &arg7_defvalue = wxPyControlNameStr ;
45143 wxString *arg7 = (wxString *) &arg7_defvalue ;
45144 wxControl *result = 0 ;
45145 void *argp1 = 0 ;
45146 int res1 = 0 ;
45147 int val2 ;
45148 int ecode2 = 0 ;
45149 wxPoint temp3 ;
45150 wxSize temp4 ;
45151 long val5 ;
45152 int ecode5 = 0 ;
45153 void *argp6 = 0 ;
45154 int res6 = 0 ;
45155 bool temp7 = false ;
45156 PyObject * obj0 = 0 ;
45157 PyObject * obj1 = 0 ;
45158 PyObject * obj2 = 0 ;
45159 PyObject * obj3 = 0 ;
45160 PyObject * obj4 = 0 ;
45161 PyObject * obj5 = 0 ;
45162 PyObject * obj6 = 0 ;
45163 char * kwnames[] = {
45164 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
45165 };
45166
45167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
45168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45169 if (!SWIG_IsOK(res1)) {
45170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
45171 }
45172 arg1 = reinterpret_cast< wxWindow * >(argp1);
45173 if (obj1) {
45174 ecode2 = SWIG_AsVal_int(obj1, &val2);
45175 if (!SWIG_IsOK(ecode2)) {
45176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
45177 }
45178 arg2 = static_cast< int >(val2);
45179 }
45180 if (obj2) {
45181 {
45182 arg3 = &temp3;
45183 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
45184 }
45185 }
45186 if (obj3) {
45187 {
45188 arg4 = &temp4;
45189 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
45190 }
45191 }
45192 if (obj4) {
45193 ecode5 = SWIG_AsVal_long(obj4, &val5);
45194 if (!SWIG_IsOK(ecode5)) {
45195 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
45196 }
45197 arg5 = static_cast< long >(val5);
45198 }
45199 if (obj5) {
45200 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
45201 if (!SWIG_IsOK(res6)) {
45202 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
45203 }
45204 if (!argp6) {
45205 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
45206 }
45207 arg6 = reinterpret_cast< wxValidator * >(argp6);
45208 }
45209 if (obj6) {
45210 {
45211 arg7 = wxString_in_helper(obj6);
45212 if (arg7 == NULL) SWIG_fail;
45213 temp7 = true;
45214 }
45215 }
45216 {
45217 if (!wxPyCheckForApp()) SWIG_fail;
45218 PyThreadState* __tstate = wxPyBeginAllowThreads();
45219 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
45220 wxPyEndAllowThreads(__tstate);
45221 if (PyErr_Occurred()) SWIG_fail;
45222 }
45223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
45224 {
45225 if (temp7)
45226 delete arg7;
45227 }
45228 return resultobj;
45229 fail:
45230 {
45231 if (temp7)
45232 delete arg7;
45233 }
45234 return NULL;
45235 }
45236
45237
45238 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45239 PyObject *resultobj = 0;
45240 wxControl *result = 0 ;
45241
45242 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
45243 {
45244 if (!wxPyCheckForApp()) SWIG_fail;
45245 PyThreadState* __tstate = wxPyBeginAllowThreads();
45246 result = (wxControl *)new wxControl();
45247 wxPyEndAllowThreads(__tstate);
45248 if (PyErr_Occurred()) SWIG_fail;
45249 }
45250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
45251 return resultobj;
45252 fail:
45253 return NULL;
45254 }
45255
45256
45257 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45258 PyObject *resultobj = 0;
45259 wxControl *arg1 = (wxControl *) 0 ;
45260 wxWindow *arg2 = (wxWindow *) 0 ;
45261 int arg3 = (int) -1 ;
45262 wxPoint const &arg4_defvalue = wxDefaultPosition ;
45263 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
45264 wxSize const &arg5_defvalue = wxDefaultSize ;
45265 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
45266 long arg6 = (long) 0 ;
45267 wxValidator const &arg7_defvalue = wxDefaultValidator ;
45268 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
45269 wxString const &arg8_defvalue = wxPyControlNameStr ;
45270 wxString *arg8 = (wxString *) &arg8_defvalue ;
45271 bool result;
45272 void *argp1 = 0 ;
45273 int res1 = 0 ;
45274 void *argp2 = 0 ;
45275 int res2 = 0 ;
45276 int val3 ;
45277 int ecode3 = 0 ;
45278 wxPoint temp4 ;
45279 wxSize temp5 ;
45280 long val6 ;
45281 int ecode6 = 0 ;
45282 void *argp7 = 0 ;
45283 int res7 = 0 ;
45284 bool temp8 = false ;
45285 PyObject * obj0 = 0 ;
45286 PyObject * obj1 = 0 ;
45287 PyObject * obj2 = 0 ;
45288 PyObject * obj3 = 0 ;
45289 PyObject * obj4 = 0 ;
45290 PyObject * obj5 = 0 ;
45291 PyObject * obj6 = 0 ;
45292 PyObject * obj7 = 0 ;
45293 char * kwnames[] = {
45294 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
45295 };
45296
45297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
45298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45299 if (!SWIG_IsOK(res1)) {
45300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
45301 }
45302 arg1 = reinterpret_cast< wxControl * >(argp1);
45303 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45304 if (!SWIG_IsOK(res2)) {
45305 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
45306 }
45307 arg2 = reinterpret_cast< wxWindow * >(argp2);
45308 if (obj2) {
45309 ecode3 = SWIG_AsVal_int(obj2, &val3);
45310 if (!SWIG_IsOK(ecode3)) {
45311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
45312 }
45313 arg3 = static_cast< int >(val3);
45314 }
45315 if (obj3) {
45316 {
45317 arg4 = &temp4;
45318 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
45319 }
45320 }
45321 if (obj4) {
45322 {
45323 arg5 = &temp5;
45324 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
45325 }
45326 }
45327 if (obj5) {
45328 ecode6 = SWIG_AsVal_long(obj5, &val6);
45329 if (!SWIG_IsOK(ecode6)) {
45330 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
45331 }
45332 arg6 = static_cast< long >(val6);
45333 }
45334 if (obj6) {
45335 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
45336 if (!SWIG_IsOK(res7)) {
45337 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
45338 }
45339 if (!argp7) {
45340 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
45341 }
45342 arg7 = reinterpret_cast< wxValidator * >(argp7);
45343 }
45344 if (obj7) {
45345 {
45346 arg8 = wxString_in_helper(obj7);
45347 if (arg8 == NULL) SWIG_fail;
45348 temp8 = true;
45349 }
45350 }
45351 {
45352 PyThreadState* __tstate = wxPyBeginAllowThreads();
45353 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
45354 wxPyEndAllowThreads(__tstate);
45355 if (PyErr_Occurred()) SWIG_fail;
45356 }
45357 {
45358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45359 }
45360 {
45361 if (temp8)
45362 delete arg8;
45363 }
45364 return resultobj;
45365 fail:
45366 {
45367 if (temp8)
45368 delete arg8;
45369 }
45370 return NULL;
45371 }
45372
45373
45374 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45375 PyObject *resultobj = 0;
45376 wxControl *arg1 = (wxControl *) 0 ;
45377 int result;
45378 void *argp1 = 0 ;
45379 int res1 = 0 ;
45380 PyObject *swig_obj[1] ;
45381
45382 if (!args) SWIG_fail;
45383 swig_obj[0] = args;
45384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45385 if (!SWIG_IsOK(res1)) {
45386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
45387 }
45388 arg1 = reinterpret_cast< wxControl * >(argp1);
45389 {
45390 PyThreadState* __tstate = wxPyBeginAllowThreads();
45391 result = (int)((wxControl const *)arg1)->GetAlignment();
45392 wxPyEndAllowThreads(__tstate);
45393 if (PyErr_Occurred()) SWIG_fail;
45394 }
45395 resultobj = SWIG_From_int(static_cast< int >(result));
45396 return resultobj;
45397 fail:
45398 return NULL;
45399 }
45400
45401
45402 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45403 PyObject *resultobj = 0;
45404 wxControl *arg1 = (wxControl *) 0 ;
45405 wxString result;
45406 void *argp1 = 0 ;
45407 int res1 = 0 ;
45408 PyObject *swig_obj[1] ;
45409
45410 if (!args) SWIG_fail;
45411 swig_obj[0] = args;
45412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45413 if (!SWIG_IsOK(res1)) {
45414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
45415 }
45416 arg1 = reinterpret_cast< wxControl * >(argp1);
45417 {
45418 PyThreadState* __tstate = wxPyBeginAllowThreads();
45419 result = ((wxControl const *)arg1)->GetLabelText();
45420 wxPyEndAllowThreads(__tstate);
45421 if (PyErr_Occurred()) SWIG_fail;
45422 }
45423 {
45424 #if wxUSE_UNICODE
45425 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45426 #else
45427 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45428 #endif
45429 }
45430 return resultobj;
45431 fail:
45432 return NULL;
45433 }
45434
45435
45436 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45437 PyObject *resultobj = 0;
45438 wxControl *arg1 = (wxControl *) 0 ;
45439 wxCommandEvent *arg2 = 0 ;
45440 void *argp1 = 0 ;
45441 int res1 = 0 ;
45442 void *argp2 = 0 ;
45443 int res2 = 0 ;
45444 PyObject * obj0 = 0 ;
45445 PyObject * obj1 = 0 ;
45446 char * kwnames[] = {
45447 (char *) "self",(char *) "event", NULL
45448 };
45449
45450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
45451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45452 if (!SWIG_IsOK(res1)) {
45453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
45454 }
45455 arg1 = reinterpret_cast< wxControl * >(argp1);
45456 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
45457 if (!SWIG_IsOK(res2)) {
45458 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
45459 }
45460 if (!argp2) {
45461 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
45462 }
45463 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
45464 {
45465 PyThreadState* __tstate = wxPyBeginAllowThreads();
45466 (arg1)->Command(*arg2);
45467 wxPyEndAllowThreads(__tstate);
45468 if (PyErr_Occurred()) SWIG_fail;
45469 }
45470 resultobj = SWIG_Py_Void();
45471 return resultobj;
45472 fail:
45473 return NULL;
45474 }
45475
45476
45477 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45478 PyObject *resultobj = 0;
45479 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
45480 SwigValueWrapper<wxVisualAttributes > result;
45481 int val1 ;
45482 int ecode1 = 0 ;
45483 PyObject * obj0 = 0 ;
45484 char * kwnames[] = {
45485 (char *) "variant", NULL
45486 };
45487
45488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
45489 if (obj0) {
45490 ecode1 = SWIG_AsVal_int(obj0, &val1);
45491 if (!SWIG_IsOK(ecode1)) {
45492 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
45493 }
45494 arg1 = static_cast< wxWindowVariant >(val1);
45495 }
45496 {
45497 if (!wxPyCheckForApp()) SWIG_fail;
45498 PyThreadState* __tstate = wxPyBeginAllowThreads();
45499 result = wxControl::GetClassDefaultAttributes(arg1);
45500 wxPyEndAllowThreads(__tstate);
45501 if (PyErr_Occurred()) SWIG_fail;
45502 }
45503 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
45504 return resultobj;
45505 fail:
45506 return NULL;
45507 }
45508
45509
45510 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45511 PyObject *obj;
45512 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45513 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
45514 return SWIG_Py_Void();
45515 }
45516
45517 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45518 return SWIG_Python_InitShadowInstance(args);
45519 }
45520
45521 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45522 PyObject *resultobj = 0;
45523 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45524 wxString *arg2 = 0 ;
45525 PyObject *arg3 = (PyObject *) NULL ;
45526 int result;
45527 void *argp1 = 0 ;
45528 int res1 = 0 ;
45529 bool temp2 = false ;
45530 PyObject * obj0 = 0 ;
45531 PyObject * obj1 = 0 ;
45532 PyObject * obj2 = 0 ;
45533 char * kwnames[] = {
45534 (char *) "self",(char *) "item",(char *) "clientData", NULL
45535 };
45536
45537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45539 if (!SWIG_IsOK(res1)) {
45540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45541 }
45542 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45543 {
45544 arg2 = wxString_in_helper(obj1);
45545 if (arg2 == NULL) SWIG_fail;
45546 temp2 = true;
45547 }
45548 if (obj2) {
45549 arg3 = obj2;
45550 }
45551 {
45552 PyThreadState* __tstate = wxPyBeginAllowThreads();
45553 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
45554 wxPyEndAllowThreads(__tstate);
45555 if (PyErr_Occurred()) SWIG_fail;
45556 }
45557 resultobj = SWIG_From_int(static_cast< int >(result));
45558 {
45559 if (temp2)
45560 delete arg2;
45561 }
45562 return resultobj;
45563 fail:
45564 {
45565 if (temp2)
45566 delete arg2;
45567 }
45568 return NULL;
45569 }
45570
45571
45572 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45573 PyObject *resultobj = 0;
45574 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45575 wxArrayString *arg2 = 0 ;
45576 void *argp1 = 0 ;
45577 int res1 = 0 ;
45578 bool temp2 = false ;
45579 PyObject * obj0 = 0 ;
45580 PyObject * obj1 = 0 ;
45581 char * kwnames[] = {
45582 (char *) "self",(char *) "strings", NULL
45583 };
45584
45585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
45586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45587 if (!SWIG_IsOK(res1)) {
45588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45589 }
45590 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45591 {
45592 if (! PySequence_Check(obj1)) {
45593 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
45594 SWIG_fail;
45595 }
45596 arg2 = new wxArrayString;
45597 temp2 = true;
45598 int i, len=PySequence_Length(obj1);
45599 for (i=0; i<len; i++) {
45600 PyObject* item = PySequence_GetItem(obj1, i);
45601 wxString* s = wxString_in_helper(item);
45602 if (PyErr_Occurred()) SWIG_fail;
45603 arg2->Add(*s);
45604 delete s;
45605 Py_DECREF(item);
45606 }
45607 }
45608 {
45609 PyThreadState* __tstate = wxPyBeginAllowThreads();
45610 (arg1)->Append((wxArrayString const &)*arg2);
45611 wxPyEndAllowThreads(__tstate);
45612 if (PyErr_Occurred()) SWIG_fail;
45613 }
45614 resultobj = SWIG_Py_Void();
45615 {
45616 if (temp2) delete arg2;
45617 }
45618 return resultobj;
45619 fail:
45620 {
45621 if (temp2) delete arg2;
45622 }
45623 return NULL;
45624 }
45625
45626
45627 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45628 PyObject *resultobj = 0;
45629 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45630 wxString *arg2 = 0 ;
45631 unsigned int arg3 ;
45632 PyObject *arg4 = (PyObject *) NULL ;
45633 int result;
45634 void *argp1 = 0 ;
45635 int res1 = 0 ;
45636 bool temp2 = false ;
45637 unsigned int val3 ;
45638 int ecode3 = 0 ;
45639 PyObject * obj0 = 0 ;
45640 PyObject * obj1 = 0 ;
45641 PyObject * obj2 = 0 ;
45642 PyObject * obj3 = 0 ;
45643 char * kwnames[] = {
45644 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45645 };
45646
45647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45649 if (!SWIG_IsOK(res1)) {
45650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45651 }
45652 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45653 {
45654 arg2 = wxString_in_helper(obj1);
45655 if (arg2 == NULL) SWIG_fail;
45656 temp2 = true;
45657 }
45658 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45659 if (!SWIG_IsOK(ecode3)) {
45660 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45661 }
45662 arg3 = static_cast< unsigned int >(val3);
45663 if (obj3) {
45664 arg4 = obj3;
45665 }
45666 {
45667 PyThreadState* __tstate = wxPyBeginAllowThreads();
45668 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45669 wxPyEndAllowThreads(__tstate);
45670 if (PyErr_Occurred()) SWIG_fail;
45671 }
45672 resultobj = SWIG_From_int(static_cast< int >(result));
45673 {
45674 if (temp2)
45675 delete arg2;
45676 }
45677 return resultobj;
45678 fail:
45679 {
45680 if (temp2)
45681 delete arg2;
45682 }
45683 return NULL;
45684 }
45685
45686
45687 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45688 PyObject *resultobj = 0;
45689 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45690 void *argp1 = 0 ;
45691 int res1 = 0 ;
45692 PyObject *swig_obj[1] ;
45693
45694 if (!args) SWIG_fail;
45695 swig_obj[0] = args;
45696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45697 if (!SWIG_IsOK(res1)) {
45698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45699 }
45700 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45701 {
45702 PyThreadState* __tstate = wxPyBeginAllowThreads();
45703 (arg1)->Clear();
45704 wxPyEndAllowThreads(__tstate);
45705 if (PyErr_Occurred()) SWIG_fail;
45706 }
45707 resultobj = SWIG_Py_Void();
45708 return resultobj;
45709 fail:
45710 return NULL;
45711 }
45712
45713
45714 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45715 PyObject *resultobj = 0;
45716 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45717 unsigned int arg2 ;
45718 void *argp1 = 0 ;
45719 int res1 = 0 ;
45720 unsigned int val2 ;
45721 int ecode2 = 0 ;
45722 PyObject * obj0 = 0 ;
45723 PyObject * obj1 = 0 ;
45724 char * kwnames[] = {
45725 (char *) "self",(char *) "n", NULL
45726 };
45727
45728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45730 if (!SWIG_IsOK(res1)) {
45731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45732 }
45733 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45734 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45735 if (!SWIG_IsOK(ecode2)) {
45736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45737 }
45738 arg2 = static_cast< unsigned int >(val2);
45739 {
45740 PyThreadState* __tstate = wxPyBeginAllowThreads();
45741 (arg1)->Delete(arg2);
45742 wxPyEndAllowThreads(__tstate);
45743 if (PyErr_Occurred()) SWIG_fail;
45744 }
45745 resultobj = SWIG_Py_Void();
45746 return resultobj;
45747 fail:
45748 return NULL;
45749 }
45750
45751
45752 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45753 PyObject *resultobj = 0;
45754 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45755 unsigned int arg2 ;
45756 PyObject *result = 0 ;
45757 void *argp1 = 0 ;
45758 int res1 = 0 ;
45759 unsigned int val2 ;
45760 int ecode2 = 0 ;
45761 PyObject * obj0 = 0 ;
45762 PyObject * obj1 = 0 ;
45763 char * kwnames[] = {
45764 (char *) "self",(char *) "n", NULL
45765 };
45766
45767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45769 if (!SWIG_IsOK(res1)) {
45770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45771 }
45772 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45773 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45774 if (!SWIG_IsOK(ecode2)) {
45775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45776 }
45777 arg2 = static_cast< unsigned int >(val2);
45778 {
45779 PyThreadState* __tstate = wxPyBeginAllowThreads();
45780 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45781 wxPyEndAllowThreads(__tstate);
45782 if (PyErr_Occurred()) SWIG_fail;
45783 }
45784 resultobj = result;
45785 return resultobj;
45786 fail:
45787 return NULL;
45788 }
45789
45790
45791 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45792 PyObject *resultobj = 0;
45793 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45794 unsigned int arg2 ;
45795 PyObject *arg3 = (PyObject *) 0 ;
45796 void *argp1 = 0 ;
45797 int res1 = 0 ;
45798 unsigned int val2 ;
45799 int ecode2 = 0 ;
45800 PyObject * obj0 = 0 ;
45801 PyObject * obj1 = 0 ;
45802 PyObject * obj2 = 0 ;
45803 char * kwnames[] = {
45804 (char *) "self",(char *) "n",(char *) "clientData", NULL
45805 };
45806
45807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45809 if (!SWIG_IsOK(res1)) {
45810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45811 }
45812 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45813 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45814 if (!SWIG_IsOK(ecode2)) {
45815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45816 }
45817 arg2 = static_cast< unsigned int >(val2);
45818 arg3 = obj2;
45819 {
45820 PyThreadState* __tstate = wxPyBeginAllowThreads();
45821 wxItemContainer_SetClientData(arg1,arg2,arg3);
45822 wxPyEndAllowThreads(__tstate);
45823 if (PyErr_Occurred()) SWIG_fail;
45824 }
45825 resultobj = SWIG_Py_Void();
45826 return resultobj;
45827 fail:
45828 return NULL;
45829 }
45830
45831
45832 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45833 PyObject *resultobj = 0;
45834 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45835 unsigned int result;
45836 void *argp1 = 0 ;
45837 int res1 = 0 ;
45838 PyObject *swig_obj[1] ;
45839
45840 if (!args) SWIG_fail;
45841 swig_obj[0] = args;
45842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45843 if (!SWIG_IsOK(res1)) {
45844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45845 }
45846 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45847 {
45848 PyThreadState* __tstate = wxPyBeginAllowThreads();
45849 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45850 wxPyEndAllowThreads(__tstate);
45851 if (PyErr_Occurred()) SWIG_fail;
45852 }
45853 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45854 return resultobj;
45855 fail:
45856 return NULL;
45857 }
45858
45859
45860 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45861 PyObject *resultobj = 0;
45862 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45863 bool result;
45864 void *argp1 = 0 ;
45865 int res1 = 0 ;
45866 PyObject *swig_obj[1] ;
45867
45868 if (!args) SWIG_fail;
45869 swig_obj[0] = args;
45870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45871 if (!SWIG_IsOK(res1)) {
45872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45873 }
45874 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45875 {
45876 PyThreadState* __tstate = wxPyBeginAllowThreads();
45877 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45878 wxPyEndAllowThreads(__tstate);
45879 if (PyErr_Occurred()) SWIG_fail;
45880 }
45881 {
45882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45883 }
45884 return resultobj;
45885 fail:
45886 return NULL;
45887 }
45888
45889
45890 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45891 PyObject *resultobj = 0;
45892 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45893 unsigned int arg2 ;
45894 wxString result;
45895 void *argp1 = 0 ;
45896 int res1 = 0 ;
45897 unsigned int val2 ;
45898 int ecode2 = 0 ;
45899 PyObject * obj0 = 0 ;
45900 PyObject * obj1 = 0 ;
45901 char * kwnames[] = {
45902 (char *) "self",(char *) "n", NULL
45903 };
45904
45905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45907 if (!SWIG_IsOK(res1)) {
45908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45909 }
45910 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45911 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45912 if (!SWIG_IsOK(ecode2)) {
45913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45914 }
45915 arg2 = static_cast< unsigned int >(val2);
45916 {
45917 PyThreadState* __tstate = wxPyBeginAllowThreads();
45918 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45919 wxPyEndAllowThreads(__tstate);
45920 if (PyErr_Occurred()) SWIG_fail;
45921 }
45922 {
45923 #if wxUSE_UNICODE
45924 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45925 #else
45926 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45927 #endif
45928 }
45929 return resultobj;
45930 fail:
45931 return NULL;
45932 }
45933
45934
45935 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45936 PyObject *resultobj = 0;
45937 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45938 wxArrayString result;
45939 void *argp1 = 0 ;
45940 int res1 = 0 ;
45941 PyObject *swig_obj[1] ;
45942
45943 if (!args) SWIG_fail;
45944 swig_obj[0] = args;
45945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45946 if (!SWIG_IsOK(res1)) {
45947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45948 }
45949 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45950 {
45951 PyThreadState* __tstate = wxPyBeginAllowThreads();
45952 result = ((wxItemContainer const *)arg1)->GetStrings();
45953 wxPyEndAllowThreads(__tstate);
45954 if (PyErr_Occurred()) SWIG_fail;
45955 }
45956 {
45957 resultobj = wxArrayString2PyList_helper(result);
45958 }
45959 return resultobj;
45960 fail:
45961 return NULL;
45962 }
45963
45964
45965 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45966 PyObject *resultobj = 0;
45967 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45968 unsigned int arg2 ;
45969 wxString *arg3 = 0 ;
45970 void *argp1 = 0 ;
45971 int res1 = 0 ;
45972 unsigned int val2 ;
45973 int ecode2 = 0 ;
45974 bool temp3 = false ;
45975 PyObject * obj0 = 0 ;
45976 PyObject * obj1 = 0 ;
45977 PyObject * obj2 = 0 ;
45978 char * kwnames[] = {
45979 (char *) "self",(char *) "n",(char *) "s", NULL
45980 };
45981
45982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45984 if (!SWIG_IsOK(res1)) {
45985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45986 }
45987 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45988 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45989 if (!SWIG_IsOK(ecode2)) {
45990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
45991 }
45992 arg2 = static_cast< unsigned int >(val2);
45993 {
45994 arg3 = wxString_in_helper(obj2);
45995 if (arg3 == NULL) SWIG_fail;
45996 temp3 = true;
45997 }
45998 {
45999 PyThreadState* __tstate = wxPyBeginAllowThreads();
46000 (arg1)->SetString(arg2,(wxString const &)*arg3);
46001 wxPyEndAllowThreads(__tstate);
46002 if (PyErr_Occurred()) SWIG_fail;
46003 }
46004 resultobj = SWIG_Py_Void();
46005 {
46006 if (temp3)
46007 delete arg3;
46008 }
46009 return resultobj;
46010 fail:
46011 {
46012 if (temp3)
46013 delete arg3;
46014 }
46015 return NULL;
46016 }
46017
46018
46019 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46020 PyObject *resultobj = 0;
46021 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46022 wxString *arg2 = 0 ;
46023 int result;
46024 void *argp1 = 0 ;
46025 int res1 = 0 ;
46026 bool temp2 = false ;
46027 PyObject * obj0 = 0 ;
46028 PyObject * obj1 = 0 ;
46029 char * kwnames[] = {
46030 (char *) "self",(char *) "s", NULL
46031 };
46032
46033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
46034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46035 if (!SWIG_IsOK(res1)) {
46036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46037 }
46038 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46039 {
46040 arg2 = wxString_in_helper(obj1);
46041 if (arg2 == NULL) SWIG_fail;
46042 temp2 = true;
46043 }
46044 {
46045 PyThreadState* __tstate = wxPyBeginAllowThreads();
46046 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
46047 wxPyEndAllowThreads(__tstate);
46048 if (PyErr_Occurred()) SWIG_fail;
46049 }
46050 resultobj = SWIG_From_int(static_cast< int >(result));
46051 {
46052 if (temp2)
46053 delete arg2;
46054 }
46055 return resultobj;
46056 fail:
46057 {
46058 if (temp2)
46059 delete arg2;
46060 }
46061 return NULL;
46062 }
46063
46064
46065 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46066 PyObject *resultobj = 0;
46067 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46068 int arg2 ;
46069 void *argp1 = 0 ;
46070 int res1 = 0 ;
46071 int val2 ;
46072 int ecode2 = 0 ;
46073 PyObject * obj0 = 0 ;
46074 PyObject * obj1 = 0 ;
46075 char * kwnames[] = {
46076 (char *) "self",(char *) "n", NULL
46077 };
46078
46079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
46080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46081 if (!SWIG_IsOK(res1)) {
46082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46083 }
46084 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46085 ecode2 = SWIG_AsVal_int(obj1, &val2);
46086 if (!SWIG_IsOK(ecode2)) {
46087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
46088 }
46089 arg2 = static_cast< int >(val2);
46090 {
46091 PyThreadState* __tstate = wxPyBeginAllowThreads();
46092 (arg1)->SetSelection(arg2);
46093 wxPyEndAllowThreads(__tstate);
46094 if (PyErr_Occurred()) SWIG_fail;
46095 }
46096 resultobj = SWIG_Py_Void();
46097 return resultobj;
46098 fail:
46099 return NULL;
46100 }
46101
46102
46103 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46104 PyObject *resultobj = 0;
46105 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46106 int result;
46107 void *argp1 = 0 ;
46108 int res1 = 0 ;
46109 PyObject *swig_obj[1] ;
46110
46111 if (!args) SWIG_fail;
46112 swig_obj[0] = args;
46113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46114 if (!SWIG_IsOK(res1)) {
46115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46116 }
46117 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46118 {
46119 PyThreadState* __tstate = wxPyBeginAllowThreads();
46120 result = (int)((wxItemContainer const *)arg1)->GetSelection();
46121 wxPyEndAllowThreads(__tstate);
46122 if (PyErr_Occurred()) SWIG_fail;
46123 }
46124 resultobj = SWIG_From_int(static_cast< int >(result));
46125 return resultobj;
46126 fail:
46127 return NULL;
46128 }
46129
46130
46131 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46132 PyObject *resultobj = 0;
46133 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46134 wxString *arg2 = 0 ;
46135 bool result;
46136 void *argp1 = 0 ;
46137 int res1 = 0 ;
46138 bool temp2 = false ;
46139 PyObject * obj0 = 0 ;
46140 PyObject * obj1 = 0 ;
46141 char * kwnames[] = {
46142 (char *) "self",(char *) "s", NULL
46143 };
46144
46145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
46146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46147 if (!SWIG_IsOK(res1)) {
46148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46149 }
46150 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46151 {
46152 arg2 = wxString_in_helper(obj1);
46153 if (arg2 == NULL) SWIG_fail;
46154 temp2 = true;
46155 }
46156 {
46157 PyThreadState* __tstate = wxPyBeginAllowThreads();
46158 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
46159 wxPyEndAllowThreads(__tstate);
46160 if (PyErr_Occurred()) SWIG_fail;
46161 }
46162 {
46163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46164 }
46165 {
46166 if (temp2)
46167 delete arg2;
46168 }
46169 return resultobj;
46170 fail:
46171 {
46172 if (temp2)
46173 delete arg2;
46174 }
46175 return NULL;
46176 }
46177
46178
46179 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46180 PyObject *resultobj = 0;
46181 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46182 wxString result;
46183 void *argp1 = 0 ;
46184 int res1 = 0 ;
46185 PyObject *swig_obj[1] ;
46186
46187 if (!args) SWIG_fail;
46188 swig_obj[0] = args;
46189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46190 if (!SWIG_IsOK(res1)) {
46191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46192 }
46193 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46194 {
46195 PyThreadState* __tstate = wxPyBeginAllowThreads();
46196 result = ((wxItemContainer const *)arg1)->GetStringSelection();
46197 wxPyEndAllowThreads(__tstate);
46198 if (PyErr_Occurred()) SWIG_fail;
46199 }
46200 {
46201 #if wxUSE_UNICODE
46202 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46203 #else
46204 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46205 #endif
46206 }
46207 return resultobj;
46208 fail:
46209 return NULL;
46210 }
46211
46212
46213 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46214 PyObject *resultobj = 0;
46215 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46216 int arg2 ;
46217 void *argp1 = 0 ;
46218 int res1 = 0 ;
46219 int val2 ;
46220 int ecode2 = 0 ;
46221 PyObject * obj0 = 0 ;
46222 PyObject * obj1 = 0 ;
46223 char * kwnames[] = {
46224 (char *) "self",(char *) "n", NULL
46225 };
46226
46227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
46228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46229 if (!SWIG_IsOK(res1)) {
46230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46231 }
46232 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46233 ecode2 = SWIG_AsVal_int(obj1, &val2);
46234 if (!SWIG_IsOK(ecode2)) {
46235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
46236 }
46237 arg2 = static_cast< int >(val2);
46238 {
46239 PyThreadState* __tstate = wxPyBeginAllowThreads();
46240 (arg1)->Select(arg2);
46241 wxPyEndAllowThreads(__tstate);
46242 if (PyErr_Occurred()) SWIG_fail;
46243 }
46244 resultobj = SWIG_Py_Void();
46245 return resultobj;
46246 fail:
46247 return NULL;
46248 }
46249
46250
46251 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46252 PyObject *obj;
46253 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46254 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
46255 return SWIG_Py_Void();
46256 }
46257
46258 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46259 PyObject *obj;
46260 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46261 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
46262 return SWIG_Py_Void();
46263 }
46264
46265 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46266 PyObject *resultobj = 0;
46267 wxSizerItem *result = 0 ;
46268
46269 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
46270 {
46271 PyThreadState* __tstate = wxPyBeginAllowThreads();
46272 result = (wxSizerItem *)new wxSizerItem();
46273 wxPyEndAllowThreads(__tstate);
46274 if (PyErr_Occurred()) SWIG_fail;
46275 }
46276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
46277 return resultobj;
46278 fail:
46279 return NULL;
46280 }
46281
46282
46283 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46284 PyObject *resultobj = 0;
46285 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46286 void *argp1 = 0 ;
46287 int res1 = 0 ;
46288 PyObject *swig_obj[1] ;
46289
46290 if (!args) SWIG_fail;
46291 swig_obj[0] = args;
46292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46293 if (!SWIG_IsOK(res1)) {
46294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46295 }
46296 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46297 {
46298 PyThreadState* __tstate = wxPyBeginAllowThreads();
46299 delete arg1;
46300
46301 wxPyEndAllowThreads(__tstate);
46302 if (PyErr_Occurred()) SWIG_fail;
46303 }
46304 resultobj = SWIG_Py_Void();
46305 return resultobj;
46306 fail:
46307 return NULL;
46308 }
46309
46310
46311 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46312 PyObject *resultobj = 0;
46313 wxWindow *arg1 = (wxWindow *) 0 ;
46314 int arg2 ;
46315 int arg3 ;
46316 int arg4 ;
46317 PyObject *arg5 = (PyObject *) NULL ;
46318 wxSizerItem *result = 0 ;
46319 void *argp1 = 0 ;
46320 int res1 = 0 ;
46321 int val2 ;
46322 int ecode2 = 0 ;
46323 int val3 ;
46324 int ecode3 = 0 ;
46325 int val4 ;
46326 int ecode4 = 0 ;
46327 PyObject * obj0 = 0 ;
46328 PyObject * obj1 = 0 ;
46329 PyObject * obj2 = 0 ;
46330 PyObject * obj3 = 0 ;
46331 PyObject * obj4 = 0 ;
46332 char * kwnames[] = {
46333 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46334 };
46335
46336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
46338 if (!SWIG_IsOK(res1)) {
46339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
46340 }
46341 arg1 = reinterpret_cast< wxWindow * >(argp1);
46342 ecode2 = SWIG_AsVal_int(obj1, &val2);
46343 if (!SWIG_IsOK(ecode2)) {
46344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
46345 }
46346 arg2 = static_cast< int >(val2);
46347 ecode3 = SWIG_AsVal_int(obj2, &val3);
46348 if (!SWIG_IsOK(ecode3)) {
46349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
46350 }
46351 arg3 = static_cast< int >(val3);
46352 ecode4 = SWIG_AsVal_int(obj3, &val4);
46353 if (!SWIG_IsOK(ecode4)) {
46354 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
46355 }
46356 arg4 = static_cast< int >(val4);
46357 if (obj4) {
46358 arg5 = obj4;
46359 }
46360 {
46361 PyThreadState* __tstate = wxPyBeginAllowThreads();
46362 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46363 wxPyEndAllowThreads(__tstate);
46364 if (PyErr_Occurred()) SWIG_fail;
46365 }
46366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46367 return resultobj;
46368 fail:
46369 return NULL;
46370 }
46371
46372
46373 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46374 PyObject *resultobj = 0;
46375 int arg1 ;
46376 int arg2 ;
46377 int arg3 ;
46378 int arg4 ;
46379 int arg5 ;
46380 PyObject *arg6 = (PyObject *) NULL ;
46381 wxSizerItem *result = 0 ;
46382 int val1 ;
46383 int ecode1 = 0 ;
46384 int val2 ;
46385 int ecode2 = 0 ;
46386 int val3 ;
46387 int ecode3 = 0 ;
46388 int val4 ;
46389 int ecode4 = 0 ;
46390 int val5 ;
46391 int ecode5 = 0 ;
46392 PyObject * obj0 = 0 ;
46393 PyObject * obj1 = 0 ;
46394 PyObject * obj2 = 0 ;
46395 PyObject * obj3 = 0 ;
46396 PyObject * obj4 = 0 ;
46397 PyObject * obj5 = 0 ;
46398 char * kwnames[] = {
46399 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46400 };
46401
46402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46403 ecode1 = SWIG_AsVal_int(obj0, &val1);
46404 if (!SWIG_IsOK(ecode1)) {
46405 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
46406 }
46407 arg1 = static_cast< int >(val1);
46408 ecode2 = SWIG_AsVal_int(obj1, &val2);
46409 if (!SWIG_IsOK(ecode2)) {
46410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
46411 }
46412 arg2 = static_cast< int >(val2);
46413 ecode3 = SWIG_AsVal_int(obj2, &val3);
46414 if (!SWIG_IsOK(ecode3)) {
46415 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
46416 }
46417 arg3 = static_cast< int >(val3);
46418 ecode4 = SWIG_AsVal_int(obj3, &val4);
46419 if (!SWIG_IsOK(ecode4)) {
46420 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
46421 }
46422 arg4 = static_cast< int >(val4);
46423 ecode5 = SWIG_AsVal_int(obj4, &val5);
46424 if (!SWIG_IsOK(ecode5)) {
46425 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
46426 }
46427 arg5 = static_cast< int >(val5);
46428 if (obj5) {
46429 arg6 = obj5;
46430 }
46431 {
46432 PyThreadState* __tstate = wxPyBeginAllowThreads();
46433 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
46434 wxPyEndAllowThreads(__tstate);
46435 if (PyErr_Occurred()) SWIG_fail;
46436 }
46437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46438 return resultobj;
46439 fail:
46440 return NULL;
46441 }
46442
46443
46444 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46445 PyObject *resultobj = 0;
46446 wxSizer *arg1 = (wxSizer *) 0 ;
46447 int arg2 ;
46448 int arg3 ;
46449 int arg4 ;
46450 PyObject *arg5 = (PyObject *) NULL ;
46451 wxSizerItem *result = 0 ;
46452 int res1 = 0 ;
46453 int val2 ;
46454 int ecode2 = 0 ;
46455 int val3 ;
46456 int ecode3 = 0 ;
46457 int val4 ;
46458 int ecode4 = 0 ;
46459 PyObject * obj0 = 0 ;
46460 PyObject * obj1 = 0 ;
46461 PyObject * obj2 = 0 ;
46462 PyObject * obj3 = 0 ;
46463 PyObject * obj4 = 0 ;
46464 char * kwnames[] = {
46465 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46466 };
46467
46468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46469 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46470 if (!SWIG_IsOK(res1)) {
46471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46472 }
46473 ecode2 = SWIG_AsVal_int(obj1, &val2);
46474 if (!SWIG_IsOK(ecode2)) {
46475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
46476 }
46477 arg2 = static_cast< int >(val2);
46478 ecode3 = SWIG_AsVal_int(obj2, &val3);
46479 if (!SWIG_IsOK(ecode3)) {
46480 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
46481 }
46482 arg3 = static_cast< int >(val3);
46483 ecode4 = SWIG_AsVal_int(obj3, &val4);
46484 if (!SWIG_IsOK(ecode4)) {
46485 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
46486 }
46487 arg4 = static_cast< int >(val4);
46488 if (obj4) {
46489 arg5 = obj4;
46490 }
46491 {
46492 PyThreadState* __tstate = wxPyBeginAllowThreads();
46493 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46494 wxPyEndAllowThreads(__tstate);
46495 if (PyErr_Occurred()) SWIG_fail;
46496 }
46497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46498 return resultobj;
46499 fail:
46500 return NULL;
46501 }
46502
46503
46504 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46505 PyObject *resultobj = 0;
46506 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46507 void *argp1 = 0 ;
46508 int res1 = 0 ;
46509 PyObject *swig_obj[1] ;
46510
46511 if (!args) SWIG_fail;
46512 swig_obj[0] = args;
46513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46514 if (!SWIG_IsOK(res1)) {
46515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46516 }
46517 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46518 {
46519 PyThreadState* __tstate = wxPyBeginAllowThreads();
46520 (arg1)->DeleteWindows();
46521 wxPyEndAllowThreads(__tstate);
46522 if (PyErr_Occurred()) SWIG_fail;
46523 }
46524 resultobj = SWIG_Py_Void();
46525 return resultobj;
46526 fail:
46527 return NULL;
46528 }
46529
46530
46531 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46532 PyObject *resultobj = 0;
46533 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46534 void *argp1 = 0 ;
46535 int res1 = 0 ;
46536 PyObject *swig_obj[1] ;
46537
46538 if (!args) SWIG_fail;
46539 swig_obj[0] = args;
46540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46541 if (!SWIG_IsOK(res1)) {
46542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46543 }
46544 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46545 {
46546 PyThreadState* __tstate = wxPyBeginAllowThreads();
46547 (arg1)->DetachSizer();
46548 wxPyEndAllowThreads(__tstate);
46549 if (PyErr_Occurred()) SWIG_fail;
46550 }
46551 resultobj = SWIG_Py_Void();
46552 return resultobj;
46553 fail:
46554 return NULL;
46555 }
46556
46557
46558 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46559 PyObject *resultobj = 0;
46560 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46561 wxSize result;
46562 void *argp1 = 0 ;
46563 int res1 = 0 ;
46564 PyObject *swig_obj[1] ;
46565
46566 if (!args) SWIG_fail;
46567 swig_obj[0] = args;
46568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46569 if (!SWIG_IsOK(res1)) {
46570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46571 }
46572 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46573 {
46574 PyThreadState* __tstate = wxPyBeginAllowThreads();
46575 result = (arg1)->GetSize();
46576 wxPyEndAllowThreads(__tstate);
46577 if (PyErr_Occurred()) SWIG_fail;
46578 }
46579 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46580 return resultobj;
46581 fail:
46582 return NULL;
46583 }
46584
46585
46586 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46587 PyObject *resultobj = 0;
46588 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46589 wxSize result;
46590 void *argp1 = 0 ;
46591 int res1 = 0 ;
46592 PyObject *swig_obj[1] ;
46593
46594 if (!args) SWIG_fail;
46595 swig_obj[0] = args;
46596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46597 if (!SWIG_IsOK(res1)) {
46598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46599 }
46600 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46601 {
46602 PyThreadState* __tstate = wxPyBeginAllowThreads();
46603 result = (arg1)->CalcMin();
46604 wxPyEndAllowThreads(__tstate);
46605 if (PyErr_Occurred()) SWIG_fail;
46606 }
46607 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46608 return resultobj;
46609 fail:
46610 return NULL;
46611 }
46612
46613
46614 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46615 PyObject *resultobj = 0;
46616 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46617 wxPoint *arg2 = 0 ;
46618 wxSize *arg3 = 0 ;
46619 void *argp1 = 0 ;
46620 int res1 = 0 ;
46621 wxPoint temp2 ;
46622 wxSize temp3 ;
46623 PyObject * obj0 = 0 ;
46624 PyObject * obj1 = 0 ;
46625 PyObject * obj2 = 0 ;
46626 char * kwnames[] = {
46627 (char *) "self",(char *) "pos",(char *) "size", NULL
46628 };
46629
46630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46632 if (!SWIG_IsOK(res1)) {
46633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46634 }
46635 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46636 {
46637 arg2 = &temp2;
46638 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46639 }
46640 {
46641 arg3 = &temp3;
46642 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46643 }
46644 {
46645 PyThreadState* __tstate = wxPyBeginAllowThreads();
46646 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
46647 wxPyEndAllowThreads(__tstate);
46648 if (PyErr_Occurred()) SWIG_fail;
46649 }
46650 resultobj = SWIG_Py_Void();
46651 return resultobj;
46652 fail:
46653 return NULL;
46654 }
46655
46656
46657 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46658 PyObject *resultobj = 0;
46659 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46660 wxSize result;
46661 void *argp1 = 0 ;
46662 int res1 = 0 ;
46663 PyObject *swig_obj[1] ;
46664
46665 if (!args) SWIG_fail;
46666 swig_obj[0] = args;
46667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46668 if (!SWIG_IsOK(res1)) {
46669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46670 }
46671 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46672 {
46673 PyThreadState* __tstate = wxPyBeginAllowThreads();
46674 result = (arg1)->GetMinSize();
46675 wxPyEndAllowThreads(__tstate);
46676 if (PyErr_Occurred()) SWIG_fail;
46677 }
46678 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46679 return resultobj;
46680 fail:
46681 return NULL;
46682 }
46683
46684
46685 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46686 PyObject *resultobj = 0;
46687 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46688 wxSize result;
46689 void *argp1 = 0 ;
46690 int res1 = 0 ;
46691 PyObject *swig_obj[1] ;
46692
46693 if (!args) SWIG_fail;
46694 swig_obj[0] = args;
46695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46696 if (!SWIG_IsOK(res1)) {
46697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46698 }
46699 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46700 {
46701 PyThreadState* __tstate = wxPyBeginAllowThreads();
46702 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46703 wxPyEndAllowThreads(__tstate);
46704 if (PyErr_Occurred()) SWIG_fail;
46705 }
46706 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46707 return resultobj;
46708 fail:
46709 return NULL;
46710 }
46711
46712
46713 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46714 PyObject *resultobj = 0;
46715 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46716 int arg2 ;
46717 int arg3 ;
46718 void *argp1 = 0 ;
46719 int res1 = 0 ;
46720 int val2 ;
46721 int ecode2 = 0 ;
46722 int val3 ;
46723 int ecode3 = 0 ;
46724 PyObject * obj0 = 0 ;
46725 PyObject * obj1 = 0 ;
46726 PyObject * obj2 = 0 ;
46727 char * kwnames[] = {
46728 (char *) "self",(char *) "x",(char *) "y", NULL
46729 };
46730
46731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46733 if (!SWIG_IsOK(res1)) {
46734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46735 }
46736 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46737 ecode2 = SWIG_AsVal_int(obj1, &val2);
46738 if (!SWIG_IsOK(ecode2)) {
46739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46740 }
46741 arg2 = static_cast< int >(val2);
46742 ecode3 = SWIG_AsVal_int(obj2, &val3);
46743 if (!SWIG_IsOK(ecode3)) {
46744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46745 }
46746 arg3 = static_cast< int >(val3);
46747 {
46748 PyThreadState* __tstate = wxPyBeginAllowThreads();
46749 (arg1)->SetInitSize(arg2,arg3);
46750 wxPyEndAllowThreads(__tstate);
46751 if (PyErr_Occurred()) SWIG_fail;
46752 }
46753 resultobj = SWIG_Py_Void();
46754 return resultobj;
46755 fail:
46756 return NULL;
46757 }
46758
46759
46760 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46761 PyObject *resultobj = 0;
46762 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46763 int arg2 ;
46764 int arg3 ;
46765 void *argp1 = 0 ;
46766 int res1 = 0 ;
46767 int val2 ;
46768 int ecode2 = 0 ;
46769 int val3 ;
46770 int ecode3 = 0 ;
46771 PyObject * obj0 = 0 ;
46772 PyObject * obj1 = 0 ;
46773 PyObject * obj2 = 0 ;
46774 char * kwnames[] = {
46775 (char *) "self",(char *) "width",(char *) "height", NULL
46776 };
46777
46778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46780 if (!SWIG_IsOK(res1)) {
46781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46782 }
46783 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46784 ecode2 = SWIG_AsVal_int(obj1, &val2);
46785 if (!SWIG_IsOK(ecode2)) {
46786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46787 }
46788 arg2 = static_cast< int >(val2);
46789 ecode3 = SWIG_AsVal_int(obj2, &val3);
46790 if (!SWIG_IsOK(ecode3)) {
46791 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46792 }
46793 arg3 = static_cast< int >(val3);
46794 {
46795 PyThreadState* __tstate = wxPyBeginAllowThreads();
46796 (arg1)->SetRatio(arg2,arg3);
46797 wxPyEndAllowThreads(__tstate);
46798 if (PyErr_Occurred()) SWIG_fail;
46799 }
46800 resultobj = SWIG_Py_Void();
46801 return resultobj;
46802 fail:
46803 return NULL;
46804 }
46805
46806
46807 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46808 PyObject *resultobj = 0;
46809 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46810 wxSize *arg2 = 0 ;
46811 void *argp1 = 0 ;
46812 int res1 = 0 ;
46813 wxSize temp2 ;
46814 PyObject * obj0 = 0 ;
46815 PyObject * obj1 = 0 ;
46816 char * kwnames[] = {
46817 (char *) "self",(char *) "size", NULL
46818 };
46819
46820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46822 if (!SWIG_IsOK(res1)) {
46823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46824 }
46825 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46826 {
46827 arg2 = &temp2;
46828 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46829 }
46830 {
46831 PyThreadState* __tstate = wxPyBeginAllowThreads();
46832 (arg1)->SetRatio((wxSize const &)*arg2);
46833 wxPyEndAllowThreads(__tstate);
46834 if (PyErr_Occurred()) SWIG_fail;
46835 }
46836 resultobj = SWIG_Py_Void();
46837 return resultobj;
46838 fail:
46839 return NULL;
46840 }
46841
46842
46843 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46844 PyObject *resultobj = 0;
46845 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46846 float arg2 ;
46847 void *argp1 = 0 ;
46848 int res1 = 0 ;
46849 float val2 ;
46850 int ecode2 = 0 ;
46851 PyObject * obj0 = 0 ;
46852 PyObject * obj1 = 0 ;
46853 char * kwnames[] = {
46854 (char *) "self",(char *) "ratio", NULL
46855 };
46856
46857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46859 if (!SWIG_IsOK(res1)) {
46860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46861 }
46862 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46863 ecode2 = SWIG_AsVal_float(obj1, &val2);
46864 if (!SWIG_IsOK(ecode2)) {
46865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46866 }
46867 arg2 = static_cast< float >(val2);
46868 {
46869 PyThreadState* __tstate = wxPyBeginAllowThreads();
46870 (arg1)->SetRatio(arg2);
46871 wxPyEndAllowThreads(__tstate);
46872 if (PyErr_Occurred()) SWIG_fail;
46873 }
46874 resultobj = SWIG_Py_Void();
46875 return resultobj;
46876 fail:
46877 return NULL;
46878 }
46879
46880
46881 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46882 PyObject *resultobj = 0;
46883 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46884 float result;
46885 void *argp1 = 0 ;
46886 int res1 = 0 ;
46887 PyObject *swig_obj[1] ;
46888
46889 if (!args) SWIG_fail;
46890 swig_obj[0] = args;
46891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46892 if (!SWIG_IsOK(res1)) {
46893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46894 }
46895 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46896 {
46897 PyThreadState* __tstate = wxPyBeginAllowThreads();
46898 result = (float)(arg1)->GetRatio();
46899 wxPyEndAllowThreads(__tstate);
46900 if (PyErr_Occurred()) SWIG_fail;
46901 }
46902 resultobj = SWIG_From_float(static_cast< float >(result));
46903 return resultobj;
46904 fail:
46905 return NULL;
46906 }
46907
46908
46909 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46910 PyObject *resultobj = 0;
46911 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46912 wxRect result;
46913 void *argp1 = 0 ;
46914 int res1 = 0 ;
46915 PyObject *swig_obj[1] ;
46916
46917 if (!args) SWIG_fail;
46918 swig_obj[0] = args;
46919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46920 if (!SWIG_IsOK(res1)) {
46921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46922 }
46923 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46924 {
46925 PyThreadState* __tstate = wxPyBeginAllowThreads();
46926 result = (arg1)->GetRect();
46927 wxPyEndAllowThreads(__tstate);
46928 if (PyErr_Occurred()) SWIG_fail;
46929 }
46930 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46931 return resultobj;
46932 fail:
46933 return NULL;
46934 }
46935
46936
46937 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46938 PyObject *resultobj = 0;
46939 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46940 bool result;
46941 void *argp1 = 0 ;
46942 int res1 = 0 ;
46943 PyObject *swig_obj[1] ;
46944
46945 if (!args) SWIG_fail;
46946 swig_obj[0] = args;
46947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46948 if (!SWIG_IsOK(res1)) {
46949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46950 }
46951 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46952 {
46953 PyThreadState* __tstate = wxPyBeginAllowThreads();
46954 result = (bool)(arg1)->IsWindow();
46955 wxPyEndAllowThreads(__tstate);
46956 if (PyErr_Occurred()) SWIG_fail;
46957 }
46958 {
46959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46960 }
46961 return resultobj;
46962 fail:
46963 return NULL;
46964 }
46965
46966
46967 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46968 PyObject *resultobj = 0;
46969 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46970 bool result;
46971 void *argp1 = 0 ;
46972 int res1 = 0 ;
46973 PyObject *swig_obj[1] ;
46974
46975 if (!args) SWIG_fail;
46976 swig_obj[0] = args;
46977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46978 if (!SWIG_IsOK(res1)) {
46979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46980 }
46981 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46982 {
46983 PyThreadState* __tstate = wxPyBeginAllowThreads();
46984 result = (bool)(arg1)->IsSizer();
46985 wxPyEndAllowThreads(__tstate);
46986 if (PyErr_Occurred()) SWIG_fail;
46987 }
46988 {
46989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46990 }
46991 return resultobj;
46992 fail:
46993 return NULL;
46994 }
46995
46996
46997 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46998 PyObject *resultobj = 0;
46999 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47000 bool result;
47001 void *argp1 = 0 ;
47002 int res1 = 0 ;
47003 PyObject *swig_obj[1] ;
47004
47005 if (!args) SWIG_fail;
47006 swig_obj[0] = args;
47007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47008 if (!SWIG_IsOK(res1)) {
47009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47010 }
47011 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47012 {
47013 PyThreadState* __tstate = wxPyBeginAllowThreads();
47014 result = (bool)(arg1)->IsSpacer();
47015 wxPyEndAllowThreads(__tstate);
47016 if (PyErr_Occurred()) SWIG_fail;
47017 }
47018 {
47019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47020 }
47021 return resultobj;
47022 fail:
47023 return NULL;
47024 }
47025
47026
47027 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47028 PyObject *resultobj = 0;
47029 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47030 int arg2 ;
47031 void *argp1 = 0 ;
47032 int res1 = 0 ;
47033 int val2 ;
47034 int ecode2 = 0 ;
47035 PyObject * obj0 = 0 ;
47036 PyObject * obj1 = 0 ;
47037 char * kwnames[] = {
47038 (char *) "self",(char *) "proportion", NULL
47039 };
47040
47041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
47042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47043 if (!SWIG_IsOK(res1)) {
47044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47045 }
47046 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47047 ecode2 = SWIG_AsVal_int(obj1, &val2);
47048 if (!SWIG_IsOK(ecode2)) {
47049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
47050 }
47051 arg2 = static_cast< int >(val2);
47052 {
47053 PyThreadState* __tstate = wxPyBeginAllowThreads();
47054 (arg1)->SetProportion(arg2);
47055 wxPyEndAllowThreads(__tstate);
47056 if (PyErr_Occurred()) SWIG_fail;
47057 }
47058 resultobj = SWIG_Py_Void();
47059 return resultobj;
47060 fail:
47061 return NULL;
47062 }
47063
47064
47065 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47066 PyObject *resultobj = 0;
47067 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47068 int result;
47069 void *argp1 = 0 ;
47070 int res1 = 0 ;
47071 PyObject *swig_obj[1] ;
47072
47073 if (!args) SWIG_fail;
47074 swig_obj[0] = args;
47075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47076 if (!SWIG_IsOK(res1)) {
47077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47078 }
47079 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47080 {
47081 PyThreadState* __tstate = wxPyBeginAllowThreads();
47082 result = (int)(arg1)->GetProportion();
47083 wxPyEndAllowThreads(__tstate);
47084 if (PyErr_Occurred()) SWIG_fail;
47085 }
47086 resultobj = SWIG_From_int(static_cast< int >(result));
47087 return resultobj;
47088 fail:
47089 return NULL;
47090 }
47091
47092
47093 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47094 PyObject *resultobj = 0;
47095 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47096 int arg2 ;
47097 void *argp1 = 0 ;
47098 int res1 = 0 ;
47099 int val2 ;
47100 int ecode2 = 0 ;
47101 PyObject * obj0 = 0 ;
47102 PyObject * obj1 = 0 ;
47103 char * kwnames[] = {
47104 (char *) "self",(char *) "flag", NULL
47105 };
47106
47107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
47108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47109 if (!SWIG_IsOK(res1)) {
47110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47111 }
47112 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47113 ecode2 = SWIG_AsVal_int(obj1, &val2);
47114 if (!SWIG_IsOK(ecode2)) {
47115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
47116 }
47117 arg2 = static_cast< int >(val2);
47118 {
47119 PyThreadState* __tstate = wxPyBeginAllowThreads();
47120 (arg1)->SetFlag(arg2);
47121 wxPyEndAllowThreads(__tstate);
47122 if (PyErr_Occurred()) SWIG_fail;
47123 }
47124 resultobj = SWIG_Py_Void();
47125 return resultobj;
47126 fail:
47127 return NULL;
47128 }
47129
47130
47131 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47132 PyObject *resultobj = 0;
47133 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47134 int result;
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_wxSizerItem, 0 | 0 );
47142 if (!SWIG_IsOK(res1)) {
47143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47144 }
47145 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47146 {
47147 PyThreadState* __tstate = wxPyBeginAllowThreads();
47148 result = (int)(arg1)->GetFlag();
47149 wxPyEndAllowThreads(__tstate);
47150 if (PyErr_Occurred()) SWIG_fail;
47151 }
47152 resultobj = SWIG_From_int(static_cast< int >(result));
47153 return resultobj;
47154 fail:
47155 return NULL;
47156 }
47157
47158
47159 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47160 PyObject *resultobj = 0;
47161 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47162 int arg2 ;
47163 void *argp1 = 0 ;
47164 int res1 = 0 ;
47165 int val2 ;
47166 int ecode2 = 0 ;
47167 PyObject * obj0 = 0 ;
47168 PyObject * obj1 = 0 ;
47169 char * kwnames[] = {
47170 (char *) "self",(char *) "border", NULL
47171 };
47172
47173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
47174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47175 if (!SWIG_IsOK(res1)) {
47176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47177 }
47178 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47179 ecode2 = SWIG_AsVal_int(obj1, &val2);
47180 if (!SWIG_IsOK(ecode2)) {
47181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
47182 }
47183 arg2 = static_cast< int >(val2);
47184 {
47185 PyThreadState* __tstate = wxPyBeginAllowThreads();
47186 (arg1)->SetBorder(arg2);
47187 wxPyEndAllowThreads(__tstate);
47188 if (PyErr_Occurred()) SWIG_fail;
47189 }
47190 resultobj = SWIG_Py_Void();
47191 return resultobj;
47192 fail:
47193 return NULL;
47194 }
47195
47196
47197 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47198 PyObject *resultobj = 0;
47199 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47200 int result;
47201 void *argp1 = 0 ;
47202 int res1 = 0 ;
47203 PyObject *swig_obj[1] ;
47204
47205 if (!args) SWIG_fail;
47206 swig_obj[0] = args;
47207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47208 if (!SWIG_IsOK(res1)) {
47209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47210 }
47211 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47212 {
47213 PyThreadState* __tstate = wxPyBeginAllowThreads();
47214 result = (int)(arg1)->GetBorder();
47215 wxPyEndAllowThreads(__tstate);
47216 if (PyErr_Occurred()) SWIG_fail;
47217 }
47218 resultobj = SWIG_From_int(static_cast< int >(result));
47219 return resultobj;
47220 fail:
47221 return NULL;
47222 }
47223
47224
47225 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47226 PyObject *resultobj = 0;
47227 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47228 wxWindow *result = 0 ;
47229 void *argp1 = 0 ;
47230 int res1 = 0 ;
47231 PyObject *swig_obj[1] ;
47232
47233 if (!args) SWIG_fail;
47234 swig_obj[0] = args;
47235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47236 if (!SWIG_IsOK(res1)) {
47237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47238 }
47239 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47240 {
47241 PyThreadState* __tstate = wxPyBeginAllowThreads();
47242 result = (wxWindow *)(arg1)->GetWindow();
47243 wxPyEndAllowThreads(__tstate);
47244 if (PyErr_Occurred()) SWIG_fail;
47245 }
47246 {
47247 resultobj = wxPyMake_wxObject(result, 0);
47248 }
47249 return resultobj;
47250 fail:
47251 return NULL;
47252 }
47253
47254
47255 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47256 PyObject *resultobj = 0;
47257 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47258 wxWindow *arg2 = (wxWindow *) 0 ;
47259 void *argp1 = 0 ;
47260 int res1 = 0 ;
47261 void *argp2 = 0 ;
47262 int res2 = 0 ;
47263 PyObject * obj0 = 0 ;
47264 PyObject * obj1 = 0 ;
47265 char * kwnames[] = {
47266 (char *) "self",(char *) "window", NULL
47267 };
47268
47269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47271 if (!SWIG_IsOK(res1)) {
47272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47273 }
47274 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47275 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47276 if (!SWIG_IsOK(res2)) {
47277 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47278 }
47279 arg2 = reinterpret_cast< wxWindow * >(argp2);
47280 {
47281 PyThreadState* __tstate = wxPyBeginAllowThreads();
47282 (arg1)->SetWindow(arg2);
47283 wxPyEndAllowThreads(__tstate);
47284 if (PyErr_Occurred()) SWIG_fail;
47285 }
47286 resultobj = SWIG_Py_Void();
47287 return resultobj;
47288 fail:
47289 return NULL;
47290 }
47291
47292
47293 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47294 PyObject *resultobj = 0;
47295 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47296 wxSizer *result = 0 ;
47297 void *argp1 = 0 ;
47298 int res1 = 0 ;
47299 PyObject *swig_obj[1] ;
47300
47301 if (!args) SWIG_fail;
47302 swig_obj[0] = args;
47303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47304 if (!SWIG_IsOK(res1)) {
47305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47306 }
47307 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47308 {
47309 PyThreadState* __tstate = wxPyBeginAllowThreads();
47310 result = (wxSizer *)(arg1)->GetSizer();
47311 wxPyEndAllowThreads(__tstate);
47312 if (PyErr_Occurred()) SWIG_fail;
47313 }
47314 {
47315 resultobj = wxPyMake_wxObject(result, (bool)0);
47316 }
47317 return resultobj;
47318 fail:
47319 return NULL;
47320 }
47321
47322
47323 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47324 PyObject *resultobj = 0;
47325 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47326 wxSizer *arg2 = (wxSizer *) 0 ;
47327 void *argp1 = 0 ;
47328 int res1 = 0 ;
47329 int res2 = 0 ;
47330 PyObject * obj0 = 0 ;
47331 PyObject * obj1 = 0 ;
47332 char * kwnames[] = {
47333 (char *) "self",(char *) "sizer", NULL
47334 };
47335
47336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47338 if (!SWIG_IsOK(res1)) {
47339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47340 }
47341 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47342 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47343 if (!SWIG_IsOK(res2)) {
47344 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47345 }
47346 {
47347 PyThreadState* __tstate = wxPyBeginAllowThreads();
47348 (arg1)->SetSizer(arg2);
47349 wxPyEndAllowThreads(__tstate);
47350 if (PyErr_Occurred()) SWIG_fail;
47351 }
47352 resultobj = SWIG_Py_Void();
47353 return resultobj;
47354 fail:
47355 return NULL;
47356 }
47357
47358
47359 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47360 PyObject *resultobj = 0;
47361 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47362 wxSize result;
47363 void *argp1 = 0 ;
47364 int res1 = 0 ;
47365 PyObject *swig_obj[1] ;
47366
47367 if (!args) SWIG_fail;
47368 swig_obj[0] = args;
47369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47370 if (!SWIG_IsOK(res1)) {
47371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47372 }
47373 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47374 {
47375 PyThreadState* __tstate = wxPyBeginAllowThreads();
47376 result = (arg1)->GetSpacer();
47377 wxPyEndAllowThreads(__tstate);
47378 if (PyErr_Occurred()) SWIG_fail;
47379 }
47380 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47381 return resultobj;
47382 fail:
47383 return NULL;
47384 }
47385
47386
47387 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47388 PyObject *resultobj = 0;
47389 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47390 wxSize *arg2 = 0 ;
47391 void *argp1 = 0 ;
47392 int res1 = 0 ;
47393 wxSize temp2 ;
47394 PyObject * obj0 = 0 ;
47395 PyObject * obj1 = 0 ;
47396 char * kwnames[] = {
47397 (char *) "self",(char *) "size", NULL
47398 };
47399
47400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
47401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47402 if (!SWIG_IsOK(res1)) {
47403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47404 }
47405 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47406 {
47407 arg2 = &temp2;
47408 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47409 }
47410 {
47411 PyThreadState* __tstate = wxPyBeginAllowThreads();
47412 (arg1)->SetSpacer((wxSize const &)*arg2);
47413 wxPyEndAllowThreads(__tstate);
47414 if (PyErr_Occurred()) SWIG_fail;
47415 }
47416 resultobj = SWIG_Py_Void();
47417 return resultobj;
47418 fail:
47419 return NULL;
47420 }
47421
47422
47423 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47424 PyObject *resultobj = 0;
47425 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47426 bool arg2 ;
47427 void *argp1 = 0 ;
47428 int res1 = 0 ;
47429 bool val2 ;
47430 int ecode2 = 0 ;
47431 PyObject * obj0 = 0 ;
47432 PyObject * obj1 = 0 ;
47433 char * kwnames[] = {
47434 (char *) "self",(char *) "show", NULL
47435 };
47436
47437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
47438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47439 if (!SWIG_IsOK(res1)) {
47440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47441 }
47442 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47443 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47444 if (!SWIG_IsOK(ecode2)) {
47445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
47446 }
47447 arg2 = static_cast< bool >(val2);
47448 {
47449 PyThreadState* __tstate = wxPyBeginAllowThreads();
47450 (arg1)->Show(arg2);
47451 wxPyEndAllowThreads(__tstate);
47452 if (PyErr_Occurred()) SWIG_fail;
47453 }
47454 resultobj = SWIG_Py_Void();
47455 return resultobj;
47456 fail:
47457 return NULL;
47458 }
47459
47460
47461 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47462 PyObject *resultobj = 0;
47463 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47464 bool result;
47465 void *argp1 = 0 ;
47466 int res1 = 0 ;
47467 PyObject *swig_obj[1] ;
47468
47469 if (!args) SWIG_fail;
47470 swig_obj[0] = args;
47471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47472 if (!SWIG_IsOK(res1)) {
47473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47474 }
47475 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47476 {
47477 PyThreadState* __tstate = wxPyBeginAllowThreads();
47478 result = (bool)(arg1)->IsShown();
47479 wxPyEndAllowThreads(__tstate);
47480 if (PyErr_Occurred()) SWIG_fail;
47481 }
47482 {
47483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47484 }
47485 return resultobj;
47486 fail:
47487 return NULL;
47488 }
47489
47490
47491 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47492 PyObject *resultobj = 0;
47493 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47494 wxPoint result;
47495 void *argp1 = 0 ;
47496 int res1 = 0 ;
47497 PyObject *swig_obj[1] ;
47498
47499 if (!args) SWIG_fail;
47500 swig_obj[0] = args;
47501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47502 if (!SWIG_IsOK(res1)) {
47503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47504 }
47505 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47506 {
47507 PyThreadState* __tstate = wxPyBeginAllowThreads();
47508 result = (arg1)->GetPosition();
47509 wxPyEndAllowThreads(__tstate);
47510 if (PyErr_Occurred()) SWIG_fail;
47511 }
47512 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47513 return resultobj;
47514 fail:
47515 return NULL;
47516 }
47517
47518
47519 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47520 PyObject *resultobj = 0;
47521 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47522 PyObject *result = 0 ;
47523 void *argp1 = 0 ;
47524 int res1 = 0 ;
47525 PyObject *swig_obj[1] ;
47526
47527 if (!args) SWIG_fail;
47528 swig_obj[0] = args;
47529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47530 if (!SWIG_IsOK(res1)) {
47531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47532 }
47533 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47534 {
47535 PyThreadState* __tstate = wxPyBeginAllowThreads();
47536 result = (PyObject *)wxSizerItem_GetUserData(arg1);
47537 wxPyEndAllowThreads(__tstate);
47538 if (PyErr_Occurred()) SWIG_fail;
47539 }
47540 resultobj = result;
47541 return resultobj;
47542 fail:
47543 return NULL;
47544 }
47545
47546
47547 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47548 PyObject *resultobj = 0;
47549 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47550 PyObject *arg2 = (PyObject *) 0 ;
47551 void *argp1 = 0 ;
47552 int res1 = 0 ;
47553 PyObject * obj0 = 0 ;
47554 PyObject * obj1 = 0 ;
47555 char * kwnames[] = {
47556 (char *) "self",(char *) "userData", NULL
47557 };
47558
47559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
47560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47561 if (!SWIG_IsOK(res1)) {
47562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47563 }
47564 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47565 arg2 = obj1;
47566 {
47567 PyThreadState* __tstate = wxPyBeginAllowThreads();
47568 wxSizerItem_SetUserData(arg1,arg2);
47569 wxPyEndAllowThreads(__tstate);
47570 if (PyErr_Occurred()) SWIG_fail;
47571 }
47572 resultobj = SWIG_Py_Void();
47573 return resultobj;
47574 fail:
47575 return NULL;
47576 }
47577
47578
47579 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47580 PyObject *obj;
47581 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47582 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
47583 return SWIG_Py_Void();
47584 }
47585
47586 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47587 return SWIG_Python_InitShadowInstance(args);
47588 }
47589
47590 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47591 PyObject *resultobj = 0;
47592 wxSizer *arg1 = (wxSizer *) 0 ;
47593 void *argp1 = 0 ;
47594 int res1 = 0 ;
47595 PyObject *swig_obj[1] ;
47596
47597 if (!args) SWIG_fail;
47598 swig_obj[0] = args;
47599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47600 if (!SWIG_IsOK(res1)) {
47601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47602 }
47603 arg1 = reinterpret_cast< wxSizer * >(argp1);
47604 {
47605 PyThreadState* __tstate = wxPyBeginAllowThreads();
47606 delete arg1;
47607
47608 wxPyEndAllowThreads(__tstate);
47609 if (PyErr_Occurred()) SWIG_fail;
47610 }
47611 resultobj = SWIG_Py_Void();
47612 return resultobj;
47613 fail:
47614 return NULL;
47615 }
47616
47617
47618 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47619 PyObject *resultobj = 0;
47620 wxSizer *arg1 = (wxSizer *) 0 ;
47621 PyObject *arg2 = (PyObject *) 0 ;
47622 void *argp1 = 0 ;
47623 int res1 = 0 ;
47624 PyObject * obj0 = 0 ;
47625 PyObject * obj1 = 0 ;
47626 char * kwnames[] = {
47627 (char *) "self",(char *) "_self", NULL
47628 };
47629
47630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
47631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47632 if (!SWIG_IsOK(res1)) {
47633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47634 }
47635 arg1 = reinterpret_cast< wxSizer * >(argp1);
47636 arg2 = obj1;
47637 {
47638 PyThreadState* __tstate = wxPyBeginAllowThreads();
47639 wxSizer__setOORInfo(arg1,arg2);
47640 wxPyEndAllowThreads(__tstate);
47641 if (PyErr_Occurred()) SWIG_fail;
47642 }
47643 resultobj = SWIG_Py_Void();
47644 return resultobj;
47645 fail:
47646 return NULL;
47647 }
47648
47649
47650 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47651 PyObject *resultobj = 0;
47652 wxSizer *arg1 = (wxSizer *) 0 ;
47653 PyObject *arg2 = (PyObject *) 0 ;
47654 int arg3 = (int) 0 ;
47655 int arg4 = (int) 0 ;
47656 int arg5 = (int) 0 ;
47657 PyObject *arg6 = (PyObject *) NULL ;
47658 wxSizerItem *result = 0 ;
47659 void *argp1 = 0 ;
47660 int res1 = 0 ;
47661 int val3 ;
47662 int ecode3 = 0 ;
47663 int val4 ;
47664 int ecode4 = 0 ;
47665 int val5 ;
47666 int ecode5 = 0 ;
47667 PyObject * obj0 = 0 ;
47668 PyObject * obj1 = 0 ;
47669 PyObject * obj2 = 0 ;
47670 PyObject * obj3 = 0 ;
47671 PyObject * obj4 = 0 ;
47672 PyObject * obj5 = 0 ;
47673 char * kwnames[] = {
47674 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47675 };
47676
47677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47679 if (!SWIG_IsOK(res1)) {
47680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47681 }
47682 arg1 = reinterpret_cast< wxSizer * >(argp1);
47683 arg2 = obj1;
47684 if (obj2) {
47685 ecode3 = SWIG_AsVal_int(obj2, &val3);
47686 if (!SWIG_IsOK(ecode3)) {
47687 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47688 }
47689 arg3 = static_cast< int >(val3);
47690 }
47691 if (obj3) {
47692 ecode4 = SWIG_AsVal_int(obj3, &val4);
47693 if (!SWIG_IsOK(ecode4)) {
47694 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47695 }
47696 arg4 = static_cast< int >(val4);
47697 }
47698 if (obj4) {
47699 ecode5 = SWIG_AsVal_int(obj4, &val5);
47700 if (!SWIG_IsOK(ecode5)) {
47701 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47702 }
47703 arg5 = static_cast< int >(val5);
47704 }
47705 if (obj5) {
47706 arg6 = obj5;
47707 }
47708 {
47709 PyThreadState* __tstate = wxPyBeginAllowThreads();
47710 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47711 wxPyEndAllowThreads(__tstate);
47712 if (PyErr_Occurred()) SWIG_fail;
47713 }
47714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47715 return resultobj;
47716 fail:
47717 return NULL;
47718 }
47719
47720
47721 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47722 PyObject *resultobj = 0;
47723 wxSizer *arg1 = (wxSizer *) 0 ;
47724 int arg2 ;
47725 PyObject *arg3 = (PyObject *) 0 ;
47726 int arg4 = (int) 0 ;
47727 int arg5 = (int) 0 ;
47728 int arg6 = (int) 0 ;
47729 PyObject *arg7 = (PyObject *) NULL ;
47730 wxSizerItem *result = 0 ;
47731 void *argp1 = 0 ;
47732 int res1 = 0 ;
47733 int val2 ;
47734 int ecode2 = 0 ;
47735 int val4 ;
47736 int ecode4 = 0 ;
47737 int val5 ;
47738 int ecode5 = 0 ;
47739 int val6 ;
47740 int ecode6 = 0 ;
47741 PyObject * obj0 = 0 ;
47742 PyObject * obj1 = 0 ;
47743 PyObject * obj2 = 0 ;
47744 PyObject * obj3 = 0 ;
47745 PyObject * obj4 = 0 ;
47746 PyObject * obj5 = 0 ;
47747 PyObject * obj6 = 0 ;
47748 char * kwnames[] = {
47749 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47750 };
47751
47752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47754 if (!SWIG_IsOK(res1)) {
47755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47756 }
47757 arg1 = reinterpret_cast< wxSizer * >(argp1);
47758 ecode2 = SWIG_AsVal_int(obj1, &val2);
47759 if (!SWIG_IsOK(ecode2)) {
47760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47761 }
47762 arg2 = static_cast< int >(val2);
47763 arg3 = obj2;
47764 if (obj3) {
47765 ecode4 = SWIG_AsVal_int(obj3, &val4);
47766 if (!SWIG_IsOK(ecode4)) {
47767 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47768 }
47769 arg4 = static_cast< int >(val4);
47770 }
47771 if (obj4) {
47772 ecode5 = SWIG_AsVal_int(obj4, &val5);
47773 if (!SWIG_IsOK(ecode5)) {
47774 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47775 }
47776 arg5 = static_cast< int >(val5);
47777 }
47778 if (obj5) {
47779 ecode6 = SWIG_AsVal_int(obj5, &val6);
47780 if (!SWIG_IsOK(ecode6)) {
47781 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47782 }
47783 arg6 = static_cast< int >(val6);
47784 }
47785 if (obj6) {
47786 arg7 = obj6;
47787 }
47788 {
47789 PyThreadState* __tstate = wxPyBeginAllowThreads();
47790 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47791 wxPyEndAllowThreads(__tstate);
47792 if (PyErr_Occurred()) SWIG_fail;
47793 }
47794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47795 return resultobj;
47796 fail:
47797 return NULL;
47798 }
47799
47800
47801 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47802 PyObject *resultobj = 0;
47803 wxSizer *arg1 = (wxSizer *) 0 ;
47804 PyObject *arg2 = (PyObject *) 0 ;
47805 int arg3 = (int) 0 ;
47806 int arg4 = (int) 0 ;
47807 int arg5 = (int) 0 ;
47808 PyObject *arg6 = (PyObject *) NULL ;
47809 wxSizerItem *result = 0 ;
47810 void *argp1 = 0 ;
47811 int res1 = 0 ;
47812 int val3 ;
47813 int ecode3 = 0 ;
47814 int val4 ;
47815 int ecode4 = 0 ;
47816 int val5 ;
47817 int ecode5 = 0 ;
47818 PyObject * obj0 = 0 ;
47819 PyObject * obj1 = 0 ;
47820 PyObject * obj2 = 0 ;
47821 PyObject * obj3 = 0 ;
47822 PyObject * obj4 = 0 ;
47823 PyObject * obj5 = 0 ;
47824 char * kwnames[] = {
47825 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47826 };
47827
47828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47830 if (!SWIG_IsOK(res1)) {
47831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
47832 }
47833 arg1 = reinterpret_cast< wxSizer * >(argp1);
47834 arg2 = obj1;
47835 if (obj2) {
47836 ecode3 = SWIG_AsVal_int(obj2, &val3);
47837 if (!SWIG_IsOK(ecode3)) {
47838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
47839 }
47840 arg3 = static_cast< int >(val3);
47841 }
47842 if (obj3) {
47843 ecode4 = SWIG_AsVal_int(obj3, &val4);
47844 if (!SWIG_IsOK(ecode4)) {
47845 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
47846 }
47847 arg4 = static_cast< int >(val4);
47848 }
47849 if (obj4) {
47850 ecode5 = SWIG_AsVal_int(obj4, &val5);
47851 if (!SWIG_IsOK(ecode5)) {
47852 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
47853 }
47854 arg5 = static_cast< int >(val5);
47855 }
47856 if (obj5) {
47857 arg6 = obj5;
47858 }
47859 {
47860 PyThreadState* __tstate = wxPyBeginAllowThreads();
47861 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
47862 wxPyEndAllowThreads(__tstate);
47863 if (PyErr_Occurred()) SWIG_fail;
47864 }
47865 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47866 return resultobj;
47867 fail:
47868 return NULL;
47869 }
47870
47871
47872 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47873 PyObject *resultobj = 0;
47874 wxSizer *arg1 = (wxSizer *) 0 ;
47875 PyObject *arg2 = (PyObject *) 0 ;
47876 bool result;
47877 void *argp1 = 0 ;
47878 int res1 = 0 ;
47879 PyObject * obj0 = 0 ;
47880 PyObject * obj1 = 0 ;
47881 char * kwnames[] = {
47882 (char *) "self",(char *) "item", NULL
47883 };
47884
47885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
47886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47887 if (!SWIG_IsOK(res1)) {
47888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47889 }
47890 arg1 = reinterpret_cast< wxSizer * >(argp1);
47891 arg2 = obj1;
47892 {
47893 PyThreadState* __tstate = wxPyBeginAllowThreads();
47894 result = (bool)wxSizer_Remove(arg1,arg2);
47895 wxPyEndAllowThreads(__tstate);
47896 if (PyErr_Occurred()) SWIG_fail;
47897 }
47898 {
47899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47900 }
47901 return resultobj;
47902 fail:
47903 return NULL;
47904 }
47905
47906
47907 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47908 PyObject *resultobj = 0;
47909 wxSizer *arg1 = (wxSizer *) 0 ;
47910 PyObject *arg2 = (PyObject *) 0 ;
47911 bool result;
47912 void *argp1 = 0 ;
47913 int res1 = 0 ;
47914 PyObject * obj0 = 0 ;
47915 PyObject * obj1 = 0 ;
47916 char * kwnames[] = {
47917 (char *) "self",(char *) "item", NULL
47918 };
47919
47920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47922 if (!SWIG_IsOK(res1)) {
47923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47924 }
47925 arg1 = reinterpret_cast< wxSizer * >(argp1);
47926 arg2 = obj1;
47927 {
47928 PyThreadState* __tstate = wxPyBeginAllowThreads();
47929 result = (bool)wxSizer_Detach(arg1,arg2);
47930 wxPyEndAllowThreads(__tstate);
47931 if (PyErr_Occurred()) SWIG_fail;
47932 }
47933 {
47934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47935 }
47936 return resultobj;
47937 fail:
47938 return NULL;
47939 }
47940
47941
47942 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47943 PyObject *resultobj = 0;
47944 wxSizer *arg1 = (wxSizer *) 0 ;
47945 PyObject *arg2 = (PyObject *) 0 ;
47946 wxSizerItem *result = 0 ;
47947 void *argp1 = 0 ;
47948 int res1 = 0 ;
47949 PyObject * obj0 = 0 ;
47950 PyObject * obj1 = 0 ;
47951 char * kwnames[] = {
47952 (char *) "self",(char *) "item", NULL
47953 };
47954
47955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47957 if (!SWIG_IsOK(res1)) {
47958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47959 }
47960 arg1 = reinterpret_cast< wxSizer * >(argp1);
47961 arg2 = obj1;
47962 {
47963 PyThreadState* __tstate = wxPyBeginAllowThreads();
47964 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47965 wxPyEndAllowThreads(__tstate);
47966 if (PyErr_Occurred()) SWIG_fail;
47967 }
47968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47969 return resultobj;
47970 fail:
47971 return NULL;
47972 }
47973
47974
47975 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47976 PyObject *resultobj = 0;
47977 wxSizer *arg1 = (wxSizer *) 0 ;
47978 PyObject *arg2 = (PyObject *) 0 ;
47979 wxSize *arg3 = 0 ;
47980 void *argp1 = 0 ;
47981 int res1 = 0 ;
47982 wxSize temp3 ;
47983 PyObject * obj0 = 0 ;
47984 PyObject * obj1 = 0 ;
47985 PyObject * obj2 = 0 ;
47986 char * kwnames[] = {
47987 (char *) "self",(char *) "item",(char *) "size", NULL
47988 };
47989
47990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47992 if (!SWIG_IsOK(res1)) {
47993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47994 }
47995 arg1 = reinterpret_cast< wxSizer * >(argp1);
47996 arg2 = obj1;
47997 {
47998 arg3 = &temp3;
47999 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48000 }
48001 {
48002 PyThreadState* __tstate = wxPyBeginAllowThreads();
48003 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
48004 wxPyEndAllowThreads(__tstate);
48005 if (PyErr_Occurred()) SWIG_fail;
48006 }
48007 resultobj = SWIG_Py_Void();
48008 return resultobj;
48009 fail:
48010 return NULL;
48011 }
48012
48013
48014 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48015 PyObject *resultobj = 0;
48016 wxSizer *arg1 = (wxSizer *) 0 ;
48017 wxWindow *arg2 = (wxWindow *) 0 ;
48018 wxWindow *arg3 = (wxWindow *) 0 ;
48019 bool arg4 = (bool) false ;
48020 bool result;
48021 void *argp1 = 0 ;
48022 int res1 = 0 ;
48023 void *argp2 = 0 ;
48024 int res2 = 0 ;
48025 void *argp3 = 0 ;
48026 int res3 = 0 ;
48027 bool val4 ;
48028 int ecode4 = 0 ;
48029 PyObject * obj0 = 0 ;
48030 PyObject * obj1 = 0 ;
48031 PyObject * obj2 = 0 ;
48032 PyObject * obj3 = 0 ;
48033 char * kwnames[] = {
48034 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
48035 };
48036
48037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48039 if (!SWIG_IsOK(res1)) {
48040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
48041 }
48042 arg1 = reinterpret_cast< wxSizer * >(argp1);
48043 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48044 if (!SWIG_IsOK(res2)) {
48045 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
48046 }
48047 arg2 = reinterpret_cast< wxWindow * >(argp2);
48048 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
48049 if (!SWIG_IsOK(res3)) {
48050 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
48051 }
48052 arg3 = reinterpret_cast< wxWindow * >(argp3);
48053 if (obj3) {
48054 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48055 if (!SWIG_IsOK(ecode4)) {
48056 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
48057 }
48058 arg4 = static_cast< bool >(val4);
48059 }
48060 {
48061 PyThreadState* __tstate = wxPyBeginAllowThreads();
48062 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
48063 wxPyEndAllowThreads(__tstate);
48064 if (PyErr_Occurred()) SWIG_fail;
48065 }
48066 {
48067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48068 }
48069 return resultobj;
48070 fail:
48071 return NULL;
48072 }
48073
48074
48075 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48076 PyObject *resultobj = 0;
48077 wxSizer *arg1 = (wxSizer *) 0 ;
48078 wxSizer *arg2 = (wxSizer *) 0 ;
48079 wxSizer *arg3 = (wxSizer *) 0 ;
48080 bool arg4 = (bool) false ;
48081 bool result;
48082 void *argp1 = 0 ;
48083 int res1 = 0 ;
48084 void *argp2 = 0 ;
48085 int res2 = 0 ;
48086 void *argp3 = 0 ;
48087 int res3 = 0 ;
48088 bool val4 ;
48089 int ecode4 = 0 ;
48090 PyObject * obj0 = 0 ;
48091 PyObject * obj1 = 0 ;
48092 PyObject * obj2 = 0 ;
48093 PyObject * obj3 = 0 ;
48094 char * kwnames[] = {
48095 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
48096 };
48097
48098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48100 if (!SWIG_IsOK(res1)) {
48101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48102 }
48103 arg1 = reinterpret_cast< wxSizer * >(argp1);
48104 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
48105 if (!SWIG_IsOK(res2)) {
48106 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
48107 }
48108 arg2 = reinterpret_cast< wxSizer * >(argp2);
48109 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
48110 if (!SWIG_IsOK(res3)) {
48111 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
48112 }
48113 arg3 = reinterpret_cast< wxSizer * >(argp3);
48114 if (obj3) {
48115 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48116 if (!SWIG_IsOK(ecode4)) {
48117 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
48118 }
48119 arg4 = static_cast< bool >(val4);
48120 }
48121 {
48122 PyThreadState* __tstate = wxPyBeginAllowThreads();
48123 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
48124 wxPyEndAllowThreads(__tstate);
48125 if (PyErr_Occurred()) SWIG_fail;
48126 }
48127 {
48128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48129 }
48130 return resultobj;
48131 fail:
48132 return NULL;
48133 }
48134
48135
48136 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48137 PyObject *resultobj = 0;
48138 wxSizer *arg1 = (wxSizer *) 0 ;
48139 size_t arg2 ;
48140 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
48141 bool result;
48142 void *argp1 = 0 ;
48143 int res1 = 0 ;
48144 size_t val2 ;
48145 int ecode2 = 0 ;
48146 void *argp3 = 0 ;
48147 int res3 = 0 ;
48148 PyObject * obj0 = 0 ;
48149 PyObject * obj1 = 0 ;
48150 PyObject * obj2 = 0 ;
48151 char * kwnames[] = {
48152 (char *) "self",(char *) "index",(char *) "newitem", NULL
48153 };
48154
48155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48157 if (!SWIG_IsOK(res1)) {
48158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48159 }
48160 arg1 = reinterpret_cast< wxSizer * >(argp1);
48161 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48162 if (!SWIG_IsOK(ecode2)) {
48163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
48164 }
48165 arg2 = static_cast< size_t >(val2);
48166 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48167 if (!SWIG_IsOK(res3)) {
48168 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
48169 }
48170 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
48171 {
48172 PyThreadState* __tstate = wxPyBeginAllowThreads();
48173 result = (bool)(arg1)->Replace(arg2,arg3);
48174 wxPyEndAllowThreads(__tstate);
48175 if (PyErr_Occurred()) SWIG_fail;
48176 }
48177 {
48178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48179 }
48180 return resultobj;
48181 fail:
48182 return NULL;
48183 }
48184
48185
48186 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48187 PyObject *resultobj = 0;
48188 wxSizer *arg1 = (wxSizer *) 0 ;
48189 wxWindow *arg2 = (wxWindow *) 0 ;
48190 void *argp1 = 0 ;
48191 int res1 = 0 ;
48192 void *argp2 = 0 ;
48193 int res2 = 0 ;
48194 PyObject * obj0 = 0 ;
48195 PyObject * obj1 = 0 ;
48196 char * kwnames[] = {
48197 (char *) "self",(char *) "window", NULL
48198 };
48199
48200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
48201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48202 if (!SWIG_IsOK(res1)) {
48203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
48204 }
48205 arg1 = reinterpret_cast< wxSizer * >(argp1);
48206 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48207 if (!SWIG_IsOK(res2)) {
48208 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
48209 }
48210 arg2 = reinterpret_cast< wxWindow * >(argp2);
48211 {
48212 PyThreadState* __tstate = wxPyBeginAllowThreads();
48213 (arg1)->SetContainingWindow(arg2);
48214 wxPyEndAllowThreads(__tstate);
48215 if (PyErr_Occurred()) SWIG_fail;
48216 }
48217 resultobj = SWIG_Py_Void();
48218 return resultobj;
48219 fail:
48220 return NULL;
48221 }
48222
48223
48224 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48225 PyObject *resultobj = 0;
48226 wxSizer *arg1 = (wxSizer *) 0 ;
48227 wxWindow *result = 0 ;
48228 void *argp1 = 0 ;
48229 int res1 = 0 ;
48230 PyObject *swig_obj[1] ;
48231
48232 if (!args) SWIG_fail;
48233 swig_obj[0] = args;
48234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48235 if (!SWIG_IsOK(res1)) {
48236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
48237 }
48238 arg1 = reinterpret_cast< wxSizer * >(argp1);
48239 {
48240 PyThreadState* __tstate = wxPyBeginAllowThreads();
48241 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
48242 wxPyEndAllowThreads(__tstate);
48243 if (PyErr_Occurred()) SWIG_fail;
48244 }
48245 {
48246 resultobj = wxPyMake_wxObject(result, 0);
48247 }
48248 return resultobj;
48249 fail:
48250 return NULL;
48251 }
48252
48253
48254 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48255 PyObject *resultobj = 0;
48256 wxSizer *arg1 = (wxSizer *) 0 ;
48257 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
48258 wxSizerItem *result = 0 ;
48259 void *argp1 = 0 ;
48260 int res1 = 0 ;
48261 int res2 = 0 ;
48262 PyObject * obj0 = 0 ;
48263 PyObject * obj1 = 0 ;
48264 char * kwnames[] = {
48265 (char *) "self",(char *) "item", NULL
48266 };
48267
48268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
48269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48270 if (!SWIG_IsOK(res1)) {
48271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48272 }
48273 arg1 = reinterpret_cast< wxSizer * >(argp1);
48274 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48275 if (!SWIG_IsOK(res2)) {
48276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
48277 }
48278 {
48279 PyThreadState* __tstate = wxPyBeginAllowThreads();
48280 result = (wxSizerItem *)(arg1)->Add(arg2);
48281 wxPyEndAllowThreads(__tstate);
48282 if (PyErr_Occurred()) SWIG_fail;
48283 }
48284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48285 return resultobj;
48286 fail:
48287 return NULL;
48288 }
48289
48290
48291 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48292 PyObject *resultobj = 0;
48293 wxSizer *arg1 = (wxSizer *) 0 ;
48294 size_t arg2 ;
48295 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
48296 wxSizerItem *result = 0 ;
48297 void *argp1 = 0 ;
48298 int res1 = 0 ;
48299 size_t val2 ;
48300 int ecode2 = 0 ;
48301 int res3 = 0 ;
48302 PyObject * obj0 = 0 ;
48303 PyObject * obj1 = 0 ;
48304 PyObject * obj2 = 0 ;
48305 char * kwnames[] = {
48306 (char *) "self",(char *) "index",(char *) "item", NULL
48307 };
48308
48309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48311 if (!SWIG_IsOK(res1)) {
48312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48313 }
48314 arg1 = reinterpret_cast< wxSizer * >(argp1);
48315 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48316 if (!SWIG_IsOK(ecode2)) {
48317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
48318 }
48319 arg2 = static_cast< size_t >(val2);
48320 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48321 if (!SWIG_IsOK(res3)) {
48322 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
48323 }
48324 {
48325 PyThreadState* __tstate = wxPyBeginAllowThreads();
48326 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
48327 wxPyEndAllowThreads(__tstate);
48328 if (PyErr_Occurred()) SWIG_fail;
48329 }
48330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48331 return resultobj;
48332 fail:
48333 return NULL;
48334 }
48335
48336
48337 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48338 PyObject *resultobj = 0;
48339 wxSizer *arg1 = (wxSizer *) 0 ;
48340 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
48341 wxSizerItem *result = 0 ;
48342 void *argp1 = 0 ;
48343 int res1 = 0 ;
48344 int res2 = 0 ;
48345 PyObject * obj0 = 0 ;
48346 PyObject * obj1 = 0 ;
48347 char * kwnames[] = {
48348 (char *) "self",(char *) "item", NULL
48349 };
48350
48351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
48352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48353 if (!SWIG_IsOK(res1)) {
48354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48355 }
48356 arg1 = reinterpret_cast< wxSizer * >(argp1);
48357 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48358 if (!SWIG_IsOK(res2)) {
48359 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
48360 }
48361 {
48362 PyThreadState* __tstate = wxPyBeginAllowThreads();
48363 result = (wxSizerItem *)(arg1)->Prepend(arg2);
48364 wxPyEndAllowThreads(__tstate);
48365 if (PyErr_Occurred()) SWIG_fail;
48366 }
48367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48368 return resultobj;
48369 fail:
48370 return NULL;
48371 }
48372
48373
48374 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48375 PyObject *resultobj = 0;
48376 wxSizer *arg1 = (wxSizer *) 0 ;
48377 int arg2 ;
48378 int arg3 ;
48379 int arg4 ;
48380 int arg5 ;
48381 void *argp1 = 0 ;
48382 int res1 = 0 ;
48383 int val2 ;
48384 int ecode2 = 0 ;
48385 int val3 ;
48386 int ecode3 = 0 ;
48387 int val4 ;
48388 int ecode4 = 0 ;
48389 int val5 ;
48390 int ecode5 = 0 ;
48391 PyObject * obj0 = 0 ;
48392 PyObject * obj1 = 0 ;
48393 PyObject * obj2 = 0 ;
48394 PyObject * obj3 = 0 ;
48395 PyObject * obj4 = 0 ;
48396 char * kwnames[] = {
48397 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
48398 };
48399
48400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48402 if (!SWIG_IsOK(res1)) {
48403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
48404 }
48405 arg1 = reinterpret_cast< wxSizer * >(argp1);
48406 ecode2 = SWIG_AsVal_int(obj1, &val2);
48407 if (!SWIG_IsOK(ecode2)) {
48408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
48409 }
48410 arg2 = static_cast< int >(val2);
48411 ecode3 = SWIG_AsVal_int(obj2, &val3);
48412 if (!SWIG_IsOK(ecode3)) {
48413 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
48414 }
48415 arg3 = static_cast< int >(val3);
48416 ecode4 = SWIG_AsVal_int(obj3, &val4);
48417 if (!SWIG_IsOK(ecode4)) {
48418 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
48419 }
48420 arg4 = static_cast< int >(val4);
48421 ecode5 = SWIG_AsVal_int(obj4, &val5);
48422 if (!SWIG_IsOK(ecode5)) {
48423 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
48424 }
48425 arg5 = static_cast< int >(val5);
48426 {
48427 PyThreadState* __tstate = wxPyBeginAllowThreads();
48428 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
48429 wxPyEndAllowThreads(__tstate);
48430 if (PyErr_Occurred()) SWIG_fail;
48431 }
48432 resultobj = SWIG_Py_Void();
48433 return resultobj;
48434 fail:
48435 return NULL;
48436 }
48437
48438
48439 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48440 PyObject *resultobj = 0;
48441 wxSizer *arg1 = (wxSizer *) 0 ;
48442 wxSize *arg2 = 0 ;
48443 void *argp1 = 0 ;
48444 int res1 = 0 ;
48445 wxSize temp2 ;
48446 PyObject * obj0 = 0 ;
48447 PyObject * obj1 = 0 ;
48448 char * kwnames[] = {
48449 (char *) "self",(char *) "size", NULL
48450 };
48451
48452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
48453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48454 if (!SWIG_IsOK(res1)) {
48455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48456 }
48457 arg1 = reinterpret_cast< wxSizer * >(argp1);
48458 {
48459 arg2 = &temp2;
48460 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48461 }
48462 {
48463 PyThreadState* __tstate = wxPyBeginAllowThreads();
48464 (arg1)->SetMinSize((wxSize const &)*arg2);
48465 wxPyEndAllowThreads(__tstate);
48466 if (PyErr_Occurred()) SWIG_fail;
48467 }
48468 resultobj = SWIG_Py_Void();
48469 return resultobj;
48470 fail:
48471 return NULL;
48472 }
48473
48474
48475 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48476 PyObject *resultobj = 0;
48477 wxSizer *arg1 = (wxSizer *) 0 ;
48478 wxSize result;
48479 void *argp1 = 0 ;
48480 int res1 = 0 ;
48481 PyObject *swig_obj[1] ;
48482
48483 if (!args) SWIG_fail;
48484 swig_obj[0] = args;
48485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48486 if (!SWIG_IsOK(res1)) {
48487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48488 }
48489 arg1 = reinterpret_cast< wxSizer * >(argp1);
48490 {
48491 PyThreadState* __tstate = wxPyBeginAllowThreads();
48492 result = (arg1)->GetSize();
48493 wxPyEndAllowThreads(__tstate);
48494 if (PyErr_Occurred()) SWIG_fail;
48495 }
48496 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48497 return resultobj;
48498 fail:
48499 return NULL;
48500 }
48501
48502
48503 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48504 PyObject *resultobj = 0;
48505 wxSizer *arg1 = (wxSizer *) 0 ;
48506 wxPoint result;
48507 void *argp1 = 0 ;
48508 int res1 = 0 ;
48509 PyObject *swig_obj[1] ;
48510
48511 if (!args) SWIG_fail;
48512 swig_obj[0] = args;
48513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48514 if (!SWIG_IsOK(res1)) {
48515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
48516 }
48517 arg1 = reinterpret_cast< wxSizer * >(argp1);
48518 {
48519 PyThreadState* __tstate = wxPyBeginAllowThreads();
48520 result = (arg1)->GetPosition();
48521 wxPyEndAllowThreads(__tstate);
48522 if (PyErr_Occurred()) SWIG_fail;
48523 }
48524 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
48525 return resultobj;
48526 fail:
48527 return NULL;
48528 }
48529
48530
48531 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48532 PyObject *resultobj = 0;
48533 wxSizer *arg1 = (wxSizer *) 0 ;
48534 wxSize result;
48535 void *argp1 = 0 ;
48536 int res1 = 0 ;
48537 PyObject *swig_obj[1] ;
48538
48539 if (!args) SWIG_fail;
48540 swig_obj[0] = args;
48541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48542 if (!SWIG_IsOK(res1)) {
48543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48544 }
48545 arg1 = reinterpret_cast< wxSizer * >(argp1);
48546 {
48547 PyThreadState* __tstate = wxPyBeginAllowThreads();
48548 result = (arg1)->GetMinSize();
48549 wxPyEndAllowThreads(__tstate);
48550 if (PyErr_Occurred()) SWIG_fail;
48551 }
48552 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48553 return resultobj;
48554 fail:
48555 return NULL;
48556 }
48557
48558
48559 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48560 PyObject *resultobj = 0;
48561 wxSizer *arg1 = (wxSizer *) 0 ;
48562 void *argp1 = 0 ;
48563 int res1 = 0 ;
48564 PyObject *swig_obj[1] ;
48565
48566 if (!args) SWIG_fail;
48567 swig_obj[0] = args;
48568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48569 if (!SWIG_IsOK(res1)) {
48570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
48571 }
48572 arg1 = reinterpret_cast< wxSizer * >(argp1);
48573 {
48574 PyThreadState* __tstate = wxPyBeginAllowThreads();
48575 (arg1)->RecalcSizes();
48576 wxPyEndAllowThreads(__tstate);
48577 if (PyErr_Occurred()) SWIG_fail;
48578 }
48579 resultobj = SWIG_Py_Void();
48580 return resultobj;
48581 fail:
48582 return NULL;
48583 }
48584
48585
48586 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48587 PyObject *resultobj = 0;
48588 wxSizer *arg1 = (wxSizer *) 0 ;
48589 wxSize result;
48590 void *argp1 = 0 ;
48591 int res1 = 0 ;
48592 PyObject *swig_obj[1] ;
48593
48594 if (!args) SWIG_fail;
48595 swig_obj[0] = args;
48596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48597 if (!SWIG_IsOK(res1)) {
48598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
48599 }
48600 arg1 = reinterpret_cast< wxSizer * >(argp1);
48601 {
48602 PyThreadState* __tstate = wxPyBeginAllowThreads();
48603 result = (arg1)->CalcMin();
48604 wxPyEndAllowThreads(__tstate);
48605 if (PyErr_Occurred()) SWIG_fail;
48606 }
48607 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48608 return resultobj;
48609 fail:
48610 return NULL;
48611 }
48612
48613
48614 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48615 PyObject *resultobj = 0;
48616 wxSizer *arg1 = (wxSizer *) 0 ;
48617 void *argp1 = 0 ;
48618 int res1 = 0 ;
48619 PyObject *swig_obj[1] ;
48620
48621 if (!args) SWIG_fail;
48622 swig_obj[0] = args;
48623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48624 if (!SWIG_IsOK(res1)) {
48625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
48626 }
48627 arg1 = reinterpret_cast< wxSizer * >(argp1);
48628 {
48629 PyThreadState* __tstate = wxPyBeginAllowThreads();
48630 (arg1)->Layout();
48631 wxPyEndAllowThreads(__tstate);
48632 if (PyErr_Occurred()) SWIG_fail;
48633 }
48634 resultobj = SWIG_Py_Void();
48635 return resultobj;
48636 fail:
48637 return NULL;
48638 }
48639
48640
48641 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48642 PyObject *resultobj = 0;
48643 wxSizer *arg1 = (wxSizer *) 0 ;
48644 wxWindow *arg2 = (wxWindow *) 0 ;
48645 wxSize result;
48646 void *argp1 = 0 ;
48647 int res1 = 0 ;
48648 void *argp2 = 0 ;
48649 int res2 = 0 ;
48650 PyObject * obj0 = 0 ;
48651 PyObject * obj1 = 0 ;
48652 char * kwnames[] = {
48653 (char *) "self",(char *) "window", NULL
48654 };
48655
48656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48658 if (!SWIG_IsOK(res1)) {
48659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48660 }
48661 arg1 = reinterpret_cast< wxSizer * >(argp1);
48662 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48663 if (!SWIG_IsOK(res2)) {
48664 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48665 }
48666 arg2 = reinterpret_cast< wxWindow * >(argp2);
48667 {
48668 PyThreadState* __tstate = wxPyBeginAllowThreads();
48669 result = (arg1)->Fit(arg2);
48670 wxPyEndAllowThreads(__tstate);
48671 if (PyErr_Occurred()) SWIG_fail;
48672 }
48673 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48674 return resultobj;
48675 fail:
48676 return NULL;
48677 }
48678
48679
48680 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48681 PyObject *resultobj = 0;
48682 wxSizer *arg1 = (wxSizer *) 0 ;
48683 wxWindow *arg2 = (wxWindow *) 0 ;
48684 void *argp1 = 0 ;
48685 int res1 = 0 ;
48686 void *argp2 = 0 ;
48687 int res2 = 0 ;
48688 PyObject * obj0 = 0 ;
48689 PyObject * obj1 = 0 ;
48690 char * kwnames[] = {
48691 (char *) "self",(char *) "window", NULL
48692 };
48693
48694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48696 if (!SWIG_IsOK(res1)) {
48697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48698 }
48699 arg1 = reinterpret_cast< wxSizer * >(argp1);
48700 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48701 if (!SWIG_IsOK(res2)) {
48702 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48703 }
48704 arg2 = reinterpret_cast< wxWindow * >(argp2);
48705 {
48706 PyThreadState* __tstate = wxPyBeginAllowThreads();
48707 (arg1)->FitInside(arg2);
48708 wxPyEndAllowThreads(__tstate);
48709 if (PyErr_Occurred()) SWIG_fail;
48710 }
48711 resultobj = SWIG_Py_Void();
48712 return resultobj;
48713 fail:
48714 return NULL;
48715 }
48716
48717
48718 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48719 PyObject *resultobj = 0;
48720 wxSizer *arg1 = (wxSizer *) 0 ;
48721 wxWindow *arg2 = (wxWindow *) 0 ;
48722 void *argp1 = 0 ;
48723 int res1 = 0 ;
48724 void *argp2 = 0 ;
48725 int res2 = 0 ;
48726 PyObject * obj0 = 0 ;
48727 PyObject * obj1 = 0 ;
48728 char * kwnames[] = {
48729 (char *) "self",(char *) "window", NULL
48730 };
48731
48732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48734 if (!SWIG_IsOK(res1)) {
48735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48736 }
48737 arg1 = reinterpret_cast< wxSizer * >(argp1);
48738 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48739 if (!SWIG_IsOK(res2)) {
48740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48741 }
48742 arg2 = reinterpret_cast< wxWindow * >(argp2);
48743 {
48744 PyThreadState* __tstate = wxPyBeginAllowThreads();
48745 (arg1)->SetSizeHints(arg2);
48746 wxPyEndAllowThreads(__tstate);
48747 if (PyErr_Occurred()) SWIG_fail;
48748 }
48749 resultobj = SWIG_Py_Void();
48750 return resultobj;
48751 fail:
48752 return NULL;
48753 }
48754
48755
48756 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48757 PyObject *resultobj = 0;
48758 wxSizer *arg1 = (wxSizer *) 0 ;
48759 wxWindow *arg2 = (wxWindow *) 0 ;
48760 void *argp1 = 0 ;
48761 int res1 = 0 ;
48762 void *argp2 = 0 ;
48763 int res2 = 0 ;
48764 PyObject * obj0 = 0 ;
48765 PyObject * obj1 = 0 ;
48766 char * kwnames[] = {
48767 (char *) "self",(char *) "window", NULL
48768 };
48769
48770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48772 if (!SWIG_IsOK(res1)) {
48773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48774 }
48775 arg1 = reinterpret_cast< wxSizer * >(argp1);
48776 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48777 if (!SWIG_IsOK(res2)) {
48778 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48779 }
48780 arg2 = reinterpret_cast< wxWindow * >(argp2);
48781 {
48782 PyThreadState* __tstate = wxPyBeginAllowThreads();
48783 (arg1)->SetVirtualSizeHints(arg2);
48784 wxPyEndAllowThreads(__tstate);
48785 if (PyErr_Occurred()) SWIG_fail;
48786 }
48787 resultobj = SWIG_Py_Void();
48788 return resultobj;
48789 fail:
48790 return NULL;
48791 }
48792
48793
48794 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48795 PyObject *resultobj = 0;
48796 wxSizer *arg1 = (wxSizer *) 0 ;
48797 bool arg2 = (bool) false ;
48798 void *argp1 = 0 ;
48799 int res1 = 0 ;
48800 bool val2 ;
48801 int ecode2 = 0 ;
48802 PyObject * obj0 = 0 ;
48803 PyObject * obj1 = 0 ;
48804 char * kwnames[] = {
48805 (char *) "self",(char *) "deleteWindows", NULL
48806 };
48807
48808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
48809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48810 if (!SWIG_IsOK(res1)) {
48811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48812 }
48813 arg1 = reinterpret_cast< wxSizer * >(argp1);
48814 if (obj1) {
48815 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48816 if (!SWIG_IsOK(ecode2)) {
48817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48818 }
48819 arg2 = static_cast< bool >(val2);
48820 }
48821 {
48822 PyThreadState* __tstate = wxPyBeginAllowThreads();
48823 (arg1)->Clear(arg2);
48824 wxPyEndAllowThreads(__tstate);
48825 if (PyErr_Occurred()) SWIG_fail;
48826 }
48827 resultobj = SWIG_Py_Void();
48828 return resultobj;
48829 fail:
48830 return NULL;
48831 }
48832
48833
48834 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48835 PyObject *resultobj = 0;
48836 wxSizer *arg1 = (wxSizer *) 0 ;
48837 void *argp1 = 0 ;
48838 int res1 = 0 ;
48839 PyObject *swig_obj[1] ;
48840
48841 if (!args) SWIG_fail;
48842 swig_obj[0] = args;
48843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48844 if (!SWIG_IsOK(res1)) {
48845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48846 }
48847 arg1 = reinterpret_cast< wxSizer * >(argp1);
48848 {
48849 PyThreadState* __tstate = wxPyBeginAllowThreads();
48850 (arg1)->DeleteWindows();
48851 wxPyEndAllowThreads(__tstate);
48852 if (PyErr_Occurred()) SWIG_fail;
48853 }
48854 resultobj = SWIG_Py_Void();
48855 return resultobj;
48856 fail:
48857 return NULL;
48858 }
48859
48860
48861 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48862 PyObject *resultobj = 0;
48863 wxSizer *arg1 = (wxSizer *) 0 ;
48864 PyObject *result = 0 ;
48865 void *argp1 = 0 ;
48866 int res1 = 0 ;
48867 PyObject *swig_obj[1] ;
48868
48869 if (!args) SWIG_fail;
48870 swig_obj[0] = args;
48871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48872 if (!SWIG_IsOK(res1)) {
48873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48874 }
48875 arg1 = reinterpret_cast< wxSizer * >(argp1);
48876 {
48877 PyThreadState* __tstate = wxPyBeginAllowThreads();
48878 result = (PyObject *)wxSizer_GetChildren(arg1);
48879 wxPyEndAllowThreads(__tstate);
48880 if (PyErr_Occurred()) SWIG_fail;
48881 }
48882 resultobj = result;
48883 return resultobj;
48884 fail:
48885 return NULL;
48886 }
48887
48888
48889 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48890 PyObject *resultobj = 0;
48891 wxSizer *arg1 = (wxSizer *) 0 ;
48892 PyObject *arg2 = (PyObject *) 0 ;
48893 bool arg3 = (bool) true ;
48894 bool arg4 = (bool) false ;
48895 bool result;
48896 void *argp1 = 0 ;
48897 int res1 = 0 ;
48898 bool val3 ;
48899 int ecode3 = 0 ;
48900 bool val4 ;
48901 int ecode4 = 0 ;
48902 PyObject * obj0 = 0 ;
48903 PyObject * obj1 = 0 ;
48904 PyObject * obj2 = 0 ;
48905 PyObject * obj3 = 0 ;
48906 char * kwnames[] = {
48907 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48908 };
48909
48910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48912 if (!SWIG_IsOK(res1)) {
48913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48914 }
48915 arg1 = reinterpret_cast< wxSizer * >(argp1);
48916 arg2 = obj1;
48917 if (obj2) {
48918 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48919 if (!SWIG_IsOK(ecode3)) {
48920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48921 }
48922 arg3 = static_cast< bool >(val3);
48923 }
48924 if (obj3) {
48925 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48926 if (!SWIG_IsOK(ecode4)) {
48927 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48928 }
48929 arg4 = static_cast< bool >(val4);
48930 }
48931 {
48932 PyThreadState* __tstate = wxPyBeginAllowThreads();
48933 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48934 wxPyEndAllowThreads(__tstate);
48935 if (PyErr_Occurred()) SWIG_fail;
48936 }
48937 {
48938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48939 }
48940 return resultobj;
48941 fail:
48942 return NULL;
48943 }
48944
48945
48946 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48947 PyObject *resultobj = 0;
48948 wxSizer *arg1 = (wxSizer *) 0 ;
48949 PyObject *arg2 = (PyObject *) 0 ;
48950 bool result;
48951 void *argp1 = 0 ;
48952 int res1 = 0 ;
48953 PyObject * obj0 = 0 ;
48954 PyObject * obj1 = 0 ;
48955 char * kwnames[] = {
48956 (char *) "self",(char *) "item", NULL
48957 };
48958
48959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
48960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48961 if (!SWIG_IsOK(res1)) {
48962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48963 }
48964 arg1 = reinterpret_cast< wxSizer * >(argp1);
48965 arg2 = obj1;
48966 {
48967 PyThreadState* __tstate = wxPyBeginAllowThreads();
48968 result = (bool)wxSizer_IsShown(arg1,arg2);
48969 wxPyEndAllowThreads(__tstate);
48970 if (PyErr_Occurred()) SWIG_fail;
48971 }
48972 {
48973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48974 }
48975 return resultobj;
48976 fail:
48977 return NULL;
48978 }
48979
48980
48981 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48982 PyObject *resultobj = 0;
48983 wxSizer *arg1 = (wxSizer *) 0 ;
48984 bool arg2 ;
48985 void *argp1 = 0 ;
48986 int res1 = 0 ;
48987 bool val2 ;
48988 int ecode2 = 0 ;
48989 PyObject * obj0 = 0 ;
48990 PyObject * obj1 = 0 ;
48991 char * kwnames[] = {
48992 (char *) "self",(char *) "show", NULL
48993 };
48994
48995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
48996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48997 if (!SWIG_IsOK(res1)) {
48998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
48999 }
49000 arg1 = reinterpret_cast< wxSizer * >(argp1);
49001 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49002 if (!SWIG_IsOK(ecode2)) {
49003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
49004 }
49005 arg2 = static_cast< bool >(val2);
49006 {
49007 PyThreadState* __tstate = wxPyBeginAllowThreads();
49008 (arg1)->ShowItems(arg2);
49009 wxPyEndAllowThreads(__tstate);
49010 if (PyErr_Occurred()) SWIG_fail;
49011 }
49012 resultobj = SWIG_Py_Void();
49013 return resultobj;
49014 fail:
49015 return NULL;
49016 }
49017
49018
49019 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49020 PyObject *obj;
49021 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49022 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
49023 return SWIG_Py_Void();
49024 }
49025
49026 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49027 PyObject *resultobj = 0;
49028 wxPySizer *result = 0 ;
49029
49030 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
49031 {
49032 PyThreadState* __tstate = wxPyBeginAllowThreads();
49033 result = (wxPySizer *)new wxPySizer();
49034 wxPyEndAllowThreads(__tstate);
49035 if (PyErr_Occurred()) SWIG_fail;
49036 }
49037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
49038 return resultobj;
49039 fail:
49040 return NULL;
49041 }
49042
49043
49044 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49045 PyObject *resultobj = 0;
49046 wxPySizer *arg1 = (wxPySizer *) 0 ;
49047 PyObject *arg2 = (PyObject *) 0 ;
49048 PyObject *arg3 = (PyObject *) 0 ;
49049 void *argp1 = 0 ;
49050 int res1 = 0 ;
49051 PyObject * obj0 = 0 ;
49052 PyObject * obj1 = 0 ;
49053 PyObject * obj2 = 0 ;
49054 char * kwnames[] = {
49055 (char *) "self",(char *) "self",(char *) "_class", NULL
49056 };
49057
49058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
49060 if (!SWIG_IsOK(res1)) {
49061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
49062 }
49063 arg1 = reinterpret_cast< wxPySizer * >(argp1);
49064 arg2 = obj1;
49065 arg3 = obj2;
49066 {
49067 PyThreadState* __tstate = wxPyBeginAllowThreads();
49068 (arg1)->_setCallbackInfo(arg2,arg3);
49069 wxPyEndAllowThreads(__tstate);
49070 if (PyErr_Occurred()) SWIG_fail;
49071 }
49072 resultobj = SWIG_Py_Void();
49073 return resultobj;
49074 fail:
49075 return NULL;
49076 }
49077
49078
49079 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49080 PyObject *obj;
49081 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49082 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
49083 return SWIG_Py_Void();
49084 }
49085
49086 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49087 return SWIG_Python_InitShadowInstance(args);
49088 }
49089
49090 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49091 PyObject *resultobj = 0;
49092 int arg1 = (int) wxHORIZONTAL ;
49093 wxBoxSizer *result = 0 ;
49094 int val1 ;
49095 int ecode1 = 0 ;
49096 PyObject * obj0 = 0 ;
49097 char * kwnames[] = {
49098 (char *) "orient", NULL
49099 };
49100
49101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
49102 if (obj0) {
49103 ecode1 = SWIG_AsVal_int(obj0, &val1);
49104 if (!SWIG_IsOK(ecode1)) {
49105 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
49106 }
49107 arg1 = static_cast< int >(val1);
49108 }
49109 {
49110 PyThreadState* __tstate = wxPyBeginAllowThreads();
49111 result = (wxBoxSizer *)new wxBoxSizer(arg1);
49112 wxPyEndAllowThreads(__tstate);
49113 if (PyErr_Occurred()) SWIG_fail;
49114 }
49115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
49116 return resultobj;
49117 fail:
49118 return NULL;
49119 }
49120
49121
49122 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49123 PyObject *resultobj = 0;
49124 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
49125 int result;
49126 void *argp1 = 0 ;
49127 int res1 = 0 ;
49128 PyObject *swig_obj[1] ;
49129
49130 if (!args) SWIG_fail;
49131 swig_obj[0] = args;
49132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
49133 if (!SWIG_IsOK(res1)) {
49134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
49135 }
49136 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
49137 {
49138 PyThreadState* __tstate = wxPyBeginAllowThreads();
49139 result = (int)(arg1)->GetOrientation();
49140 wxPyEndAllowThreads(__tstate);
49141 if (PyErr_Occurred()) SWIG_fail;
49142 }
49143 resultobj = SWIG_From_int(static_cast< int >(result));
49144 return resultobj;
49145 fail:
49146 return NULL;
49147 }
49148
49149
49150 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49151 PyObject *resultobj = 0;
49152 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
49153 int arg2 ;
49154 void *argp1 = 0 ;
49155 int res1 = 0 ;
49156 int val2 ;
49157 int ecode2 = 0 ;
49158 PyObject * obj0 = 0 ;
49159 PyObject * obj1 = 0 ;
49160 char * kwnames[] = {
49161 (char *) "self",(char *) "orient", NULL
49162 };
49163
49164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
49165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
49166 if (!SWIG_IsOK(res1)) {
49167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
49168 }
49169 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
49170 ecode2 = SWIG_AsVal_int(obj1, &val2);
49171 if (!SWIG_IsOK(ecode2)) {
49172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
49173 }
49174 arg2 = static_cast< int >(val2);
49175 {
49176 PyThreadState* __tstate = wxPyBeginAllowThreads();
49177 (arg1)->SetOrientation(arg2);
49178 wxPyEndAllowThreads(__tstate);
49179 if (PyErr_Occurred()) SWIG_fail;
49180 }
49181 resultobj = SWIG_Py_Void();
49182 return resultobj;
49183 fail:
49184 return NULL;
49185 }
49186
49187
49188 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49189 PyObject *obj;
49190 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49191 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
49192 return SWIG_Py_Void();
49193 }
49194
49195 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49196 return SWIG_Python_InitShadowInstance(args);
49197 }
49198
49199 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49200 PyObject *resultobj = 0;
49201 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
49202 int arg2 = (int) wxHORIZONTAL ;
49203 wxStaticBoxSizer *result = 0 ;
49204 void *argp1 = 0 ;
49205 int res1 = 0 ;
49206 int val2 ;
49207 int ecode2 = 0 ;
49208 PyObject * obj0 = 0 ;
49209 PyObject * obj1 = 0 ;
49210 char * kwnames[] = {
49211 (char *) "box",(char *) "orient", NULL
49212 };
49213
49214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
49216 if (!SWIG_IsOK(res1)) {
49217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
49218 }
49219 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
49220 if (obj1) {
49221 ecode2 = SWIG_AsVal_int(obj1, &val2);
49222 if (!SWIG_IsOK(ecode2)) {
49223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
49224 }
49225 arg2 = static_cast< int >(val2);
49226 }
49227 {
49228 PyThreadState* __tstate = wxPyBeginAllowThreads();
49229 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
49230 wxPyEndAllowThreads(__tstate);
49231 if (PyErr_Occurred()) SWIG_fail;
49232 }
49233 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
49234 return resultobj;
49235 fail:
49236 return NULL;
49237 }
49238
49239
49240 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49241 PyObject *resultobj = 0;
49242 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
49243 wxStaticBox *result = 0 ;
49244 void *argp1 = 0 ;
49245 int res1 = 0 ;
49246 PyObject *swig_obj[1] ;
49247
49248 if (!args) SWIG_fail;
49249 swig_obj[0] = args;
49250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
49251 if (!SWIG_IsOK(res1)) {
49252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
49253 }
49254 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
49255 {
49256 PyThreadState* __tstate = wxPyBeginAllowThreads();
49257 result = (wxStaticBox *)(arg1)->GetStaticBox();
49258 wxPyEndAllowThreads(__tstate);
49259 if (PyErr_Occurred()) SWIG_fail;
49260 }
49261 {
49262 resultobj = wxPyMake_wxObject(result, (bool)0);
49263 }
49264 return resultobj;
49265 fail:
49266 return NULL;
49267 }
49268
49269
49270 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49271 PyObject *obj;
49272 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49273 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
49274 return SWIG_Py_Void();
49275 }
49276
49277 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49278 return SWIG_Python_InitShadowInstance(args);
49279 }
49280
49281 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49282 PyObject *resultobj = 0;
49283 int arg1 = (int) 1 ;
49284 int arg2 = (int) 0 ;
49285 int arg3 = (int) 0 ;
49286 int arg4 = (int) 0 ;
49287 wxGridSizer *result = 0 ;
49288 int val1 ;
49289 int ecode1 = 0 ;
49290 int val2 ;
49291 int ecode2 = 0 ;
49292 int val3 ;
49293 int ecode3 = 0 ;
49294 int val4 ;
49295 int ecode4 = 0 ;
49296 PyObject * obj0 = 0 ;
49297 PyObject * obj1 = 0 ;
49298 PyObject * obj2 = 0 ;
49299 PyObject * obj3 = 0 ;
49300 char * kwnames[] = {
49301 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49302 };
49303
49304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49305 if (obj0) {
49306 ecode1 = SWIG_AsVal_int(obj0, &val1);
49307 if (!SWIG_IsOK(ecode1)) {
49308 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
49309 }
49310 arg1 = static_cast< int >(val1);
49311 }
49312 if (obj1) {
49313 ecode2 = SWIG_AsVal_int(obj1, &val2);
49314 if (!SWIG_IsOK(ecode2)) {
49315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
49316 }
49317 arg2 = static_cast< int >(val2);
49318 }
49319 if (obj2) {
49320 ecode3 = SWIG_AsVal_int(obj2, &val3);
49321 if (!SWIG_IsOK(ecode3)) {
49322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
49323 }
49324 arg3 = static_cast< int >(val3);
49325 }
49326 if (obj3) {
49327 ecode4 = SWIG_AsVal_int(obj3, &val4);
49328 if (!SWIG_IsOK(ecode4)) {
49329 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
49330 }
49331 arg4 = static_cast< int >(val4);
49332 }
49333 {
49334 PyThreadState* __tstate = wxPyBeginAllowThreads();
49335 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
49336 wxPyEndAllowThreads(__tstate);
49337 if (PyErr_Occurred()) SWIG_fail;
49338 }
49339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
49340 return resultobj;
49341 fail:
49342 return NULL;
49343 }
49344
49345
49346 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49347 PyObject *resultobj = 0;
49348 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49349 int arg2 ;
49350 void *argp1 = 0 ;
49351 int res1 = 0 ;
49352 int val2 ;
49353 int ecode2 = 0 ;
49354 PyObject * obj0 = 0 ;
49355 PyObject * obj1 = 0 ;
49356 char * kwnames[] = {
49357 (char *) "self",(char *) "cols", NULL
49358 };
49359
49360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
49361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49362 if (!SWIG_IsOK(res1)) {
49363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49364 }
49365 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49366 ecode2 = SWIG_AsVal_int(obj1, &val2);
49367 if (!SWIG_IsOK(ecode2)) {
49368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
49369 }
49370 arg2 = static_cast< int >(val2);
49371 {
49372 PyThreadState* __tstate = wxPyBeginAllowThreads();
49373 (arg1)->SetCols(arg2);
49374 wxPyEndAllowThreads(__tstate);
49375 if (PyErr_Occurred()) SWIG_fail;
49376 }
49377 resultobj = SWIG_Py_Void();
49378 return resultobj;
49379 fail:
49380 return NULL;
49381 }
49382
49383
49384 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49385 PyObject *resultobj = 0;
49386 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49387 int arg2 ;
49388 void *argp1 = 0 ;
49389 int res1 = 0 ;
49390 int val2 ;
49391 int ecode2 = 0 ;
49392 PyObject * obj0 = 0 ;
49393 PyObject * obj1 = 0 ;
49394 char * kwnames[] = {
49395 (char *) "self",(char *) "rows", NULL
49396 };
49397
49398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
49399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49400 if (!SWIG_IsOK(res1)) {
49401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49402 }
49403 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49404 ecode2 = SWIG_AsVal_int(obj1, &val2);
49405 if (!SWIG_IsOK(ecode2)) {
49406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
49407 }
49408 arg2 = static_cast< int >(val2);
49409 {
49410 PyThreadState* __tstate = wxPyBeginAllowThreads();
49411 (arg1)->SetRows(arg2);
49412 wxPyEndAllowThreads(__tstate);
49413 if (PyErr_Occurred()) SWIG_fail;
49414 }
49415 resultobj = SWIG_Py_Void();
49416 return resultobj;
49417 fail:
49418 return NULL;
49419 }
49420
49421
49422 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49423 PyObject *resultobj = 0;
49424 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49425 int arg2 ;
49426 void *argp1 = 0 ;
49427 int res1 = 0 ;
49428 int val2 ;
49429 int ecode2 = 0 ;
49430 PyObject * obj0 = 0 ;
49431 PyObject * obj1 = 0 ;
49432 char * kwnames[] = {
49433 (char *) "self",(char *) "gap", NULL
49434 };
49435
49436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
49437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49438 if (!SWIG_IsOK(res1)) {
49439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49440 }
49441 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49442 ecode2 = SWIG_AsVal_int(obj1, &val2);
49443 if (!SWIG_IsOK(ecode2)) {
49444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
49445 }
49446 arg2 = static_cast< int >(val2);
49447 {
49448 PyThreadState* __tstate = wxPyBeginAllowThreads();
49449 (arg1)->SetVGap(arg2);
49450 wxPyEndAllowThreads(__tstate);
49451 if (PyErr_Occurred()) SWIG_fail;
49452 }
49453 resultobj = SWIG_Py_Void();
49454 return resultobj;
49455 fail:
49456 return NULL;
49457 }
49458
49459
49460 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49461 PyObject *resultobj = 0;
49462 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49463 int arg2 ;
49464 void *argp1 = 0 ;
49465 int res1 = 0 ;
49466 int val2 ;
49467 int ecode2 = 0 ;
49468 PyObject * obj0 = 0 ;
49469 PyObject * obj1 = 0 ;
49470 char * kwnames[] = {
49471 (char *) "self",(char *) "gap", NULL
49472 };
49473
49474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
49475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49476 if (!SWIG_IsOK(res1)) {
49477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49478 }
49479 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49480 ecode2 = SWIG_AsVal_int(obj1, &val2);
49481 if (!SWIG_IsOK(ecode2)) {
49482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
49483 }
49484 arg2 = static_cast< int >(val2);
49485 {
49486 PyThreadState* __tstate = wxPyBeginAllowThreads();
49487 (arg1)->SetHGap(arg2);
49488 wxPyEndAllowThreads(__tstate);
49489 if (PyErr_Occurred()) SWIG_fail;
49490 }
49491 resultobj = SWIG_Py_Void();
49492 return resultobj;
49493 fail:
49494 return NULL;
49495 }
49496
49497
49498 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49499 PyObject *resultobj = 0;
49500 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49501 int result;
49502 void *argp1 = 0 ;
49503 int res1 = 0 ;
49504 PyObject *swig_obj[1] ;
49505
49506 if (!args) SWIG_fail;
49507 swig_obj[0] = args;
49508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49509 if (!SWIG_IsOK(res1)) {
49510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49511 }
49512 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49513 {
49514 PyThreadState* __tstate = wxPyBeginAllowThreads();
49515 result = (int)(arg1)->GetCols();
49516 wxPyEndAllowThreads(__tstate);
49517 if (PyErr_Occurred()) SWIG_fail;
49518 }
49519 resultobj = SWIG_From_int(static_cast< int >(result));
49520 return resultobj;
49521 fail:
49522 return NULL;
49523 }
49524
49525
49526 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49527 PyObject *resultobj = 0;
49528 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49529 int result;
49530 void *argp1 = 0 ;
49531 int res1 = 0 ;
49532 PyObject *swig_obj[1] ;
49533
49534 if (!args) SWIG_fail;
49535 swig_obj[0] = args;
49536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49537 if (!SWIG_IsOK(res1)) {
49538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49539 }
49540 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49541 {
49542 PyThreadState* __tstate = wxPyBeginAllowThreads();
49543 result = (int)(arg1)->GetRows();
49544 wxPyEndAllowThreads(__tstate);
49545 if (PyErr_Occurred()) SWIG_fail;
49546 }
49547 resultobj = SWIG_From_int(static_cast< int >(result));
49548 return resultobj;
49549 fail:
49550 return NULL;
49551 }
49552
49553
49554 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49555 PyObject *resultobj = 0;
49556 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49557 int result;
49558 void *argp1 = 0 ;
49559 int res1 = 0 ;
49560 PyObject *swig_obj[1] ;
49561
49562 if (!args) SWIG_fail;
49563 swig_obj[0] = args;
49564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49565 if (!SWIG_IsOK(res1)) {
49566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49567 }
49568 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49569 {
49570 PyThreadState* __tstate = wxPyBeginAllowThreads();
49571 result = (int)(arg1)->GetVGap();
49572 wxPyEndAllowThreads(__tstate);
49573 if (PyErr_Occurred()) SWIG_fail;
49574 }
49575 resultobj = SWIG_From_int(static_cast< int >(result));
49576 return resultobj;
49577 fail:
49578 return NULL;
49579 }
49580
49581
49582 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49583 PyObject *resultobj = 0;
49584 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49585 int result;
49586 void *argp1 = 0 ;
49587 int res1 = 0 ;
49588 PyObject *swig_obj[1] ;
49589
49590 if (!args) SWIG_fail;
49591 swig_obj[0] = args;
49592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49593 if (!SWIG_IsOK(res1)) {
49594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49595 }
49596 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49597 {
49598 PyThreadState* __tstate = wxPyBeginAllowThreads();
49599 result = (int)(arg1)->GetHGap();
49600 wxPyEndAllowThreads(__tstate);
49601 if (PyErr_Occurred()) SWIG_fail;
49602 }
49603 resultobj = SWIG_From_int(static_cast< int >(result));
49604 return resultobj;
49605 fail:
49606 return NULL;
49607 }
49608
49609
49610 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49611 PyObject *obj;
49612 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49613 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
49614 return SWIG_Py_Void();
49615 }
49616
49617 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49618 return SWIG_Python_InitShadowInstance(args);
49619 }
49620
49621 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49622 PyObject *resultobj = 0;
49623 int arg1 = (int) 1 ;
49624 int arg2 = (int) 0 ;
49625 int arg3 = (int) 0 ;
49626 int arg4 = (int) 0 ;
49627 wxFlexGridSizer *result = 0 ;
49628 int val1 ;
49629 int ecode1 = 0 ;
49630 int val2 ;
49631 int ecode2 = 0 ;
49632 int val3 ;
49633 int ecode3 = 0 ;
49634 int val4 ;
49635 int ecode4 = 0 ;
49636 PyObject * obj0 = 0 ;
49637 PyObject * obj1 = 0 ;
49638 PyObject * obj2 = 0 ;
49639 PyObject * obj3 = 0 ;
49640 char * kwnames[] = {
49641 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49642 };
49643
49644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49645 if (obj0) {
49646 ecode1 = SWIG_AsVal_int(obj0, &val1);
49647 if (!SWIG_IsOK(ecode1)) {
49648 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49649 }
49650 arg1 = static_cast< int >(val1);
49651 }
49652 if (obj1) {
49653 ecode2 = SWIG_AsVal_int(obj1, &val2);
49654 if (!SWIG_IsOK(ecode2)) {
49655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49656 }
49657 arg2 = static_cast< int >(val2);
49658 }
49659 if (obj2) {
49660 ecode3 = SWIG_AsVal_int(obj2, &val3);
49661 if (!SWIG_IsOK(ecode3)) {
49662 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49663 }
49664 arg3 = static_cast< int >(val3);
49665 }
49666 if (obj3) {
49667 ecode4 = SWIG_AsVal_int(obj3, &val4);
49668 if (!SWIG_IsOK(ecode4)) {
49669 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49670 }
49671 arg4 = static_cast< int >(val4);
49672 }
49673 {
49674 PyThreadState* __tstate = wxPyBeginAllowThreads();
49675 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49676 wxPyEndAllowThreads(__tstate);
49677 if (PyErr_Occurred()) SWIG_fail;
49678 }
49679 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49680 return resultobj;
49681 fail:
49682 return NULL;
49683 }
49684
49685
49686 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49687 PyObject *resultobj = 0;
49688 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49689 size_t arg2 ;
49690 int arg3 = (int) 0 ;
49691 void *argp1 = 0 ;
49692 int res1 = 0 ;
49693 size_t val2 ;
49694 int ecode2 = 0 ;
49695 int val3 ;
49696 int ecode3 = 0 ;
49697 PyObject * obj0 = 0 ;
49698 PyObject * obj1 = 0 ;
49699 PyObject * obj2 = 0 ;
49700 char * kwnames[] = {
49701 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49702 };
49703
49704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49706 if (!SWIG_IsOK(res1)) {
49707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49708 }
49709 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49710 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49711 if (!SWIG_IsOK(ecode2)) {
49712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49713 }
49714 arg2 = static_cast< size_t >(val2);
49715 if (obj2) {
49716 ecode3 = SWIG_AsVal_int(obj2, &val3);
49717 if (!SWIG_IsOK(ecode3)) {
49718 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49719 }
49720 arg3 = static_cast< int >(val3);
49721 }
49722 {
49723 PyThreadState* __tstate = wxPyBeginAllowThreads();
49724 (arg1)->AddGrowableRow(arg2,arg3);
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_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49736 PyObject *resultobj = 0;
49737 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49738 size_t arg2 ;
49739 void *argp1 = 0 ;
49740 int res1 = 0 ;
49741 size_t val2 ;
49742 int ecode2 = 0 ;
49743 PyObject * obj0 = 0 ;
49744 PyObject * obj1 = 0 ;
49745 char * kwnames[] = {
49746 (char *) "self",(char *) "idx", NULL
49747 };
49748
49749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49751 if (!SWIG_IsOK(res1)) {
49752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49753 }
49754 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49755 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49756 if (!SWIG_IsOK(ecode2)) {
49757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49758 }
49759 arg2 = static_cast< size_t >(val2);
49760 {
49761 PyThreadState* __tstate = wxPyBeginAllowThreads();
49762 (arg1)->RemoveGrowableRow(arg2);
49763 wxPyEndAllowThreads(__tstate);
49764 if (PyErr_Occurred()) SWIG_fail;
49765 }
49766 resultobj = SWIG_Py_Void();
49767 return resultobj;
49768 fail:
49769 return NULL;
49770 }
49771
49772
49773 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49774 PyObject *resultobj = 0;
49775 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49776 size_t arg2 ;
49777 int arg3 = (int) 0 ;
49778 void *argp1 = 0 ;
49779 int res1 = 0 ;
49780 size_t val2 ;
49781 int ecode2 = 0 ;
49782 int val3 ;
49783 int ecode3 = 0 ;
49784 PyObject * obj0 = 0 ;
49785 PyObject * obj1 = 0 ;
49786 PyObject * obj2 = 0 ;
49787 char * kwnames[] = {
49788 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49789 };
49790
49791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49793 if (!SWIG_IsOK(res1)) {
49794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49795 }
49796 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49797 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49798 if (!SWIG_IsOK(ecode2)) {
49799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49800 }
49801 arg2 = static_cast< size_t >(val2);
49802 if (obj2) {
49803 ecode3 = SWIG_AsVal_int(obj2, &val3);
49804 if (!SWIG_IsOK(ecode3)) {
49805 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49806 }
49807 arg3 = static_cast< int >(val3);
49808 }
49809 {
49810 PyThreadState* __tstate = wxPyBeginAllowThreads();
49811 (arg1)->AddGrowableCol(arg2,arg3);
49812 wxPyEndAllowThreads(__tstate);
49813 if (PyErr_Occurred()) SWIG_fail;
49814 }
49815 resultobj = SWIG_Py_Void();
49816 return resultobj;
49817 fail:
49818 return NULL;
49819 }
49820
49821
49822 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49823 PyObject *resultobj = 0;
49824 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49825 size_t arg2 ;
49826 void *argp1 = 0 ;
49827 int res1 = 0 ;
49828 size_t val2 ;
49829 int ecode2 = 0 ;
49830 PyObject * obj0 = 0 ;
49831 PyObject * obj1 = 0 ;
49832 char * kwnames[] = {
49833 (char *) "self",(char *) "idx", NULL
49834 };
49835
49836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49838 if (!SWIG_IsOK(res1)) {
49839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49840 }
49841 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49842 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49843 if (!SWIG_IsOK(ecode2)) {
49844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49845 }
49846 arg2 = static_cast< size_t >(val2);
49847 {
49848 PyThreadState* __tstate = wxPyBeginAllowThreads();
49849 (arg1)->RemoveGrowableCol(arg2);
49850 wxPyEndAllowThreads(__tstate);
49851 if (PyErr_Occurred()) SWIG_fail;
49852 }
49853 resultobj = SWIG_Py_Void();
49854 return resultobj;
49855 fail:
49856 return NULL;
49857 }
49858
49859
49860 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49861 PyObject *resultobj = 0;
49862 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49863 int arg2 ;
49864 void *argp1 = 0 ;
49865 int res1 = 0 ;
49866 int val2 ;
49867 int ecode2 = 0 ;
49868 PyObject * obj0 = 0 ;
49869 PyObject * obj1 = 0 ;
49870 char * kwnames[] = {
49871 (char *) "self",(char *) "direction", NULL
49872 };
49873
49874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49876 if (!SWIG_IsOK(res1)) {
49877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49878 }
49879 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49880 ecode2 = SWIG_AsVal_int(obj1, &val2);
49881 if (!SWIG_IsOK(ecode2)) {
49882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49883 }
49884 arg2 = static_cast< int >(val2);
49885 {
49886 PyThreadState* __tstate = wxPyBeginAllowThreads();
49887 (arg1)->SetFlexibleDirection(arg2);
49888 wxPyEndAllowThreads(__tstate);
49889 if (PyErr_Occurred()) SWIG_fail;
49890 }
49891 resultobj = SWIG_Py_Void();
49892 return resultobj;
49893 fail:
49894 return NULL;
49895 }
49896
49897
49898 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49899 PyObject *resultobj = 0;
49900 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49901 int result;
49902 void *argp1 = 0 ;
49903 int res1 = 0 ;
49904 PyObject *swig_obj[1] ;
49905
49906 if (!args) SWIG_fail;
49907 swig_obj[0] = args;
49908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49909 if (!SWIG_IsOK(res1)) {
49910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49911 }
49912 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49913 {
49914 PyThreadState* __tstate = wxPyBeginAllowThreads();
49915 result = (int)(arg1)->GetFlexibleDirection();
49916 wxPyEndAllowThreads(__tstate);
49917 if (PyErr_Occurred()) SWIG_fail;
49918 }
49919 resultobj = SWIG_From_int(static_cast< int >(result));
49920 return resultobj;
49921 fail:
49922 return NULL;
49923 }
49924
49925
49926 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49927 PyObject *resultobj = 0;
49928 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49929 wxFlexSizerGrowMode arg2 ;
49930 void *argp1 = 0 ;
49931 int res1 = 0 ;
49932 int val2 ;
49933 int ecode2 = 0 ;
49934 PyObject * obj0 = 0 ;
49935 PyObject * obj1 = 0 ;
49936 char * kwnames[] = {
49937 (char *) "self",(char *) "mode", NULL
49938 };
49939
49940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49942 if (!SWIG_IsOK(res1)) {
49943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49944 }
49945 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49946 ecode2 = SWIG_AsVal_int(obj1, &val2);
49947 if (!SWIG_IsOK(ecode2)) {
49948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49949 }
49950 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49951 {
49952 PyThreadState* __tstate = wxPyBeginAllowThreads();
49953 (arg1)->SetNonFlexibleGrowMode(arg2);
49954 wxPyEndAllowThreads(__tstate);
49955 if (PyErr_Occurred()) SWIG_fail;
49956 }
49957 resultobj = SWIG_Py_Void();
49958 return resultobj;
49959 fail:
49960 return NULL;
49961 }
49962
49963
49964 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49965 PyObject *resultobj = 0;
49966 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49967 wxFlexSizerGrowMode result;
49968 void *argp1 = 0 ;
49969 int res1 = 0 ;
49970 PyObject *swig_obj[1] ;
49971
49972 if (!args) SWIG_fail;
49973 swig_obj[0] = args;
49974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49975 if (!SWIG_IsOK(res1)) {
49976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49977 }
49978 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49979 {
49980 PyThreadState* __tstate = wxPyBeginAllowThreads();
49981 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
49982 wxPyEndAllowThreads(__tstate);
49983 if (PyErr_Occurred()) SWIG_fail;
49984 }
49985 resultobj = SWIG_From_int(static_cast< int >(result));
49986 return resultobj;
49987 fail:
49988 return NULL;
49989 }
49990
49991
49992 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49993 PyObject *resultobj = 0;
49994 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49995 wxArrayInt *result = 0 ;
49996 void *argp1 = 0 ;
49997 int res1 = 0 ;
49998 PyObject *swig_obj[1] ;
49999
50000 if (!args) SWIG_fail;
50001 swig_obj[0] = args;
50002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
50003 if (!SWIG_IsOK(res1)) {
50004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
50005 }
50006 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
50007 {
50008 PyThreadState* __tstate = wxPyBeginAllowThreads();
50009 {
50010 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
50011 result = (wxArrayInt *) &_result_ref;
50012 }
50013 wxPyEndAllowThreads(__tstate);
50014 if (PyErr_Occurred()) SWIG_fail;
50015 }
50016 {
50017 resultobj = wxArrayInt2PyList_helper(*result);
50018 }
50019 return resultobj;
50020 fail:
50021 return NULL;
50022 }
50023
50024
50025 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50026 PyObject *resultobj = 0;
50027 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
50028 wxArrayInt *result = 0 ;
50029 void *argp1 = 0 ;
50030 int res1 = 0 ;
50031 PyObject *swig_obj[1] ;
50032
50033 if (!args) SWIG_fail;
50034 swig_obj[0] = args;
50035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
50036 if (!SWIG_IsOK(res1)) {
50037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
50038 }
50039 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
50040 {
50041 PyThreadState* __tstate = wxPyBeginAllowThreads();
50042 {
50043 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
50044 result = (wxArrayInt *) &_result_ref;
50045 }
50046 wxPyEndAllowThreads(__tstate);
50047 if (PyErr_Occurred()) SWIG_fail;
50048 }
50049 {
50050 resultobj = wxArrayInt2PyList_helper(*result);
50051 }
50052 return resultobj;
50053 fail:
50054 return NULL;
50055 }
50056
50057
50058 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50059 PyObject *obj;
50060 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50061 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
50062 return SWIG_Py_Void();
50063 }
50064
50065 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50066 return SWIG_Python_InitShadowInstance(args);
50067 }
50068
50069 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50070 PyObject *resultobj = 0;
50071 wxStdDialogButtonSizer *result = 0 ;
50072
50073 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
50074 {
50075 PyThreadState* __tstate = wxPyBeginAllowThreads();
50076 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
50077 wxPyEndAllowThreads(__tstate);
50078 if (PyErr_Occurred()) SWIG_fail;
50079 }
50080 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
50081 return resultobj;
50082 fail:
50083 return NULL;
50084 }
50085
50086
50087 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50088 PyObject *resultobj = 0;
50089 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50090 wxButton *arg2 = (wxButton *) 0 ;
50091 void *argp1 = 0 ;
50092 int res1 = 0 ;
50093 void *argp2 = 0 ;
50094 int res2 = 0 ;
50095 PyObject * obj0 = 0 ;
50096 PyObject * obj1 = 0 ;
50097 char * kwnames[] = {
50098 (char *) "self",(char *) "button", NULL
50099 };
50100
50101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
50102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50103 if (!SWIG_IsOK(res1)) {
50104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50105 }
50106 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50107 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50108 if (!SWIG_IsOK(res2)) {
50109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
50110 }
50111 arg2 = reinterpret_cast< wxButton * >(argp2);
50112 {
50113 PyThreadState* __tstate = wxPyBeginAllowThreads();
50114 (arg1)->AddButton(arg2);
50115 wxPyEndAllowThreads(__tstate);
50116 if (PyErr_Occurred()) SWIG_fail;
50117 }
50118 resultobj = SWIG_Py_Void();
50119 return resultobj;
50120 fail:
50121 return NULL;
50122 }
50123
50124
50125 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50126 PyObject *resultobj = 0;
50127 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50128 void *argp1 = 0 ;
50129 int res1 = 0 ;
50130 PyObject *swig_obj[1] ;
50131
50132 if (!args) SWIG_fail;
50133 swig_obj[0] = args;
50134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50135 if (!SWIG_IsOK(res1)) {
50136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50137 }
50138 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50139 {
50140 PyThreadState* __tstate = wxPyBeginAllowThreads();
50141 (arg1)->Realize();
50142 wxPyEndAllowThreads(__tstate);
50143 if (PyErr_Occurred()) SWIG_fail;
50144 }
50145 resultobj = SWIG_Py_Void();
50146 return resultobj;
50147 fail:
50148 return NULL;
50149 }
50150
50151
50152 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50153 PyObject *resultobj = 0;
50154 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50155 wxButton *arg2 = (wxButton *) 0 ;
50156 void *argp1 = 0 ;
50157 int res1 = 0 ;
50158 void *argp2 = 0 ;
50159 int res2 = 0 ;
50160 PyObject * obj0 = 0 ;
50161 PyObject * obj1 = 0 ;
50162 char * kwnames[] = {
50163 (char *) "self",(char *) "button", NULL
50164 };
50165
50166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
50167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50168 if (!SWIG_IsOK(res1)) {
50169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50170 }
50171 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50172 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50173 if (!SWIG_IsOK(res2)) {
50174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
50175 }
50176 arg2 = reinterpret_cast< wxButton * >(argp2);
50177 {
50178 PyThreadState* __tstate = wxPyBeginAllowThreads();
50179 (arg1)->SetAffirmativeButton(arg2);
50180 wxPyEndAllowThreads(__tstate);
50181 if (PyErr_Occurred()) SWIG_fail;
50182 }
50183 resultobj = SWIG_Py_Void();
50184 return resultobj;
50185 fail:
50186 return NULL;
50187 }
50188
50189
50190 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50191 PyObject *resultobj = 0;
50192 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50193 wxButton *arg2 = (wxButton *) 0 ;
50194 void *argp1 = 0 ;
50195 int res1 = 0 ;
50196 void *argp2 = 0 ;
50197 int res2 = 0 ;
50198 PyObject * obj0 = 0 ;
50199 PyObject * obj1 = 0 ;
50200 char * kwnames[] = {
50201 (char *) "self",(char *) "button", NULL
50202 };
50203
50204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
50205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50206 if (!SWIG_IsOK(res1)) {
50207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50208 }
50209 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50210 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50211 if (!SWIG_IsOK(res2)) {
50212 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
50213 }
50214 arg2 = reinterpret_cast< wxButton * >(argp2);
50215 {
50216 PyThreadState* __tstate = wxPyBeginAllowThreads();
50217 (arg1)->SetNegativeButton(arg2);
50218 wxPyEndAllowThreads(__tstate);
50219 if (PyErr_Occurred()) SWIG_fail;
50220 }
50221 resultobj = SWIG_Py_Void();
50222 return resultobj;
50223 fail:
50224 return NULL;
50225 }
50226
50227
50228 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50229 PyObject *resultobj = 0;
50230 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50231 wxButton *arg2 = (wxButton *) 0 ;
50232 void *argp1 = 0 ;
50233 int res1 = 0 ;
50234 void *argp2 = 0 ;
50235 int res2 = 0 ;
50236 PyObject * obj0 = 0 ;
50237 PyObject * obj1 = 0 ;
50238 char * kwnames[] = {
50239 (char *) "self",(char *) "button", NULL
50240 };
50241
50242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
50243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50244 if (!SWIG_IsOK(res1)) {
50245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50246 }
50247 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50248 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50249 if (!SWIG_IsOK(res2)) {
50250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
50251 }
50252 arg2 = reinterpret_cast< wxButton * >(argp2);
50253 {
50254 PyThreadState* __tstate = wxPyBeginAllowThreads();
50255 (arg1)->SetCancelButton(arg2);
50256 wxPyEndAllowThreads(__tstate);
50257 if (PyErr_Occurred()) SWIG_fail;
50258 }
50259 resultobj = SWIG_Py_Void();
50260 return resultobj;
50261 fail:
50262 return NULL;
50263 }
50264
50265
50266 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50267 PyObject *resultobj = 0;
50268 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50269 wxButton *result = 0 ;
50270 void *argp1 = 0 ;
50271 int res1 = 0 ;
50272 PyObject *swig_obj[1] ;
50273
50274 if (!args) SWIG_fail;
50275 swig_obj[0] = args;
50276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50277 if (!SWIG_IsOK(res1)) {
50278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50279 }
50280 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50281 {
50282 PyThreadState* __tstate = wxPyBeginAllowThreads();
50283 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
50284 wxPyEndAllowThreads(__tstate);
50285 if (PyErr_Occurred()) SWIG_fail;
50286 }
50287 {
50288 resultobj = wxPyMake_wxObject(result, (bool)0);
50289 }
50290 return resultobj;
50291 fail:
50292 return NULL;
50293 }
50294
50295
50296 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50297 PyObject *resultobj = 0;
50298 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50299 wxButton *result = 0 ;
50300 void *argp1 = 0 ;
50301 int res1 = 0 ;
50302 PyObject *swig_obj[1] ;
50303
50304 if (!args) SWIG_fail;
50305 swig_obj[0] = args;
50306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50307 if (!SWIG_IsOK(res1)) {
50308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50309 }
50310 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50311 {
50312 PyThreadState* __tstate = wxPyBeginAllowThreads();
50313 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
50314 wxPyEndAllowThreads(__tstate);
50315 if (PyErr_Occurred()) SWIG_fail;
50316 }
50317 {
50318 resultobj = wxPyMake_wxObject(result, (bool)0);
50319 }
50320 return resultobj;
50321 fail:
50322 return NULL;
50323 }
50324
50325
50326 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50327 PyObject *resultobj = 0;
50328 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50329 wxButton *result = 0 ;
50330 void *argp1 = 0 ;
50331 int res1 = 0 ;
50332 PyObject *swig_obj[1] ;
50333
50334 if (!args) SWIG_fail;
50335 swig_obj[0] = args;
50336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50337 if (!SWIG_IsOK(res1)) {
50338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50339 }
50340 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50341 {
50342 PyThreadState* __tstate = wxPyBeginAllowThreads();
50343 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
50344 wxPyEndAllowThreads(__tstate);
50345 if (PyErr_Occurred()) SWIG_fail;
50346 }
50347 {
50348 resultobj = wxPyMake_wxObject(result, (bool)0);
50349 }
50350 return resultobj;
50351 fail:
50352 return NULL;
50353 }
50354
50355
50356 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50357 PyObject *resultobj = 0;
50358 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50359 wxButton *result = 0 ;
50360 void *argp1 = 0 ;
50361 int res1 = 0 ;
50362 PyObject *swig_obj[1] ;
50363
50364 if (!args) SWIG_fail;
50365 swig_obj[0] = args;
50366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50367 if (!SWIG_IsOK(res1)) {
50368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50369 }
50370 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50371 {
50372 PyThreadState* __tstate = wxPyBeginAllowThreads();
50373 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
50374 wxPyEndAllowThreads(__tstate);
50375 if (PyErr_Occurred()) SWIG_fail;
50376 }
50377 {
50378 resultobj = wxPyMake_wxObject(result, (bool)0);
50379 }
50380 return resultobj;
50381 fail:
50382 return NULL;
50383 }
50384
50385
50386 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50387 PyObject *resultobj = 0;
50388 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50389 wxButton *result = 0 ;
50390 void *argp1 = 0 ;
50391 int res1 = 0 ;
50392 PyObject *swig_obj[1] ;
50393
50394 if (!args) SWIG_fail;
50395 swig_obj[0] = args;
50396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50397 if (!SWIG_IsOK(res1)) {
50398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50399 }
50400 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50401 {
50402 PyThreadState* __tstate = wxPyBeginAllowThreads();
50403 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
50404 wxPyEndAllowThreads(__tstate);
50405 if (PyErr_Occurred()) SWIG_fail;
50406 }
50407 {
50408 resultobj = wxPyMake_wxObject(result, (bool)0);
50409 }
50410 return resultobj;
50411 fail:
50412 return NULL;
50413 }
50414
50415
50416 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50417 PyObject *obj;
50418 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50419 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
50420 return SWIG_Py_Void();
50421 }
50422
50423 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50424 return SWIG_Python_InitShadowInstance(args);
50425 }
50426
50427 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50428 PyObject *resultobj = 0;
50429 int arg1 = (int) 0 ;
50430 int arg2 = (int) 0 ;
50431 wxGBPosition *result = 0 ;
50432 int val1 ;
50433 int ecode1 = 0 ;
50434 int val2 ;
50435 int ecode2 = 0 ;
50436 PyObject * obj0 = 0 ;
50437 PyObject * obj1 = 0 ;
50438 char * kwnames[] = {
50439 (char *) "row",(char *) "col", NULL
50440 };
50441
50442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50443 if (obj0) {
50444 ecode1 = SWIG_AsVal_int(obj0, &val1);
50445 if (!SWIG_IsOK(ecode1)) {
50446 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
50447 }
50448 arg1 = static_cast< int >(val1);
50449 }
50450 if (obj1) {
50451 ecode2 = SWIG_AsVal_int(obj1, &val2);
50452 if (!SWIG_IsOK(ecode2)) {
50453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
50454 }
50455 arg2 = static_cast< int >(val2);
50456 }
50457 {
50458 PyThreadState* __tstate = wxPyBeginAllowThreads();
50459 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
50460 wxPyEndAllowThreads(__tstate);
50461 if (PyErr_Occurred()) SWIG_fail;
50462 }
50463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
50464 return resultobj;
50465 fail:
50466 return NULL;
50467 }
50468
50469
50470 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50471 PyObject *resultobj = 0;
50472 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50473 void *argp1 = 0 ;
50474 int res1 = 0 ;
50475 PyObject *swig_obj[1] ;
50476
50477 if (!args) SWIG_fail;
50478 swig_obj[0] = args;
50479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
50480 if (!SWIG_IsOK(res1)) {
50481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50482 }
50483 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50484 {
50485 PyThreadState* __tstate = wxPyBeginAllowThreads();
50486 delete arg1;
50487
50488 wxPyEndAllowThreads(__tstate);
50489 if (PyErr_Occurred()) SWIG_fail;
50490 }
50491 resultobj = SWIG_Py_Void();
50492 return resultobj;
50493 fail:
50494 return NULL;
50495 }
50496
50497
50498 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50499 PyObject *resultobj = 0;
50500 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50501 int result;
50502 void *argp1 = 0 ;
50503 int res1 = 0 ;
50504 PyObject *swig_obj[1] ;
50505
50506 if (!args) SWIG_fail;
50507 swig_obj[0] = args;
50508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50509 if (!SWIG_IsOK(res1)) {
50510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50511 }
50512 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50513 {
50514 PyThreadState* __tstate = wxPyBeginAllowThreads();
50515 result = (int)((wxGBPosition const *)arg1)->GetRow();
50516 wxPyEndAllowThreads(__tstate);
50517 if (PyErr_Occurred()) SWIG_fail;
50518 }
50519 resultobj = SWIG_From_int(static_cast< int >(result));
50520 return resultobj;
50521 fail:
50522 return NULL;
50523 }
50524
50525
50526 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50527 PyObject *resultobj = 0;
50528 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50529 int result;
50530 void *argp1 = 0 ;
50531 int res1 = 0 ;
50532 PyObject *swig_obj[1] ;
50533
50534 if (!args) SWIG_fail;
50535 swig_obj[0] = args;
50536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50537 if (!SWIG_IsOK(res1)) {
50538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50539 }
50540 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50541 {
50542 PyThreadState* __tstate = wxPyBeginAllowThreads();
50543 result = (int)((wxGBPosition const *)arg1)->GetCol();
50544 wxPyEndAllowThreads(__tstate);
50545 if (PyErr_Occurred()) SWIG_fail;
50546 }
50547 resultobj = SWIG_From_int(static_cast< int >(result));
50548 return resultobj;
50549 fail:
50550 return NULL;
50551 }
50552
50553
50554 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50555 PyObject *resultobj = 0;
50556 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50557 int arg2 ;
50558 void *argp1 = 0 ;
50559 int res1 = 0 ;
50560 int val2 ;
50561 int ecode2 = 0 ;
50562 PyObject * obj0 = 0 ;
50563 PyObject * obj1 = 0 ;
50564 char * kwnames[] = {
50565 (char *) "self",(char *) "row", NULL
50566 };
50567
50568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
50569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50570 if (!SWIG_IsOK(res1)) {
50571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50572 }
50573 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50574 ecode2 = SWIG_AsVal_int(obj1, &val2);
50575 if (!SWIG_IsOK(ecode2)) {
50576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
50577 }
50578 arg2 = static_cast< int >(val2);
50579 {
50580 PyThreadState* __tstate = wxPyBeginAllowThreads();
50581 (arg1)->SetRow(arg2);
50582 wxPyEndAllowThreads(__tstate);
50583 if (PyErr_Occurred()) SWIG_fail;
50584 }
50585 resultobj = SWIG_Py_Void();
50586 return resultobj;
50587 fail:
50588 return NULL;
50589 }
50590
50591
50592 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50593 PyObject *resultobj = 0;
50594 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50595 int arg2 ;
50596 void *argp1 = 0 ;
50597 int res1 = 0 ;
50598 int val2 ;
50599 int ecode2 = 0 ;
50600 PyObject * obj0 = 0 ;
50601 PyObject * obj1 = 0 ;
50602 char * kwnames[] = {
50603 (char *) "self",(char *) "col", NULL
50604 };
50605
50606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
50607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50608 if (!SWIG_IsOK(res1)) {
50609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50610 }
50611 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50612 ecode2 = SWIG_AsVal_int(obj1, &val2);
50613 if (!SWIG_IsOK(ecode2)) {
50614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
50615 }
50616 arg2 = static_cast< int >(val2);
50617 {
50618 PyThreadState* __tstate = wxPyBeginAllowThreads();
50619 (arg1)->SetCol(arg2);
50620 wxPyEndAllowThreads(__tstate);
50621 if (PyErr_Occurred()) SWIG_fail;
50622 }
50623 resultobj = SWIG_Py_Void();
50624 return resultobj;
50625 fail:
50626 return NULL;
50627 }
50628
50629
50630 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50631 PyObject *resultobj = 0;
50632 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50633 PyObject *arg2 = (PyObject *) 0 ;
50634 bool result;
50635 void *argp1 = 0 ;
50636 int res1 = 0 ;
50637 PyObject * obj0 = 0 ;
50638 PyObject * obj1 = 0 ;
50639 char * kwnames[] = {
50640 (char *) "self",(char *) "other", NULL
50641 };
50642
50643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50645 if (!SWIG_IsOK(res1)) {
50646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50647 }
50648 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50649 arg2 = obj1;
50650 {
50651 result = (bool)wxGBPosition___eq__(arg1,arg2);
50652 if (PyErr_Occurred()) SWIG_fail;
50653 }
50654 {
50655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50656 }
50657 return resultobj;
50658 fail:
50659 return NULL;
50660 }
50661
50662
50663 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50664 PyObject *resultobj = 0;
50665 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50666 PyObject *arg2 = (PyObject *) 0 ;
50667 bool result;
50668 void *argp1 = 0 ;
50669 int res1 = 0 ;
50670 PyObject * obj0 = 0 ;
50671 PyObject * obj1 = 0 ;
50672 char * kwnames[] = {
50673 (char *) "self",(char *) "other", NULL
50674 };
50675
50676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50678 if (!SWIG_IsOK(res1)) {
50679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50680 }
50681 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50682 arg2 = obj1;
50683 {
50684 result = (bool)wxGBPosition___ne__(arg1,arg2);
50685 if (PyErr_Occurred()) SWIG_fail;
50686 }
50687 {
50688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50689 }
50690 return resultobj;
50691 fail:
50692 return NULL;
50693 }
50694
50695
50696 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50697 PyObject *resultobj = 0;
50698 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50699 int arg2 = (int) 0 ;
50700 int arg3 = (int) 0 ;
50701 void *argp1 = 0 ;
50702 int res1 = 0 ;
50703 int val2 ;
50704 int ecode2 = 0 ;
50705 int val3 ;
50706 int ecode3 = 0 ;
50707 PyObject * obj0 = 0 ;
50708 PyObject * obj1 = 0 ;
50709 PyObject * obj2 = 0 ;
50710 char * kwnames[] = {
50711 (char *) "self",(char *) "row",(char *) "col", NULL
50712 };
50713
50714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50716 if (!SWIG_IsOK(res1)) {
50717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50718 }
50719 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50720 if (obj1) {
50721 ecode2 = SWIG_AsVal_int(obj1, &val2);
50722 if (!SWIG_IsOK(ecode2)) {
50723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50724 }
50725 arg2 = static_cast< int >(val2);
50726 }
50727 if (obj2) {
50728 ecode3 = SWIG_AsVal_int(obj2, &val3);
50729 if (!SWIG_IsOK(ecode3)) {
50730 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50731 }
50732 arg3 = static_cast< int >(val3);
50733 }
50734 {
50735 PyThreadState* __tstate = wxPyBeginAllowThreads();
50736 wxGBPosition_Set(arg1,arg2,arg3);
50737 wxPyEndAllowThreads(__tstate);
50738 if (PyErr_Occurred()) SWIG_fail;
50739 }
50740 resultobj = SWIG_Py_Void();
50741 return resultobj;
50742 fail:
50743 return NULL;
50744 }
50745
50746
50747 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50748 PyObject *resultobj = 0;
50749 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50750 PyObject *result = 0 ;
50751 void *argp1 = 0 ;
50752 int res1 = 0 ;
50753 PyObject *swig_obj[1] ;
50754
50755 if (!args) SWIG_fail;
50756 swig_obj[0] = args;
50757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50758 if (!SWIG_IsOK(res1)) {
50759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50760 }
50761 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50762 {
50763 PyThreadState* __tstate = wxPyBeginAllowThreads();
50764 result = (PyObject *)wxGBPosition_Get(arg1);
50765 wxPyEndAllowThreads(__tstate);
50766 if (PyErr_Occurred()) SWIG_fail;
50767 }
50768 resultobj = result;
50769 return resultobj;
50770 fail:
50771 return NULL;
50772 }
50773
50774
50775 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50776 PyObject *obj;
50777 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50778 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50779 return SWIG_Py_Void();
50780 }
50781
50782 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50783 return SWIG_Python_InitShadowInstance(args);
50784 }
50785
50786 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50787 PyObject *resultobj = 0;
50788 int arg1 = (int) 1 ;
50789 int arg2 = (int) 1 ;
50790 wxGBSpan *result = 0 ;
50791 int val1 ;
50792 int ecode1 = 0 ;
50793 int val2 ;
50794 int ecode2 = 0 ;
50795 PyObject * obj0 = 0 ;
50796 PyObject * obj1 = 0 ;
50797 char * kwnames[] = {
50798 (char *) "rowspan",(char *) "colspan", NULL
50799 };
50800
50801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50802 if (obj0) {
50803 ecode1 = SWIG_AsVal_int(obj0, &val1);
50804 if (!SWIG_IsOK(ecode1)) {
50805 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50806 }
50807 arg1 = static_cast< int >(val1);
50808 }
50809 if (obj1) {
50810 ecode2 = SWIG_AsVal_int(obj1, &val2);
50811 if (!SWIG_IsOK(ecode2)) {
50812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50813 }
50814 arg2 = static_cast< int >(val2);
50815 }
50816 {
50817 PyThreadState* __tstate = wxPyBeginAllowThreads();
50818 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50819 wxPyEndAllowThreads(__tstate);
50820 if (PyErr_Occurred()) SWIG_fail;
50821 }
50822 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50823 return resultobj;
50824 fail:
50825 return NULL;
50826 }
50827
50828
50829 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50830 PyObject *resultobj = 0;
50831 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50832 void *argp1 = 0 ;
50833 int res1 = 0 ;
50834 PyObject *swig_obj[1] ;
50835
50836 if (!args) SWIG_fail;
50837 swig_obj[0] = args;
50838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50839 if (!SWIG_IsOK(res1)) {
50840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50841 }
50842 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50843 {
50844 PyThreadState* __tstate = wxPyBeginAllowThreads();
50845 delete arg1;
50846
50847 wxPyEndAllowThreads(__tstate);
50848 if (PyErr_Occurred()) SWIG_fail;
50849 }
50850 resultobj = SWIG_Py_Void();
50851 return resultobj;
50852 fail:
50853 return NULL;
50854 }
50855
50856
50857 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50858 PyObject *resultobj = 0;
50859 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50860 int result;
50861 void *argp1 = 0 ;
50862 int res1 = 0 ;
50863 PyObject *swig_obj[1] ;
50864
50865 if (!args) SWIG_fail;
50866 swig_obj[0] = args;
50867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50868 if (!SWIG_IsOK(res1)) {
50869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50870 }
50871 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50872 {
50873 PyThreadState* __tstate = wxPyBeginAllowThreads();
50874 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50875 wxPyEndAllowThreads(__tstate);
50876 if (PyErr_Occurred()) SWIG_fail;
50877 }
50878 resultobj = SWIG_From_int(static_cast< int >(result));
50879 return resultobj;
50880 fail:
50881 return NULL;
50882 }
50883
50884
50885 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50886 PyObject *resultobj = 0;
50887 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50888 int result;
50889 void *argp1 = 0 ;
50890 int res1 = 0 ;
50891 PyObject *swig_obj[1] ;
50892
50893 if (!args) SWIG_fail;
50894 swig_obj[0] = args;
50895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50896 if (!SWIG_IsOK(res1)) {
50897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50898 }
50899 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50900 {
50901 PyThreadState* __tstate = wxPyBeginAllowThreads();
50902 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50903 wxPyEndAllowThreads(__tstate);
50904 if (PyErr_Occurred()) SWIG_fail;
50905 }
50906 resultobj = SWIG_From_int(static_cast< int >(result));
50907 return resultobj;
50908 fail:
50909 return NULL;
50910 }
50911
50912
50913 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50914 PyObject *resultobj = 0;
50915 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50916 int arg2 ;
50917 void *argp1 = 0 ;
50918 int res1 = 0 ;
50919 int val2 ;
50920 int ecode2 = 0 ;
50921 PyObject * obj0 = 0 ;
50922 PyObject * obj1 = 0 ;
50923 char * kwnames[] = {
50924 (char *) "self",(char *) "rowspan", NULL
50925 };
50926
50927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50929 if (!SWIG_IsOK(res1)) {
50930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50931 }
50932 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50933 ecode2 = SWIG_AsVal_int(obj1, &val2);
50934 if (!SWIG_IsOK(ecode2)) {
50935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50936 }
50937 arg2 = static_cast< int >(val2);
50938 {
50939 PyThreadState* __tstate = wxPyBeginAllowThreads();
50940 (arg1)->SetRowspan(arg2);
50941 wxPyEndAllowThreads(__tstate);
50942 if (PyErr_Occurred()) SWIG_fail;
50943 }
50944 resultobj = SWIG_Py_Void();
50945 return resultobj;
50946 fail:
50947 return NULL;
50948 }
50949
50950
50951 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50952 PyObject *resultobj = 0;
50953 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50954 int arg2 ;
50955 void *argp1 = 0 ;
50956 int res1 = 0 ;
50957 int val2 ;
50958 int ecode2 = 0 ;
50959 PyObject * obj0 = 0 ;
50960 PyObject * obj1 = 0 ;
50961 char * kwnames[] = {
50962 (char *) "self",(char *) "colspan", NULL
50963 };
50964
50965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50967 if (!SWIG_IsOK(res1)) {
50968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50969 }
50970 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50971 ecode2 = SWIG_AsVal_int(obj1, &val2);
50972 if (!SWIG_IsOK(ecode2)) {
50973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
50974 }
50975 arg2 = static_cast< int >(val2);
50976 {
50977 PyThreadState* __tstate = wxPyBeginAllowThreads();
50978 (arg1)->SetColspan(arg2);
50979 wxPyEndAllowThreads(__tstate);
50980 if (PyErr_Occurred()) SWIG_fail;
50981 }
50982 resultobj = SWIG_Py_Void();
50983 return resultobj;
50984 fail:
50985 return NULL;
50986 }
50987
50988
50989 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50990 PyObject *resultobj = 0;
50991 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50992 PyObject *arg2 = (PyObject *) 0 ;
50993 bool result;
50994 void *argp1 = 0 ;
50995 int res1 = 0 ;
50996 PyObject * obj0 = 0 ;
50997 PyObject * obj1 = 0 ;
50998 char * kwnames[] = {
50999 (char *) "self",(char *) "other", NULL
51000 };
51001
51002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
51003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51004 if (!SWIG_IsOK(res1)) {
51005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51006 }
51007 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51008 arg2 = obj1;
51009 {
51010 result = (bool)wxGBSpan___eq__(arg1,arg2);
51011 if (PyErr_Occurred()) SWIG_fail;
51012 }
51013 {
51014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51015 }
51016 return resultobj;
51017 fail:
51018 return NULL;
51019 }
51020
51021
51022 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51023 PyObject *resultobj = 0;
51024 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51025 PyObject *arg2 = (PyObject *) 0 ;
51026 bool result;
51027 void *argp1 = 0 ;
51028 int res1 = 0 ;
51029 PyObject * obj0 = 0 ;
51030 PyObject * obj1 = 0 ;
51031 char * kwnames[] = {
51032 (char *) "self",(char *) "other", NULL
51033 };
51034
51035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
51036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51037 if (!SWIG_IsOK(res1)) {
51038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51039 }
51040 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51041 arg2 = obj1;
51042 {
51043 result = (bool)wxGBSpan___ne__(arg1,arg2);
51044 if (PyErr_Occurred()) SWIG_fail;
51045 }
51046 {
51047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51048 }
51049 return resultobj;
51050 fail:
51051 return NULL;
51052 }
51053
51054
51055 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51056 PyObject *resultobj = 0;
51057 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51058 int arg2 = (int) 1 ;
51059 int arg3 = (int) 1 ;
51060 void *argp1 = 0 ;
51061 int res1 = 0 ;
51062 int val2 ;
51063 int ecode2 = 0 ;
51064 int val3 ;
51065 int ecode3 = 0 ;
51066 PyObject * obj0 = 0 ;
51067 PyObject * obj1 = 0 ;
51068 PyObject * obj2 = 0 ;
51069 char * kwnames[] = {
51070 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
51071 };
51072
51073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51075 if (!SWIG_IsOK(res1)) {
51076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51077 }
51078 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51079 if (obj1) {
51080 ecode2 = SWIG_AsVal_int(obj1, &val2);
51081 if (!SWIG_IsOK(ecode2)) {
51082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
51083 }
51084 arg2 = static_cast< int >(val2);
51085 }
51086 if (obj2) {
51087 ecode3 = SWIG_AsVal_int(obj2, &val3);
51088 if (!SWIG_IsOK(ecode3)) {
51089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
51090 }
51091 arg3 = static_cast< int >(val3);
51092 }
51093 {
51094 PyThreadState* __tstate = wxPyBeginAllowThreads();
51095 wxGBSpan_Set(arg1,arg2,arg3);
51096 wxPyEndAllowThreads(__tstate);
51097 if (PyErr_Occurred()) SWIG_fail;
51098 }
51099 resultobj = SWIG_Py_Void();
51100 return resultobj;
51101 fail:
51102 return NULL;
51103 }
51104
51105
51106 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51107 PyObject *resultobj = 0;
51108 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51109 PyObject *result = 0 ;
51110 void *argp1 = 0 ;
51111 int res1 = 0 ;
51112 PyObject *swig_obj[1] ;
51113
51114 if (!args) SWIG_fail;
51115 swig_obj[0] = args;
51116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51117 if (!SWIG_IsOK(res1)) {
51118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51119 }
51120 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51121 {
51122 PyThreadState* __tstate = wxPyBeginAllowThreads();
51123 result = (PyObject *)wxGBSpan_Get(arg1);
51124 wxPyEndAllowThreads(__tstate);
51125 if (PyErr_Occurred()) SWIG_fail;
51126 }
51127 resultobj = result;
51128 return resultobj;
51129 fail:
51130 return NULL;
51131 }
51132
51133
51134 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51135 PyObject *obj;
51136 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51137 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
51138 return SWIG_Py_Void();
51139 }
51140
51141 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51142 return SWIG_Python_InitShadowInstance(args);
51143 }
51144
51145 SWIGINTERN int DefaultSpan_set(PyObject *) {
51146 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
51147 return 1;
51148 }
51149
51150
51151 SWIGINTERN PyObject *DefaultSpan_get(void) {
51152 PyObject *pyobj = 0;
51153
51154 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
51155 return pyobj;
51156 }
51157
51158
51159 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51160 PyObject *resultobj = 0;
51161 wxGBSizerItem *result = 0 ;
51162
51163 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
51164 {
51165 PyThreadState* __tstate = wxPyBeginAllowThreads();
51166 result = (wxGBSizerItem *)new wxGBSizerItem();
51167 wxPyEndAllowThreads(__tstate);
51168 if (PyErr_Occurred()) SWIG_fail;
51169 }
51170 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
51171 return resultobj;
51172 fail:
51173 return NULL;
51174 }
51175
51176
51177 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51178 PyObject *resultobj = 0;
51179 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51180 void *argp1 = 0 ;
51181 int res1 = 0 ;
51182 PyObject *swig_obj[1] ;
51183
51184 if (!args) SWIG_fail;
51185 swig_obj[0] = args;
51186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51187 if (!SWIG_IsOK(res1)) {
51188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51189 }
51190 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51191 {
51192 PyThreadState* __tstate = wxPyBeginAllowThreads();
51193 delete arg1;
51194
51195 wxPyEndAllowThreads(__tstate);
51196 if (PyErr_Occurred()) SWIG_fail;
51197 }
51198 resultobj = SWIG_Py_Void();
51199 return resultobj;
51200 fail:
51201 return NULL;
51202 }
51203
51204
51205 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51206 PyObject *resultobj = 0;
51207 wxWindow *arg1 = (wxWindow *) 0 ;
51208 wxGBPosition *arg2 = 0 ;
51209 wxGBSpan *arg3 = 0 ;
51210 int arg4 ;
51211 int arg5 ;
51212 PyObject *arg6 = (PyObject *) NULL ;
51213 wxGBSizerItem *result = 0 ;
51214 void *argp1 = 0 ;
51215 int res1 = 0 ;
51216 wxGBPosition temp2 ;
51217 wxGBSpan temp3 ;
51218 int val4 ;
51219 int ecode4 = 0 ;
51220 int val5 ;
51221 int ecode5 = 0 ;
51222 PyObject * obj0 = 0 ;
51223 PyObject * obj1 = 0 ;
51224 PyObject * obj2 = 0 ;
51225 PyObject * obj3 = 0 ;
51226 PyObject * obj4 = 0 ;
51227 PyObject * obj5 = 0 ;
51228 char * kwnames[] = {
51229 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51230 };
51231
51232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
51234 if (!SWIG_IsOK(res1)) {
51235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
51236 }
51237 arg1 = reinterpret_cast< wxWindow * >(argp1);
51238 {
51239 arg2 = &temp2;
51240 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51241 }
51242 {
51243 arg3 = &temp3;
51244 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51245 }
51246 ecode4 = SWIG_AsVal_int(obj3, &val4);
51247 if (!SWIG_IsOK(ecode4)) {
51248 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
51249 }
51250 arg4 = static_cast< int >(val4);
51251 ecode5 = SWIG_AsVal_int(obj4, &val5);
51252 if (!SWIG_IsOK(ecode5)) {
51253 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
51254 }
51255 arg5 = static_cast< int >(val5);
51256 if (obj5) {
51257 arg6 = obj5;
51258 }
51259 {
51260 PyThreadState* __tstate = wxPyBeginAllowThreads();
51261 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
51262 wxPyEndAllowThreads(__tstate);
51263 if (PyErr_Occurred()) SWIG_fail;
51264 }
51265 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51266 return resultobj;
51267 fail:
51268 return NULL;
51269 }
51270
51271
51272 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51273 PyObject *resultobj = 0;
51274 wxSizer *arg1 = (wxSizer *) 0 ;
51275 wxGBPosition *arg2 = 0 ;
51276 wxGBSpan *arg3 = 0 ;
51277 int arg4 ;
51278 int arg5 ;
51279 PyObject *arg6 = (PyObject *) NULL ;
51280 wxGBSizerItem *result = 0 ;
51281 int res1 = 0 ;
51282 wxGBPosition temp2 ;
51283 wxGBSpan temp3 ;
51284 int val4 ;
51285 int ecode4 = 0 ;
51286 int val5 ;
51287 int ecode5 = 0 ;
51288 PyObject * obj0 = 0 ;
51289 PyObject * obj1 = 0 ;
51290 PyObject * obj2 = 0 ;
51291 PyObject * obj3 = 0 ;
51292 PyObject * obj4 = 0 ;
51293 PyObject * obj5 = 0 ;
51294 char * kwnames[] = {
51295 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51296 };
51297
51298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51299 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51300 if (!SWIG_IsOK(res1)) {
51301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51302 }
51303 {
51304 arg2 = &temp2;
51305 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51306 }
51307 {
51308 arg3 = &temp3;
51309 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51310 }
51311 ecode4 = SWIG_AsVal_int(obj3, &val4);
51312 if (!SWIG_IsOK(ecode4)) {
51313 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
51314 }
51315 arg4 = static_cast< int >(val4);
51316 ecode5 = SWIG_AsVal_int(obj4, &val5);
51317 if (!SWIG_IsOK(ecode5)) {
51318 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
51319 }
51320 arg5 = static_cast< int >(val5);
51321 if (obj5) {
51322 arg6 = obj5;
51323 }
51324 {
51325 PyThreadState* __tstate = wxPyBeginAllowThreads();
51326 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
51327 wxPyEndAllowThreads(__tstate);
51328 if (PyErr_Occurred()) SWIG_fail;
51329 }
51330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51331 return resultobj;
51332 fail:
51333 return NULL;
51334 }
51335
51336
51337 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51338 PyObject *resultobj = 0;
51339 int arg1 ;
51340 int arg2 ;
51341 wxGBPosition *arg3 = 0 ;
51342 wxGBSpan *arg4 = 0 ;
51343 int arg5 ;
51344 int arg6 ;
51345 PyObject *arg7 = (PyObject *) NULL ;
51346 wxGBSizerItem *result = 0 ;
51347 int val1 ;
51348 int ecode1 = 0 ;
51349 int val2 ;
51350 int ecode2 = 0 ;
51351 wxGBPosition temp3 ;
51352 wxGBSpan temp4 ;
51353 int val5 ;
51354 int ecode5 = 0 ;
51355 int val6 ;
51356 int ecode6 = 0 ;
51357 PyObject * obj0 = 0 ;
51358 PyObject * obj1 = 0 ;
51359 PyObject * obj2 = 0 ;
51360 PyObject * obj3 = 0 ;
51361 PyObject * obj4 = 0 ;
51362 PyObject * obj5 = 0 ;
51363 PyObject * obj6 = 0 ;
51364 char * kwnames[] = {
51365 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51366 };
51367
51368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51369 ecode1 = SWIG_AsVal_int(obj0, &val1);
51370 if (!SWIG_IsOK(ecode1)) {
51371 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
51372 }
51373 arg1 = static_cast< int >(val1);
51374 ecode2 = SWIG_AsVal_int(obj1, &val2);
51375 if (!SWIG_IsOK(ecode2)) {
51376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
51377 }
51378 arg2 = static_cast< int >(val2);
51379 {
51380 arg3 = &temp3;
51381 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51382 }
51383 {
51384 arg4 = &temp4;
51385 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51386 }
51387 ecode5 = SWIG_AsVal_int(obj4, &val5);
51388 if (!SWIG_IsOK(ecode5)) {
51389 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
51390 }
51391 arg5 = static_cast< int >(val5);
51392 ecode6 = SWIG_AsVal_int(obj5, &val6);
51393 if (!SWIG_IsOK(ecode6)) {
51394 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
51395 }
51396 arg6 = static_cast< int >(val6);
51397 if (obj6) {
51398 arg7 = obj6;
51399 }
51400 {
51401 PyThreadState* __tstate = wxPyBeginAllowThreads();
51402 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51403 wxPyEndAllowThreads(__tstate);
51404 if (PyErr_Occurred()) SWIG_fail;
51405 }
51406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51407 return resultobj;
51408 fail:
51409 return NULL;
51410 }
51411
51412
51413 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51414 PyObject *resultobj = 0;
51415 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51416 wxGBPosition result;
51417 void *argp1 = 0 ;
51418 int res1 = 0 ;
51419 PyObject *swig_obj[1] ;
51420
51421 if (!args) SWIG_fail;
51422 swig_obj[0] = args;
51423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51424 if (!SWIG_IsOK(res1)) {
51425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51426 }
51427 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51428 {
51429 PyThreadState* __tstate = wxPyBeginAllowThreads();
51430 result = ((wxGBSizerItem const *)arg1)->GetPos();
51431 wxPyEndAllowThreads(__tstate);
51432 if (PyErr_Occurred()) SWIG_fail;
51433 }
51434 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51435 return resultobj;
51436 fail:
51437 return NULL;
51438 }
51439
51440
51441 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51442 PyObject *resultobj = 0;
51443 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51444 wxGBSpan result;
51445 void *argp1 = 0 ;
51446 int res1 = 0 ;
51447 PyObject *swig_obj[1] ;
51448
51449 if (!args) SWIG_fail;
51450 swig_obj[0] = args;
51451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51452 if (!SWIG_IsOK(res1)) {
51453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51454 }
51455 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51456 {
51457 PyThreadState* __tstate = wxPyBeginAllowThreads();
51458 result = ((wxGBSizerItem const *)arg1)->GetSpan();
51459 wxPyEndAllowThreads(__tstate);
51460 if (PyErr_Occurred()) SWIG_fail;
51461 }
51462 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51463 return resultobj;
51464 fail:
51465 return NULL;
51466 }
51467
51468
51469 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51470 PyObject *resultobj = 0;
51471 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51472 wxGBPosition *arg2 = 0 ;
51473 bool result;
51474 void *argp1 = 0 ;
51475 int res1 = 0 ;
51476 wxGBPosition temp2 ;
51477 PyObject * obj0 = 0 ;
51478 PyObject * obj1 = 0 ;
51479 char * kwnames[] = {
51480 (char *) "self",(char *) "pos", NULL
51481 };
51482
51483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
51484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51485 if (!SWIG_IsOK(res1)) {
51486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51487 }
51488 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51489 {
51490 arg2 = &temp2;
51491 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51492 }
51493 {
51494 PyThreadState* __tstate = wxPyBeginAllowThreads();
51495 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
51496 wxPyEndAllowThreads(__tstate);
51497 if (PyErr_Occurred()) SWIG_fail;
51498 }
51499 {
51500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51501 }
51502 return resultobj;
51503 fail:
51504 return NULL;
51505 }
51506
51507
51508 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51509 PyObject *resultobj = 0;
51510 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51511 wxGBSpan *arg2 = 0 ;
51512 bool result;
51513 void *argp1 = 0 ;
51514 int res1 = 0 ;
51515 wxGBSpan temp2 ;
51516 PyObject * obj0 = 0 ;
51517 PyObject * obj1 = 0 ;
51518 char * kwnames[] = {
51519 (char *) "self",(char *) "span", NULL
51520 };
51521
51522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
51523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51524 if (!SWIG_IsOK(res1)) {
51525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51526 }
51527 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51528 {
51529 arg2 = &temp2;
51530 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
51531 }
51532 {
51533 PyThreadState* __tstate = wxPyBeginAllowThreads();
51534 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
51535 wxPyEndAllowThreads(__tstate);
51536 if (PyErr_Occurred()) SWIG_fail;
51537 }
51538 {
51539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51540 }
51541 return resultobj;
51542 fail:
51543 return NULL;
51544 }
51545
51546
51547 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51548 PyObject *resultobj = 0;
51549 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51550 wxGBSizerItem *arg2 = 0 ;
51551 bool result;
51552 void *argp1 = 0 ;
51553 int res1 = 0 ;
51554 void *argp2 = 0 ;
51555 int res2 = 0 ;
51556 PyObject * obj0 = 0 ;
51557 PyObject * obj1 = 0 ;
51558 char * kwnames[] = {
51559 (char *) "self",(char *) "other", NULL
51560 };
51561
51562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
51563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51564 if (!SWIG_IsOK(res1)) {
51565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51566 }
51567 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51568 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
51569 if (!SWIG_IsOK(res2)) {
51570 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51571 }
51572 if (!argp2) {
51573 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51574 }
51575 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51576 {
51577 PyThreadState* __tstate = wxPyBeginAllowThreads();
51578 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
51579 wxPyEndAllowThreads(__tstate);
51580 if (PyErr_Occurred()) SWIG_fail;
51581 }
51582 {
51583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51584 }
51585 return resultobj;
51586 fail:
51587 return NULL;
51588 }
51589
51590
51591 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51592 PyObject *resultobj = 0;
51593 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51594 wxGBPosition *arg2 = 0 ;
51595 wxGBSpan *arg3 = 0 ;
51596 bool result;
51597 void *argp1 = 0 ;
51598 int res1 = 0 ;
51599 wxGBPosition temp2 ;
51600 wxGBSpan temp3 ;
51601 PyObject * obj0 = 0 ;
51602 PyObject * obj1 = 0 ;
51603 PyObject * obj2 = 0 ;
51604 char * kwnames[] = {
51605 (char *) "self",(char *) "pos",(char *) "span", NULL
51606 };
51607
51608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51610 if (!SWIG_IsOK(res1)) {
51611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51612 }
51613 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51614 {
51615 arg2 = &temp2;
51616 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51617 }
51618 {
51619 arg3 = &temp3;
51620 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51621 }
51622 {
51623 PyThreadState* __tstate = wxPyBeginAllowThreads();
51624 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51625 wxPyEndAllowThreads(__tstate);
51626 if (PyErr_Occurred()) SWIG_fail;
51627 }
51628 {
51629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51630 }
51631 return resultobj;
51632 fail:
51633 return NULL;
51634 }
51635
51636
51637 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51638 PyObject *resultobj = 0;
51639 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51640 wxGBPosition result;
51641 void *argp1 = 0 ;
51642 int res1 = 0 ;
51643 PyObject *swig_obj[1] ;
51644
51645 if (!args) SWIG_fail;
51646 swig_obj[0] = args;
51647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51648 if (!SWIG_IsOK(res1)) {
51649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51650 }
51651 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51652 {
51653 PyThreadState* __tstate = wxPyBeginAllowThreads();
51654 result = wxGBSizerItem_GetEndPos(arg1);
51655 wxPyEndAllowThreads(__tstate);
51656 if (PyErr_Occurred()) SWIG_fail;
51657 }
51658 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51659 return resultobj;
51660 fail:
51661 return NULL;
51662 }
51663
51664
51665 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51666 PyObject *resultobj = 0;
51667 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51668 wxGridBagSizer *result = 0 ;
51669 void *argp1 = 0 ;
51670 int res1 = 0 ;
51671 PyObject *swig_obj[1] ;
51672
51673 if (!args) SWIG_fail;
51674 swig_obj[0] = args;
51675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51676 if (!SWIG_IsOK(res1)) {
51677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51678 }
51679 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51680 {
51681 PyThreadState* __tstate = wxPyBeginAllowThreads();
51682 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51683 wxPyEndAllowThreads(__tstate);
51684 if (PyErr_Occurred()) SWIG_fail;
51685 }
51686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51687 return resultobj;
51688 fail:
51689 return NULL;
51690 }
51691
51692
51693 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51694 PyObject *resultobj = 0;
51695 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51696 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
51697 void *argp1 = 0 ;
51698 int res1 = 0 ;
51699 void *argp2 = 0 ;
51700 int res2 = 0 ;
51701 PyObject * obj0 = 0 ;
51702 PyObject * obj1 = 0 ;
51703 char * kwnames[] = {
51704 (char *) "self",(char *) "sizer", NULL
51705 };
51706
51707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51709 if (!SWIG_IsOK(res1)) {
51710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51711 }
51712 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51713 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51714 if (!SWIG_IsOK(res2)) {
51715 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51716 }
51717 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51718 {
51719 PyThreadState* __tstate = wxPyBeginAllowThreads();
51720 (arg1)->SetGBSizer(arg2);
51721 wxPyEndAllowThreads(__tstate);
51722 if (PyErr_Occurred()) SWIG_fail;
51723 }
51724 resultobj = SWIG_Py_Void();
51725 return resultobj;
51726 fail:
51727 return NULL;
51728 }
51729
51730
51731 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51732 PyObject *obj;
51733 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51734 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51735 return SWIG_Py_Void();
51736 }
51737
51738 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51739 return SWIG_Python_InitShadowInstance(args);
51740 }
51741
51742 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51743 PyObject *resultobj = 0;
51744 int arg1 = (int) 0 ;
51745 int arg2 = (int) 0 ;
51746 wxGridBagSizer *result = 0 ;
51747 int val1 ;
51748 int ecode1 = 0 ;
51749 int val2 ;
51750 int ecode2 = 0 ;
51751 PyObject * obj0 = 0 ;
51752 PyObject * obj1 = 0 ;
51753 char * kwnames[] = {
51754 (char *) "vgap",(char *) "hgap", NULL
51755 };
51756
51757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51758 if (obj0) {
51759 ecode1 = SWIG_AsVal_int(obj0, &val1);
51760 if (!SWIG_IsOK(ecode1)) {
51761 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51762 }
51763 arg1 = static_cast< int >(val1);
51764 }
51765 if (obj1) {
51766 ecode2 = SWIG_AsVal_int(obj1, &val2);
51767 if (!SWIG_IsOK(ecode2)) {
51768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51769 }
51770 arg2 = static_cast< int >(val2);
51771 }
51772 {
51773 PyThreadState* __tstate = wxPyBeginAllowThreads();
51774 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51775 wxPyEndAllowThreads(__tstate);
51776 if (PyErr_Occurred()) SWIG_fail;
51777 }
51778 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51779 return resultobj;
51780 fail:
51781 return NULL;
51782 }
51783
51784
51785 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51786 PyObject *resultobj = 0;
51787 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51788 PyObject *arg2 = (PyObject *) 0 ;
51789 wxGBPosition *arg3 = 0 ;
51790 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51791 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51792 int arg5 = (int) 0 ;
51793 int arg6 = (int) 0 ;
51794 PyObject *arg7 = (PyObject *) NULL ;
51795 wxGBSizerItem *result = 0 ;
51796 void *argp1 = 0 ;
51797 int res1 = 0 ;
51798 wxGBPosition temp3 ;
51799 wxGBSpan temp4 ;
51800 int val5 ;
51801 int ecode5 = 0 ;
51802 int val6 ;
51803 int ecode6 = 0 ;
51804 PyObject * obj0 = 0 ;
51805 PyObject * obj1 = 0 ;
51806 PyObject * obj2 = 0 ;
51807 PyObject * obj3 = 0 ;
51808 PyObject * obj4 = 0 ;
51809 PyObject * obj5 = 0 ;
51810 PyObject * obj6 = 0 ;
51811 char * kwnames[] = {
51812 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51813 };
51814
51815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51817 if (!SWIG_IsOK(res1)) {
51818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51819 }
51820 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51821 arg2 = obj1;
51822 {
51823 arg3 = &temp3;
51824 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51825 }
51826 if (obj3) {
51827 {
51828 arg4 = &temp4;
51829 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51830 }
51831 }
51832 if (obj4) {
51833 ecode5 = SWIG_AsVal_int(obj4, &val5);
51834 if (!SWIG_IsOK(ecode5)) {
51835 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51836 }
51837 arg5 = static_cast< int >(val5);
51838 }
51839 if (obj5) {
51840 ecode6 = SWIG_AsVal_int(obj5, &val6);
51841 if (!SWIG_IsOK(ecode6)) {
51842 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51843 }
51844 arg6 = static_cast< int >(val6);
51845 }
51846 if (obj6) {
51847 arg7 = obj6;
51848 }
51849 {
51850 PyThreadState* __tstate = wxPyBeginAllowThreads();
51851 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51852 wxPyEndAllowThreads(__tstate);
51853 if (PyErr_Occurred()) SWIG_fail;
51854 }
51855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51856 return resultobj;
51857 fail:
51858 return NULL;
51859 }
51860
51861
51862 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51863 PyObject *resultobj = 0;
51864 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51865 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51866 wxGBSizerItem *result = 0 ;
51867 void *argp1 = 0 ;
51868 int res1 = 0 ;
51869 int res2 = 0 ;
51870 PyObject * obj0 = 0 ;
51871 PyObject * obj1 = 0 ;
51872 char * kwnames[] = {
51873 (char *) "self",(char *) "item", NULL
51874 };
51875
51876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51878 if (!SWIG_IsOK(res1)) {
51879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51880 }
51881 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51882 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51883 if (!SWIG_IsOK(res2)) {
51884 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51885 }
51886 {
51887 PyThreadState* __tstate = wxPyBeginAllowThreads();
51888 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51889 wxPyEndAllowThreads(__tstate);
51890 if (PyErr_Occurred()) SWIG_fail;
51891 }
51892 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51893 return resultobj;
51894 fail:
51895 return NULL;
51896 }
51897
51898
51899 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51900 PyObject *resultobj = 0;
51901 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51902 int arg2 ;
51903 int arg3 ;
51904 wxSize result;
51905 void *argp1 = 0 ;
51906 int res1 = 0 ;
51907 int val2 ;
51908 int ecode2 = 0 ;
51909 int val3 ;
51910 int ecode3 = 0 ;
51911 PyObject * obj0 = 0 ;
51912 PyObject * obj1 = 0 ;
51913 PyObject * obj2 = 0 ;
51914 char * kwnames[] = {
51915 (char *) "self",(char *) "row",(char *) "col", NULL
51916 };
51917
51918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51920 if (!SWIG_IsOK(res1)) {
51921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51922 }
51923 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51924 ecode2 = SWIG_AsVal_int(obj1, &val2);
51925 if (!SWIG_IsOK(ecode2)) {
51926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51927 }
51928 arg2 = static_cast< int >(val2);
51929 ecode3 = SWIG_AsVal_int(obj2, &val3);
51930 if (!SWIG_IsOK(ecode3)) {
51931 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51932 }
51933 arg3 = static_cast< int >(val3);
51934 {
51935 PyThreadState* __tstate = wxPyBeginAllowThreads();
51936 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51937 wxPyEndAllowThreads(__tstate);
51938 if (PyErr_Occurred()) SWIG_fail;
51939 }
51940 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51941 return resultobj;
51942 fail:
51943 return NULL;
51944 }
51945
51946
51947 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51948 PyObject *resultobj = 0;
51949 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51950 wxSize result;
51951 void *argp1 = 0 ;
51952 int res1 = 0 ;
51953 PyObject *swig_obj[1] ;
51954
51955 if (!args) SWIG_fail;
51956 swig_obj[0] = args;
51957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51958 if (!SWIG_IsOK(res1)) {
51959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51960 }
51961 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51962 {
51963 PyThreadState* __tstate = wxPyBeginAllowThreads();
51964 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51965 wxPyEndAllowThreads(__tstate);
51966 if (PyErr_Occurred()) SWIG_fail;
51967 }
51968 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51969 return resultobj;
51970 fail:
51971 return NULL;
51972 }
51973
51974
51975 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51976 PyObject *resultobj = 0;
51977 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51978 wxSize *arg2 = 0 ;
51979 void *argp1 = 0 ;
51980 int res1 = 0 ;
51981 wxSize temp2 ;
51982 PyObject * obj0 = 0 ;
51983 PyObject * obj1 = 0 ;
51984 char * kwnames[] = {
51985 (char *) "self",(char *) "sz", NULL
51986 };
51987
51988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
51989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51990 if (!SWIG_IsOK(res1)) {
51991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51992 }
51993 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51994 {
51995 arg2 = &temp2;
51996 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51997 }
51998 {
51999 PyThreadState* __tstate = wxPyBeginAllowThreads();
52000 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
52001 wxPyEndAllowThreads(__tstate);
52002 if (PyErr_Occurred()) SWIG_fail;
52003 }
52004 resultobj = SWIG_Py_Void();
52005 return resultobj;
52006 fail:
52007 return NULL;
52008 }
52009
52010
52011 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52012 PyObject *resultobj = 0;
52013 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52014 wxWindow *arg2 = (wxWindow *) 0 ;
52015 wxGBPosition result;
52016 void *argp1 = 0 ;
52017 int res1 = 0 ;
52018 void *argp2 = 0 ;
52019 int res2 = 0 ;
52020
52021 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52023 if (!SWIG_IsOK(res1)) {
52024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52025 }
52026 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52027 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52028 if (!SWIG_IsOK(res2)) {
52029 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
52030 }
52031 arg2 = reinterpret_cast< wxWindow * >(argp2);
52032 {
52033 PyThreadState* __tstate = wxPyBeginAllowThreads();
52034 result = (arg1)->GetItemPosition(arg2);
52035 wxPyEndAllowThreads(__tstate);
52036 if (PyErr_Occurred()) SWIG_fail;
52037 }
52038 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52039 return resultobj;
52040 fail:
52041 return NULL;
52042 }
52043
52044
52045 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52046 PyObject *resultobj = 0;
52047 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52048 wxSizer *arg2 = (wxSizer *) 0 ;
52049 wxGBPosition result;
52050 void *argp1 = 0 ;
52051 int res1 = 0 ;
52052 void *argp2 = 0 ;
52053 int res2 = 0 ;
52054
52055 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52057 if (!SWIG_IsOK(res1)) {
52058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52059 }
52060 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52061 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52062 if (!SWIG_IsOK(res2)) {
52063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
52064 }
52065 arg2 = reinterpret_cast< wxSizer * >(argp2);
52066 {
52067 PyThreadState* __tstate = wxPyBeginAllowThreads();
52068 result = (arg1)->GetItemPosition(arg2);
52069 wxPyEndAllowThreads(__tstate);
52070 if (PyErr_Occurred()) SWIG_fail;
52071 }
52072 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52073 return resultobj;
52074 fail:
52075 return NULL;
52076 }
52077
52078
52079 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52080 PyObject *resultobj = 0;
52081 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52082 size_t arg2 ;
52083 wxGBPosition result;
52084 void *argp1 = 0 ;
52085 int res1 = 0 ;
52086 size_t val2 ;
52087 int ecode2 = 0 ;
52088
52089 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52091 if (!SWIG_IsOK(res1)) {
52092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52093 }
52094 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52095 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52096 if (!SWIG_IsOK(ecode2)) {
52097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
52098 }
52099 arg2 = static_cast< size_t >(val2);
52100 {
52101 PyThreadState* __tstate = wxPyBeginAllowThreads();
52102 result = (arg1)->GetItemPosition(arg2);
52103 wxPyEndAllowThreads(__tstate);
52104 if (PyErr_Occurred()) SWIG_fail;
52105 }
52106 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52107 return resultobj;
52108 fail:
52109 return NULL;
52110 }
52111
52112
52113 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
52114 int argc;
52115 PyObject *argv[3];
52116
52117 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
52118 --argc;
52119 if (argc == 2) {
52120 int _v = 0;
52121 {
52122 void *vptr = 0;
52123 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52124 _v = SWIG_CheckState(res);
52125 }
52126 if (!_v) goto check_1;
52127 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
52128 }
52129 check_1:
52130
52131 if (argc == 2) {
52132 int _v = 0;
52133 {
52134 void *vptr = 0;
52135 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52136 _v = SWIG_CheckState(res);
52137 }
52138 if (!_v) goto check_2;
52139 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
52140 }
52141 check_2:
52142
52143 if (argc == 2) {
52144 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
52145 }
52146
52147 fail:
52148 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
52149 return NULL;
52150 }
52151
52152
52153 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52154 PyObject *resultobj = 0;
52155 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52156 wxWindow *arg2 = (wxWindow *) 0 ;
52157 wxGBPosition *arg3 = 0 ;
52158 bool result;
52159 void *argp1 = 0 ;
52160 int res1 = 0 ;
52161 void *argp2 = 0 ;
52162 int res2 = 0 ;
52163 wxGBPosition temp3 ;
52164
52165 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52167 if (!SWIG_IsOK(res1)) {
52168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52169 }
52170 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52171 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52172 if (!SWIG_IsOK(res2)) {
52173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
52174 }
52175 arg2 = reinterpret_cast< wxWindow * >(argp2);
52176 {
52177 arg3 = &temp3;
52178 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52179 }
52180 {
52181 PyThreadState* __tstate = wxPyBeginAllowThreads();
52182 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52183 wxPyEndAllowThreads(__tstate);
52184 if (PyErr_Occurred()) SWIG_fail;
52185 }
52186 {
52187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52188 }
52189 return resultobj;
52190 fail:
52191 return NULL;
52192 }
52193
52194
52195 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52196 PyObject *resultobj = 0;
52197 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52198 wxSizer *arg2 = (wxSizer *) 0 ;
52199 wxGBPosition *arg3 = 0 ;
52200 bool result;
52201 void *argp1 = 0 ;
52202 int res1 = 0 ;
52203 void *argp2 = 0 ;
52204 int res2 = 0 ;
52205 wxGBPosition temp3 ;
52206
52207 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52209 if (!SWIG_IsOK(res1)) {
52210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52211 }
52212 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52213 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52214 if (!SWIG_IsOK(res2)) {
52215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
52216 }
52217 arg2 = reinterpret_cast< wxSizer * >(argp2);
52218 {
52219 arg3 = &temp3;
52220 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52221 }
52222 {
52223 PyThreadState* __tstate = wxPyBeginAllowThreads();
52224 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52225 wxPyEndAllowThreads(__tstate);
52226 if (PyErr_Occurred()) SWIG_fail;
52227 }
52228 {
52229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52230 }
52231 return resultobj;
52232 fail:
52233 return NULL;
52234 }
52235
52236
52237 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52238 PyObject *resultobj = 0;
52239 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52240 size_t arg2 ;
52241 wxGBPosition *arg3 = 0 ;
52242 bool result;
52243 void *argp1 = 0 ;
52244 int res1 = 0 ;
52245 size_t val2 ;
52246 int ecode2 = 0 ;
52247 wxGBPosition temp3 ;
52248
52249 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52251 if (!SWIG_IsOK(res1)) {
52252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52253 }
52254 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52255 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52256 if (!SWIG_IsOK(ecode2)) {
52257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
52258 }
52259 arg2 = static_cast< size_t >(val2);
52260 {
52261 arg3 = &temp3;
52262 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52263 }
52264 {
52265 PyThreadState* __tstate = wxPyBeginAllowThreads();
52266 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52267 wxPyEndAllowThreads(__tstate);
52268 if (PyErr_Occurred()) SWIG_fail;
52269 }
52270 {
52271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52272 }
52273 return resultobj;
52274 fail:
52275 return NULL;
52276 }
52277
52278
52279 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
52280 int argc;
52281 PyObject *argv[4];
52282
52283 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
52284 --argc;
52285 if (argc == 3) {
52286 int _v = 0;
52287 {
52288 void *vptr = 0;
52289 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52290 _v = SWIG_CheckState(res);
52291 }
52292 if (!_v) goto check_1;
52293 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
52294 }
52295 check_1:
52296
52297 if (argc == 3) {
52298 int _v = 0;
52299 {
52300 void *vptr = 0;
52301 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52302 _v = SWIG_CheckState(res);
52303 }
52304 if (!_v) goto check_2;
52305 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
52306 }
52307 check_2:
52308
52309 if (argc == 3) {
52310 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
52311 }
52312
52313 fail:
52314 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
52315 return NULL;
52316 }
52317
52318
52319 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52320 PyObject *resultobj = 0;
52321 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52322 wxWindow *arg2 = (wxWindow *) 0 ;
52323 wxGBSpan result;
52324 void *argp1 = 0 ;
52325 int res1 = 0 ;
52326 void *argp2 = 0 ;
52327 int res2 = 0 ;
52328
52329 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52331 if (!SWIG_IsOK(res1)) {
52332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52333 }
52334 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52335 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52336 if (!SWIG_IsOK(res2)) {
52337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52338 }
52339 arg2 = reinterpret_cast< wxWindow * >(argp2);
52340 {
52341 PyThreadState* __tstate = wxPyBeginAllowThreads();
52342 result = (arg1)->GetItemSpan(arg2);
52343 wxPyEndAllowThreads(__tstate);
52344 if (PyErr_Occurred()) SWIG_fail;
52345 }
52346 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52347 return resultobj;
52348 fail:
52349 return NULL;
52350 }
52351
52352
52353 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52354 PyObject *resultobj = 0;
52355 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52356 wxSizer *arg2 = (wxSizer *) 0 ;
52357 wxGBSpan result;
52358 void *argp1 = 0 ;
52359 int res1 = 0 ;
52360 void *argp2 = 0 ;
52361 int res2 = 0 ;
52362
52363 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52365 if (!SWIG_IsOK(res1)) {
52366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52367 }
52368 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52369 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52370 if (!SWIG_IsOK(res2)) {
52371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52372 }
52373 arg2 = reinterpret_cast< wxSizer * >(argp2);
52374 {
52375 PyThreadState* __tstate = wxPyBeginAllowThreads();
52376 result = (arg1)->GetItemSpan(arg2);
52377 wxPyEndAllowThreads(__tstate);
52378 if (PyErr_Occurred()) SWIG_fail;
52379 }
52380 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52381 return resultobj;
52382 fail:
52383 return NULL;
52384 }
52385
52386
52387 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52388 PyObject *resultobj = 0;
52389 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52390 size_t arg2 ;
52391 wxGBSpan result;
52392 void *argp1 = 0 ;
52393 int res1 = 0 ;
52394 size_t val2 ;
52395 int ecode2 = 0 ;
52396
52397 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52399 if (!SWIG_IsOK(res1)) {
52400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52401 }
52402 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52403 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52404 if (!SWIG_IsOK(ecode2)) {
52405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52406 }
52407 arg2 = static_cast< size_t >(val2);
52408 {
52409 PyThreadState* __tstate = wxPyBeginAllowThreads();
52410 result = (arg1)->GetItemSpan(arg2);
52411 wxPyEndAllowThreads(__tstate);
52412 if (PyErr_Occurred()) SWIG_fail;
52413 }
52414 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52415 return resultobj;
52416 fail:
52417 return NULL;
52418 }
52419
52420
52421 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
52422 int argc;
52423 PyObject *argv[3];
52424
52425 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
52426 --argc;
52427 if (argc == 2) {
52428 int _v = 0;
52429 {
52430 void *vptr = 0;
52431 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52432 _v = SWIG_CheckState(res);
52433 }
52434 if (!_v) goto check_1;
52435 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
52436 }
52437 check_1:
52438
52439 if (argc == 2) {
52440 int _v = 0;
52441 {
52442 void *vptr = 0;
52443 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52444 _v = SWIG_CheckState(res);
52445 }
52446 if (!_v) goto check_2;
52447 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
52448 }
52449 check_2:
52450
52451 if (argc == 2) {
52452 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
52453 }
52454
52455 fail:
52456 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
52457 return NULL;
52458 }
52459
52460
52461 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52462 PyObject *resultobj = 0;
52463 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52464 wxWindow *arg2 = (wxWindow *) 0 ;
52465 wxGBSpan *arg3 = 0 ;
52466 bool result;
52467 void *argp1 = 0 ;
52468 int res1 = 0 ;
52469 void *argp2 = 0 ;
52470 int res2 = 0 ;
52471 wxGBSpan temp3 ;
52472
52473 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52475 if (!SWIG_IsOK(res1)) {
52476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52477 }
52478 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52479 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52480 if (!SWIG_IsOK(res2)) {
52481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52482 }
52483 arg2 = reinterpret_cast< wxWindow * >(argp2);
52484 {
52485 arg3 = &temp3;
52486 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52487 }
52488 {
52489 PyThreadState* __tstate = wxPyBeginAllowThreads();
52490 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52491 wxPyEndAllowThreads(__tstate);
52492 if (PyErr_Occurred()) SWIG_fail;
52493 }
52494 {
52495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52496 }
52497 return resultobj;
52498 fail:
52499 return NULL;
52500 }
52501
52502
52503 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52504 PyObject *resultobj = 0;
52505 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52506 wxSizer *arg2 = (wxSizer *) 0 ;
52507 wxGBSpan *arg3 = 0 ;
52508 bool result;
52509 void *argp1 = 0 ;
52510 int res1 = 0 ;
52511 void *argp2 = 0 ;
52512 int res2 = 0 ;
52513 wxGBSpan temp3 ;
52514
52515 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52517 if (!SWIG_IsOK(res1)) {
52518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52519 }
52520 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52521 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52522 if (!SWIG_IsOK(res2)) {
52523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52524 }
52525 arg2 = reinterpret_cast< wxSizer * >(argp2);
52526 {
52527 arg3 = &temp3;
52528 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52529 }
52530 {
52531 PyThreadState* __tstate = wxPyBeginAllowThreads();
52532 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52533 wxPyEndAllowThreads(__tstate);
52534 if (PyErr_Occurred()) SWIG_fail;
52535 }
52536 {
52537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52538 }
52539 return resultobj;
52540 fail:
52541 return NULL;
52542 }
52543
52544
52545 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52546 PyObject *resultobj = 0;
52547 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52548 size_t arg2 ;
52549 wxGBSpan *arg3 = 0 ;
52550 bool result;
52551 void *argp1 = 0 ;
52552 int res1 = 0 ;
52553 size_t val2 ;
52554 int ecode2 = 0 ;
52555 wxGBSpan temp3 ;
52556
52557 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52559 if (!SWIG_IsOK(res1)) {
52560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52561 }
52562 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52563 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52564 if (!SWIG_IsOK(ecode2)) {
52565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52566 }
52567 arg2 = static_cast< size_t >(val2);
52568 {
52569 arg3 = &temp3;
52570 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52571 }
52572 {
52573 PyThreadState* __tstate = wxPyBeginAllowThreads();
52574 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52575 wxPyEndAllowThreads(__tstate);
52576 if (PyErr_Occurred()) SWIG_fail;
52577 }
52578 {
52579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52580 }
52581 return resultobj;
52582 fail:
52583 return NULL;
52584 }
52585
52586
52587 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
52588 int argc;
52589 PyObject *argv[4];
52590
52591 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
52592 --argc;
52593 if (argc == 3) {
52594 int _v = 0;
52595 {
52596 void *vptr = 0;
52597 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52598 _v = SWIG_CheckState(res);
52599 }
52600 if (!_v) goto check_1;
52601 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
52602 }
52603 check_1:
52604
52605 if (argc == 3) {
52606 int _v = 0;
52607 {
52608 void *vptr = 0;
52609 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52610 _v = SWIG_CheckState(res);
52611 }
52612 if (!_v) goto check_2;
52613 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
52614 }
52615 check_2:
52616
52617 if (argc == 3) {
52618 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
52619 }
52620
52621 fail:
52622 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52623 return NULL;
52624 }
52625
52626
52627 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52628 PyObject *resultobj = 0;
52629 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52630 wxWindow *arg2 = (wxWindow *) 0 ;
52631 wxGBSizerItem *result = 0 ;
52632 void *argp1 = 0 ;
52633 int res1 = 0 ;
52634 void *argp2 = 0 ;
52635 int res2 = 0 ;
52636
52637 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52639 if (!SWIG_IsOK(res1)) {
52640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52641 }
52642 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52643 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52644 if (!SWIG_IsOK(res2)) {
52645 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52646 }
52647 arg2 = reinterpret_cast< wxWindow * >(argp2);
52648 {
52649 PyThreadState* __tstate = wxPyBeginAllowThreads();
52650 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52651 wxPyEndAllowThreads(__tstate);
52652 if (PyErr_Occurred()) SWIG_fail;
52653 }
52654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52655 return resultobj;
52656 fail:
52657 return NULL;
52658 }
52659
52660
52661 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52662 PyObject *resultobj = 0;
52663 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52664 wxSizer *arg2 = (wxSizer *) 0 ;
52665 wxGBSizerItem *result = 0 ;
52666 void *argp1 = 0 ;
52667 int res1 = 0 ;
52668 void *argp2 = 0 ;
52669 int res2 = 0 ;
52670
52671 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52673 if (!SWIG_IsOK(res1)) {
52674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52675 }
52676 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52677 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52678 if (!SWIG_IsOK(res2)) {
52679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52680 }
52681 arg2 = reinterpret_cast< wxSizer * >(argp2);
52682 {
52683 PyThreadState* __tstate = wxPyBeginAllowThreads();
52684 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52685 wxPyEndAllowThreads(__tstate);
52686 if (PyErr_Occurred()) SWIG_fail;
52687 }
52688 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52689 return resultobj;
52690 fail:
52691 return NULL;
52692 }
52693
52694
52695 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52696 int argc;
52697 PyObject *argv[3];
52698
52699 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52700 --argc;
52701 if (argc == 2) {
52702 int _v = 0;
52703 {
52704 void *vptr = 0;
52705 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52706 _v = SWIG_CheckState(res);
52707 }
52708 if (!_v) goto check_1;
52709 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52710 }
52711 check_1:
52712
52713 if (argc == 2) {
52714 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52715 }
52716
52717 fail:
52718 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52719 return NULL;
52720 }
52721
52722
52723 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52724 PyObject *resultobj = 0;
52725 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52726 wxGBPosition *arg2 = 0 ;
52727 wxGBSizerItem *result = 0 ;
52728 void *argp1 = 0 ;
52729 int res1 = 0 ;
52730 wxGBPosition temp2 ;
52731 PyObject * obj0 = 0 ;
52732 PyObject * obj1 = 0 ;
52733 char * kwnames[] = {
52734 (char *) "self",(char *) "pos", NULL
52735 };
52736
52737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52739 if (!SWIG_IsOK(res1)) {
52740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52741 }
52742 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52743 {
52744 arg2 = &temp2;
52745 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52746 }
52747 {
52748 PyThreadState* __tstate = wxPyBeginAllowThreads();
52749 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52750 wxPyEndAllowThreads(__tstate);
52751 if (PyErr_Occurred()) SWIG_fail;
52752 }
52753 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52754 return resultobj;
52755 fail:
52756 return NULL;
52757 }
52758
52759
52760 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52761 PyObject *resultobj = 0;
52762 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52763 wxPoint *arg2 = 0 ;
52764 wxGBSizerItem *result = 0 ;
52765 void *argp1 = 0 ;
52766 int res1 = 0 ;
52767 wxPoint temp2 ;
52768 PyObject * obj0 = 0 ;
52769 PyObject * obj1 = 0 ;
52770 char * kwnames[] = {
52771 (char *) "self",(char *) "pt", NULL
52772 };
52773
52774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52776 if (!SWIG_IsOK(res1)) {
52777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52778 }
52779 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52780 {
52781 arg2 = &temp2;
52782 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52783 }
52784 {
52785 PyThreadState* __tstate = wxPyBeginAllowThreads();
52786 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52787 wxPyEndAllowThreads(__tstate);
52788 if (PyErr_Occurred()) SWIG_fail;
52789 }
52790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52791 return resultobj;
52792 fail:
52793 return NULL;
52794 }
52795
52796
52797 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52798 PyObject *resultobj = 0;
52799 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52800 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52801 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52802 bool result;
52803 void *argp1 = 0 ;
52804 int res1 = 0 ;
52805 void *argp2 = 0 ;
52806 int res2 = 0 ;
52807 void *argp3 = 0 ;
52808 int res3 = 0 ;
52809 PyObject * obj0 = 0 ;
52810 PyObject * obj1 = 0 ;
52811 PyObject * obj2 = 0 ;
52812 char * kwnames[] = {
52813 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52814 };
52815
52816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52818 if (!SWIG_IsOK(res1)) {
52819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52820 }
52821 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52822 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52823 if (!SWIG_IsOK(res2)) {
52824 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52825 }
52826 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52827 if (obj2) {
52828 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52829 if (!SWIG_IsOK(res3)) {
52830 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52831 }
52832 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52833 }
52834 {
52835 PyThreadState* __tstate = wxPyBeginAllowThreads();
52836 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52837 wxPyEndAllowThreads(__tstate);
52838 if (PyErr_Occurred()) SWIG_fail;
52839 }
52840 {
52841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52842 }
52843 return resultobj;
52844 fail:
52845 return NULL;
52846 }
52847
52848
52849 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52850 PyObject *resultobj = 0;
52851 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52852 wxGBPosition *arg2 = 0 ;
52853 wxGBSpan *arg3 = 0 ;
52854 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52855 bool result;
52856 void *argp1 = 0 ;
52857 int res1 = 0 ;
52858 wxGBPosition temp2 ;
52859 wxGBSpan temp3 ;
52860 void *argp4 = 0 ;
52861 int res4 = 0 ;
52862 PyObject * obj0 = 0 ;
52863 PyObject * obj1 = 0 ;
52864 PyObject * obj2 = 0 ;
52865 PyObject * obj3 = 0 ;
52866 char * kwnames[] = {
52867 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52868 };
52869
52870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52872 if (!SWIG_IsOK(res1)) {
52873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52874 }
52875 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52876 {
52877 arg2 = &temp2;
52878 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52879 }
52880 {
52881 arg3 = &temp3;
52882 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52883 }
52884 if (obj3) {
52885 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52886 if (!SWIG_IsOK(res4)) {
52887 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52888 }
52889 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52890 }
52891 {
52892 PyThreadState* __tstate = wxPyBeginAllowThreads();
52893 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52894 wxPyEndAllowThreads(__tstate);
52895 if (PyErr_Occurred()) SWIG_fail;
52896 }
52897 {
52898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52899 }
52900 return resultobj;
52901 fail:
52902 return NULL;
52903 }
52904
52905
52906 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52907 PyObject *obj;
52908 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52909 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52910 return SWIG_Py_Void();
52911 }
52912
52913 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52914 return SWIG_Python_InitShadowInstance(args);
52915 }
52916
52917 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52918 PyObject *resultobj = 0;
52919 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52920 wxRelationship arg2 ;
52921 wxWindow *arg3 = (wxWindow *) 0 ;
52922 wxEdge arg4 ;
52923 int arg5 = (int) 0 ;
52924 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52925 void *argp1 = 0 ;
52926 int res1 = 0 ;
52927 int val2 ;
52928 int ecode2 = 0 ;
52929 void *argp3 = 0 ;
52930 int res3 = 0 ;
52931 int val4 ;
52932 int ecode4 = 0 ;
52933 int val5 ;
52934 int ecode5 = 0 ;
52935 int val6 ;
52936 int ecode6 = 0 ;
52937 PyObject * obj0 = 0 ;
52938 PyObject * obj1 = 0 ;
52939 PyObject * obj2 = 0 ;
52940 PyObject * obj3 = 0 ;
52941 PyObject * obj4 = 0 ;
52942 PyObject * obj5 = 0 ;
52943 char * kwnames[] = {
52944 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52945 };
52946
52947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52949 if (!SWIG_IsOK(res1)) {
52950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52951 }
52952 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52953 ecode2 = SWIG_AsVal_int(obj1, &val2);
52954 if (!SWIG_IsOK(ecode2)) {
52955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52956 }
52957 arg2 = static_cast< wxRelationship >(val2);
52958 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52959 if (!SWIG_IsOK(res3)) {
52960 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52961 }
52962 arg3 = reinterpret_cast< wxWindow * >(argp3);
52963 ecode4 = SWIG_AsVal_int(obj3, &val4);
52964 if (!SWIG_IsOK(ecode4)) {
52965 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52966 }
52967 arg4 = static_cast< wxEdge >(val4);
52968 if (obj4) {
52969 ecode5 = SWIG_AsVal_int(obj4, &val5);
52970 if (!SWIG_IsOK(ecode5)) {
52971 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
52972 }
52973 arg5 = static_cast< int >(val5);
52974 }
52975 if (obj5) {
52976 ecode6 = SWIG_AsVal_int(obj5, &val6);
52977 if (!SWIG_IsOK(ecode6)) {
52978 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
52979 }
52980 arg6 = static_cast< int >(val6);
52981 }
52982 {
52983 PyThreadState* __tstate = wxPyBeginAllowThreads();
52984 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
52985 wxPyEndAllowThreads(__tstate);
52986 if (PyErr_Occurred()) SWIG_fail;
52987 }
52988 resultobj = SWIG_Py_Void();
52989 return resultobj;
52990 fail:
52991 return NULL;
52992 }
52993
52994
52995 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52996 PyObject *resultobj = 0;
52997 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52998 wxWindow *arg2 = (wxWindow *) 0 ;
52999 int arg3 = (int) 0 ;
53000 void *argp1 = 0 ;
53001 int res1 = 0 ;
53002 void *argp2 = 0 ;
53003 int res2 = 0 ;
53004 int val3 ;
53005 int ecode3 = 0 ;
53006 PyObject * obj0 = 0 ;
53007 PyObject * obj1 = 0 ;
53008 PyObject * obj2 = 0 ;
53009 char * kwnames[] = {
53010 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53011 };
53012
53013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53015 if (!SWIG_IsOK(res1)) {
53016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53017 }
53018 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53019 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53020 if (!SWIG_IsOK(res2)) {
53021 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53022 }
53023 arg2 = reinterpret_cast< wxWindow * >(argp2);
53024 if (obj2) {
53025 ecode3 = SWIG_AsVal_int(obj2, &val3);
53026 if (!SWIG_IsOK(ecode3)) {
53027 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
53028 }
53029 arg3 = static_cast< int >(val3);
53030 }
53031 {
53032 PyThreadState* __tstate = wxPyBeginAllowThreads();
53033 (arg1)->LeftOf(arg2,arg3);
53034 wxPyEndAllowThreads(__tstate);
53035 if (PyErr_Occurred()) SWIG_fail;
53036 }
53037 resultobj = SWIG_Py_Void();
53038 return resultobj;
53039 fail:
53040 return NULL;
53041 }
53042
53043
53044 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53045 PyObject *resultobj = 0;
53046 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53047 wxWindow *arg2 = (wxWindow *) 0 ;
53048 int arg3 = (int) 0 ;
53049 void *argp1 = 0 ;
53050 int res1 = 0 ;
53051 void *argp2 = 0 ;
53052 int res2 = 0 ;
53053 int val3 ;
53054 int ecode3 = 0 ;
53055 PyObject * obj0 = 0 ;
53056 PyObject * obj1 = 0 ;
53057 PyObject * obj2 = 0 ;
53058 char * kwnames[] = {
53059 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53060 };
53061
53062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53064 if (!SWIG_IsOK(res1)) {
53065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53066 }
53067 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53068 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53069 if (!SWIG_IsOK(res2)) {
53070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53071 }
53072 arg2 = reinterpret_cast< wxWindow * >(argp2);
53073 if (obj2) {
53074 ecode3 = SWIG_AsVal_int(obj2, &val3);
53075 if (!SWIG_IsOK(ecode3)) {
53076 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
53077 }
53078 arg3 = static_cast< int >(val3);
53079 }
53080 {
53081 PyThreadState* __tstate = wxPyBeginAllowThreads();
53082 (arg1)->RightOf(arg2,arg3);
53083 wxPyEndAllowThreads(__tstate);
53084 if (PyErr_Occurred()) SWIG_fail;
53085 }
53086 resultobj = SWIG_Py_Void();
53087 return resultobj;
53088 fail:
53089 return NULL;
53090 }
53091
53092
53093 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53094 PyObject *resultobj = 0;
53095 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53096 wxWindow *arg2 = (wxWindow *) 0 ;
53097 int arg3 = (int) 0 ;
53098 void *argp1 = 0 ;
53099 int res1 = 0 ;
53100 void *argp2 = 0 ;
53101 int res2 = 0 ;
53102 int val3 ;
53103 int ecode3 = 0 ;
53104 PyObject * obj0 = 0 ;
53105 PyObject * obj1 = 0 ;
53106 PyObject * obj2 = 0 ;
53107 char * kwnames[] = {
53108 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53109 };
53110
53111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53113 if (!SWIG_IsOK(res1)) {
53114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53115 }
53116 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53117 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53118 if (!SWIG_IsOK(res2)) {
53119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
53120 }
53121 arg2 = reinterpret_cast< wxWindow * >(argp2);
53122 if (obj2) {
53123 ecode3 = SWIG_AsVal_int(obj2, &val3);
53124 if (!SWIG_IsOK(ecode3)) {
53125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
53126 }
53127 arg3 = static_cast< int >(val3);
53128 }
53129 {
53130 PyThreadState* __tstate = wxPyBeginAllowThreads();
53131 (arg1)->Above(arg2,arg3);
53132 wxPyEndAllowThreads(__tstate);
53133 if (PyErr_Occurred()) SWIG_fail;
53134 }
53135 resultobj = SWIG_Py_Void();
53136 return resultobj;
53137 fail:
53138 return NULL;
53139 }
53140
53141
53142 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53143 PyObject *resultobj = 0;
53144 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53145 wxWindow *arg2 = (wxWindow *) 0 ;
53146 int arg3 = (int) 0 ;
53147 void *argp1 = 0 ;
53148 int res1 = 0 ;
53149 void *argp2 = 0 ;
53150 int res2 = 0 ;
53151 int val3 ;
53152 int ecode3 = 0 ;
53153 PyObject * obj0 = 0 ;
53154 PyObject * obj1 = 0 ;
53155 PyObject * obj2 = 0 ;
53156 char * kwnames[] = {
53157 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53158 };
53159
53160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53162 if (!SWIG_IsOK(res1)) {
53163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53164 }
53165 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53166 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53167 if (!SWIG_IsOK(res2)) {
53168 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
53169 }
53170 arg2 = reinterpret_cast< wxWindow * >(argp2);
53171 if (obj2) {
53172 ecode3 = SWIG_AsVal_int(obj2, &val3);
53173 if (!SWIG_IsOK(ecode3)) {
53174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
53175 }
53176 arg3 = static_cast< int >(val3);
53177 }
53178 {
53179 PyThreadState* __tstate = wxPyBeginAllowThreads();
53180 (arg1)->Below(arg2,arg3);
53181 wxPyEndAllowThreads(__tstate);
53182 if (PyErr_Occurred()) SWIG_fail;
53183 }
53184 resultobj = SWIG_Py_Void();
53185 return resultobj;
53186 fail:
53187 return NULL;
53188 }
53189
53190
53191 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53192 PyObject *resultobj = 0;
53193 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53194 wxWindow *arg2 = (wxWindow *) 0 ;
53195 wxEdge arg3 ;
53196 int arg4 = (int) 0 ;
53197 void *argp1 = 0 ;
53198 int res1 = 0 ;
53199 void *argp2 = 0 ;
53200 int res2 = 0 ;
53201 int val3 ;
53202 int ecode3 = 0 ;
53203 int val4 ;
53204 int ecode4 = 0 ;
53205 PyObject * obj0 = 0 ;
53206 PyObject * obj1 = 0 ;
53207 PyObject * obj2 = 0 ;
53208 PyObject * obj3 = 0 ;
53209 char * kwnames[] = {
53210 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
53211 };
53212
53213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53215 if (!SWIG_IsOK(res1)) {
53216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53217 }
53218 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53219 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53220 if (!SWIG_IsOK(res2)) {
53221 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
53222 }
53223 arg2 = reinterpret_cast< wxWindow * >(argp2);
53224 ecode3 = SWIG_AsVal_int(obj2, &val3);
53225 if (!SWIG_IsOK(ecode3)) {
53226 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
53227 }
53228 arg3 = static_cast< wxEdge >(val3);
53229 if (obj3) {
53230 ecode4 = SWIG_AsVal_int(obj3, &val4);
53231 if (!SWIG_IsOK(ecode4)) {
53232 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
53233 }
53234 arg4 = static_cast< int >(val4);
53235 }
53236 {
53237 PyThreadState* __tstate = wxPyBeginAllowThreads();
53238 (arg1)->SameAs(arg2,arg3,arg4);
53239 wxPyEndAllowThreads(__tstate);
53240 if (PyErr_Occurred()) SWIG_fail;
53241 }
53242 resultobj = SWIG_Py_Void();
53243 return resultobj;
53244 fail:
53245 return NULL;
53246 }
53247
53248
53249 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53250 PyObject *resultobj = 0;
53251 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53252 wxWindow *arg2 = (wxWindow *) 0 ;
53253 wxEdge arg3 ;
53254 int arg4 ;
53255 void *argp1 = 0 ;
53256 int res1 = 0 ;
53257 void *argp2 = 0 ;
53258 int res2 = 0 ;
53259 int val3 ;
53260 int ecode3 = 0 ;
53261 int val4 ;
53262 int ecode4 = 0 ;
53263 PyObject * obj0 = 0 ;
53264 PyObject * obj1 = 0 ;
53265 PyObject * obj2 = 0 ;
53266 PyObject * obj3 = 0 ;
53267 char * kwnames[] = {
53268 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
53269 };
53270
53271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53273 if (!SWIG_IsOK(res1)) {
53274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53275 }
53276 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53277 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53278 if (!SWIG_IsOK(res2)) {
53279 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53280 }
53281 arg2 = reinterpret_cast< wxWindow * >(argp2);
53282 ecode3 = SWIG_AsVal_int(obj2, &val3);
53283 if (!SWIG_IsOK(ecode3)) {
53284 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
53285 }
53286 arg3 = static_cast< wxEdge >(val3);
53287 ecode4 = SWIG_AsVal_int(obj3, &val4);
53288 if (!SWIG_IsOK(ecode4)) {
53289 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
53290 }
53291 arg4 = static_cast< int >(val4);
53292 {
53293 PyThreadState* __tstate = wxPyBeginAllowThreads();
53294 (arg1)->PercentOf(arg2,arg3,arg4);
53295 wxPyEndAllowThreads(__tstate);
53296 if (PyErr_Occurred()) SWIG_fail;
53297 }
53298 resultobj = SWIG_Py_Void();
53299 return resultobj;
53300 fail:
53301 return NULL;
53302 }
53303
53304
53305 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53306 PyObject *resultobj = 0;
53307 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53308 int arg2 ;
53309 void *argp1 = 0 ;
53310 int res1 = 0 ;
53311 int val2 ;
53312 int ecode2 = 0 ;
53313 PyObject * obj0 = 0 ;
53314 PyObject * obj1 = 0 ;
53315 char * kwnames[] = {
53316 (char *) "self",(char *) "val", NULL
53317 };
53318
53319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
53320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53321 if (!SWIG_IsOK(res1)) {
53322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53323 }
53324 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53325 ecode2 = SWIG_AsVal_int(obj1, &val2);
53326 if (!SWIG_IsOK(ecode2)) {
53327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
53328 }
53329 arg2 = static_cast< int >(val2);
53330 {
53331 PyThreadState* __tstate = wxPyBeginAllowThreads();
53332 (arg1)->Absolute(arg2);
53333 wxPyEndAllowThreads(__tstate);
53334 if (PyErr_Occurred()) SWIG_fail;
53335 }
53336 resultobj = SWIG_Py_Void();
53337 return resultobj;
53338 fail:
53339 return NULL;
53340 }
53341
53342
53343 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53344 PyObject *resultobj = 0;
53345 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53346 void *argp1 = 0 ;
53347 int res1 = 0 ;
53348 PyObject *swig_obj[1] ;
53349
53350 if (!args) SWIG_fail;
53351 swig_obj[0] = args;
53352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53353 if (!SWIG_IsOK(res1)) {
53354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53355 }
53356 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53357 {
53358 PyThreadState* __tstate = wxPyBeginAllowThreads();
53359 (arg1)->Unconstrained();
53360 wxPyEndAllowThreads(__tstate);
53361 if (PyErr_Occurred()) SWIG_fail;
53362 }
53363 resultobj = SWIG_Py_Void();
53364 return resultobj;
53365 fail:
53366 return NULL;
53367 }
53368
53369
53370 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53371 PyObject *resultobj = 0;
53372 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53373 void *argp1 = 0 ;
53374 int res1 = 0 ;
53375 PyObject *swig_obj[1] ;
53376
53377 if (!args) SWIG_fail;
53378 swig_obj[0] = args;
53379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53380 if (!SWIG_IsOK(res1)) {
53381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53382 }
53383 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53384 {
53385 PyThreadState* __tstate = wxPyBeginAllowThreads();
53386 (arg1)->AsIs();
53387 wxPyEndAllowThreads(__tstate);
53388 if (PyErr_Occurred()) SWIG_fail;
53389 }
53390 resultobj = SWIG_Py_Void();
53391 return resultobj;
53392 fail:
53393 return NULL;
53394 }
53395
53396
53397 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53398 PyObject *resultobj = 0;
53399 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53400 wxWindow *result = 0 ;
53401 void *argp1 = 0 ;
53402 int res1 = 0 ;
53403 PyObject *swig_obj[1] ;
53404
53405 if (!args) SWIG_fail;
53406 swig_obj[0] = args;
53407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53408 if (!SWIG_IsOK(res1)) {
53409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53410 }
53411 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53412 {
53413 PyThreadState* __tstate = wxPyBeginAllowThreads();
53414 result = (wxWindow *)(arg1)->GetOtherWindow();
53415 wxPyEndAllowThreads(__tstate);
53416 if (PyErr_Occurred()) SWIG_fail;
53417 }
53418 {
53419 resultobj = wxPyMake_wxObject(result, 0);
53420 }
53421 return resultobj;
53422 fail:
53423 return NULL;
53424 }
53425
53426
53427 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53428 PyObject *resultobj = 0;
53429 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53430 wxEdge result;
53431 void *argp1 = 0 ;
53432 int res1 = 0 ;
53433 PyObject *swig_obj[1] ;
53434
53435 if (!args) SWIG_fail;
53436 swig_obj[0] = args;
53437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53438 if (!SWIG_IsOK(res1)) {
53439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53440 }
53441 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53442 {
53443 PyThreadState* __tstate = wxPyBeginAllowThreads();
53444 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
53445 wxPyEndAllowThreads(__tstate);
53446 if (PyErr_Occurred()) SWIG_fail;
53447 }
53448 resultobj = SWIG_From_int(static_cast< int >(result));
53449 return resultobj;
53450 fail:
53451 return NULL;
53452 }
53453
53454
53455 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53456 PyObject *resultobj = 0;
53457 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53458 wxEdge arg2 ;
53459 void *argp1 = 0 ;
53460 int res1 = 0 ;
53461 int val2 ;
53462 int ecode2 = 0 ;
53463 PyObject * obj0 = 0 ;
53464 PyObject * obj1 = 0 ;
53465 char * kwnames[] = {
53466 (char *) "self",(char *) "which", NULL
53467 };
53468
53469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
53470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53471 if (!SWIG_IsOK(res1)) {
53472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53473 }
53474 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53475 ecode2 = SWIG_AsVal_int(obj1, &val2);
53476 if (!SWIG_IsOK(ecode2)) {
53477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53478 }
53479 arg2 = static_cast< wxEdge >(val2);
53480 {
53481 PyThreadState* __tstate = wxPyBeginAllowThreads();
53482 (arg1)->SetEdge(arg2);
53483 wxPyEndAllowThreads(__tstate);
53484 if (PyErr_Occurred()) SWIG_fail;
53485 }
53486 resultobj = SWIG_Py_Void();
53487 return resultobj;
53488 fail:
53489 return NULL;
53490 }
53491
53492
53493 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53494 PyObject *resultobj = 0;
53495 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53496 int arg2 ;
53497 void *argp1 = 0 ;
53498 int res1 = 0 ;
53499 int val2 ;
53500 int ecode2 = 0 ;
53501 PyObject * obj0 = 0 ;
53502 PyObject * obj1 = 0 ;
53503 char * kwnames[] = {
53504 (char *) "self",(char *) "v", NULL
53505 };
53506
53507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
53508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53509 if (!SWIG_IsOK(res1)) {
53510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53511 }
53512 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53513 ecode2 = SWIG_AsVal_int(obj1, &val2);
53514 if (!SWIG_IsOK(ecode2)) {
53515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
53516 }
53517 arg2 = static_cast< int >(val2);
53518 {
53519 PyThreadState* __tstate = wxPyBeginAllowThreads();
53520 (arg1)->SetValue(arg2);
53521 wxPyEndAllowThreads(__tstate);
53522 if (PyErr_Occurred()) SWIG_fail;
53523 }
53524 resultobj = SWIG_Py_Void();
53525 return resultobj;
53526 fail:
53527 return NULL;
53528 }
53529
53530
53531 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53532 PyObject *resultobj = 0;
53533 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53534 int result;
53535 void *argp1 = 0 ;
53536 int res1 = 0 ;
53537 PyObject *swig_obj[1] ;
53538
53539 if (!args) SWIG_fail;
53540 swig_obj[0] = args;
53541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53542 if (!SWIG_IsOK(res1)) {
53543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53544 }
53545 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53546 {
53547 PyThreadState* __tstate = wxPyBeginAllowThreads();
53548 result = (int)(arg1)->GetMargin();
53549 wxPyEndAllowThreads(__tstate);
53550 if (PyErr_Occurred()) SWIG_fail;
53551 }
53552 resultobj = SWIG_From_int(static_cast< int >(result));
53553 return resultobj;
53554 fail:
53555 return NULL;
53556 }
53557
53558
53559 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53560 PyObject *resultobj = 0;
53561 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53562 int arg2 ;
53563 void *argp1 = 0 ;
53564 int res1 = 0 ;
53565 int val2 ;
53566 int ecode2 = 0 ;
53567 PyObject * obj0 = 0 ;
53568 PyObject * obj1 = 0 ;
53569 char * kwnames[] = {
53570 (char *) "self",(char *) "m", NULL
53571 };
53572
53573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
53574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53575 if (!SWIG_IsOK(res1)) {
53576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53577 }
53578 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53579 ecode2 = SWIG_AsVal_int(obj1, &val2);
53580 if (!SWIG_IsOK(ecode2)) {
53581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
53582 }
53583 arg2 = static_cast< int >(val2);
53584 {
53585 PyThreadState* __tstate = wxPyBeginAllowThreads();
53586 (arg1)->SetMargin(arg2);
53587 wxPyEndAllowThreads(__tstate);
53588 if (PyErr_Occurred()) SWIG_fail;
53589 }
53590 resultobj = SWIG_Py_Void();
53591 return resultobj;
53592 fail:
53593 return NULL;
53594 }
53595
53596
53597 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53598 PyObject *resultobj = 0;
53599 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53600 int result;
53601 void *argp1 = 0 ;
53602 int res1 = 0 ;
53603 PyObject *swig_obj[1] ;
53604
53605 if (!args) SWIG_fail;
53606 swig_obj[0] = args;
53607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53608 if (!SWIG_IsOK(res1)) {
53609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53610 }
53611 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53612 {
53613 PyThreadState* __tstate = wxPyBeginAllowThreads();
53614 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
53615 wxPyEndAllowThreads(__tstate);
53616 if (PyErr_Occurred()) SWIG_fail;
53617 }
53618 resultobj = SWIG_From_int(static_cast< int >(result));
53619 return resultobj;
53620 fail:
53621 return NULL;
53622 }
53623
53624
53625 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53626 PyObject *resultobj = 0;
53627 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53628 int result;
53629 void *argp1 = 0 ;
53630 int res1 = 0 ;
53631 PyObject *swig_obj[1] ;
53632
53633 if (!args) SWIG_fail;
53634 swig_obj[0] = args;
53635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53636 if (!SWIG_IsOK(res1)) {
53637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53638 }
53639 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53640 {
53641 PyThreadState* __tstate = wxPyBeginAllowThreads();
53642 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53643 wxPyEndAllowThreads(__tstate);
53644 if (PyErr_Occurred()) SWIG_fail;
53645 }
53646 resultobj = SWIG_From_int(static_cast< int >(result));
53647 return resultobj;
53648 fail:
53649 return NULL;
53650 }
53651
53652
53653 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53654 PyObject *resultobj = 0;
53655 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53656 int result;
53657 void *argp1 = 0 ;
53658 int res1 = 0 ;
53659 PyObject *swig_obj[1] ;
53660
53661 if (!args) SWIG_fail;
53662 swig_obj[0] = args;
53663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53664 if (!SWIG_IsOK(res1)) {
53665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53666 }
53667 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53668 {
53669 PyThreadState* __tstate = wxPyBeginAllowThreads();
53670 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53671 wxPyEndAllowThreads(__tstate);
53672 if (PyErr_Occurred()) SWIG_fail;
53673 }
53674 resultobj = SWIG_From_int(static_cast< int >(result));
53675 return resultobj;
53676 fail:
53677 return NULL;
53678 }
53679
53680
53681 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53682 PyObject *resultobj = 0;
53683 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53684 bool result;
53685 void *argp1 = 0 ;
53686 int res1 = 0 ;
53687 PyObject *swig_obj[1] ;
53688
53689 if (!args) SWIG_fail;
53690 swig_obj[0] = args;
53691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53692 if (!SWIG_IsOK(res1)) {
53693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53694 }
53695 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53696 {
53697 PyThreadState* __tstate = wxPyBeginAllowThreads();
53698 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53699 wxPyEndAllowThreads(__tstate);
53700 if (PyErr_Occurred()) SWIG_fail;
53701 }
53702 {
53703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53704 }
53705 return resultobj;
53706 fail:
53707 return NULL;
53708 }
53709
53710
53711 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53712 PyObject *resultobj = 0;
53713 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53714 bool arg2 ;
53715 void *argp1 = 0 ;
53716 int res1 = 0 ;
53717 bool val2 ;
53718 int ecode2 = 0 ;
53719 PyObject * obj0 = 0 ;
53720 PyObject * obj1 = 0 ;
53721 char * kwnames[] = {
53722 (char *) "self",(char *) "d", NULL
53723 };
53724
53725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53727 if (!SWIG_IsOK(res1)) {
53728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53729 }
53730 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53731 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53732 if (!SWIG_IsOK(ecode2)) {
53733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53734 }
53735 arg2 = static_cast< bool >(val2);
53736 {
53737 PyThreadState* __tstate = wxPyBeginAllowThreads();
53738 (arg1)->SetDone(arg2);
53739 wxPyEndAllowThreads(__tstate);
53740 if (PyErr_Occurred()) SWIG_fail;
53741 }
53742 resultobj = SWIG_Py_Void();
53743 return resultobj;
53744 fail:
53745 return NULL;
53746 }
53747
53748
53749 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53750 PyObject *resultobj = 0;
53751 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53752 wxRelationship result;
53753 void *argp1 = 0 ;
53754 int res1 = 0 ;
53755 PyObject *swig_obj[1] ;
53756
53757 if (!args) SWIG_fail;
53758 swig_obj[0] = args;
53759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53760 if (!SWIG_IsOK(res1)) {
53761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53762 }
53763 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53764 {
53765 PyThreadState* __tstate = wxPyBeginAllowThreads();
53766 result = (wxRelationship)(arg1)->GetRelationship();
53767 wxPyEndAllowThreads(__tstate);
53768 if (PyErr_Occurred()) SWIG_fail;
53769 }
53770 resultobj = SWIG_From_int(static_cast< int >(result));
53771 return resultobj;
53772 fail:
53773 return NULL;
53774 }
53775
53776
53777 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53778 PyObject *resultobj = 0;
53779 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53780 wxRelationship arg2 ;
53781 void *argp1 = 0 ;
53782 int res1 = 0 ;
53783 int val2 ;
53784 int ecode2 = 0 ;
53785 PyObject * obj0 = 0 ;
53786 PyObject * obj1 = 0 ;
53787 char * kwnames[] = {
53788 (char *) "self",(char *) "r", NULL
53789 };
53790
53791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53793 if (!SWIG_IsOK(res1)) {
53794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53795 }
53796 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53797 ecode2 = SWIG_AsVal_int(obj1, &val2);
53798 if (!SWIG_IsOK(ecode2)) {
53799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53800 }
53801 arg2 = static_cast< wxRelationship >(val2);
53802 {
53803 PyThreadState* __tstate = wxPyBeginAllowThreads();
53804 (arg1)->SetRelationship(arg2);
53805 wxPyEndAllowThreads(__tstate);
53806 if (PyErr_Occurred()) SWIG_fail;
53807 }
53808 resultobj = SWIG_Py_Void();
53809 return resultobj;
53810 fail:
53811 return NULL;
53812 }
53813
53814
53815 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53816 PyObject *resultobj = 0;
53817 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53818 wxWindow *arg2 = (wxWindow *) 0 ;
53819 bool result;
53820 void *argp1 = 0 ;
53821 int res1 = 0 ;
53822 void *argp2 = 0 ;
53823 int res2 = 0 ;
53824 PyObject * obj0 = 0 ;
53825 PyObject * obj1 = 0 ;
53826 char * kwnames[] = {
53827 (char *) "self",(char *) "otherW", NULL
53828 };
53829
53830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53832 if (!SWIG_IsOK(res1)) {
53833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53834 }
53835 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53836 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53837 if (!SWIG_IsOK(res2)) {
53838 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53839 }
53840 arg2 = reinterpret_cast< wxWindow * >(argp2);
53841 {
53842 PyThreadState* __tstate = wxPyBeginAllowThreads();
53843 result = (bool)(arg1)->ResetIfWin(arg2);
53844 wxPyEndAllowThreads(__tstate);
53845 if (PyErr_Occurred()) SWIG_fail;
53846 }
53847 {
53848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53849 }
53850 return resultobj;
53851 fail:
53852 return NULL;
53853 }
53854
53855
53856 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53857 PyObject *resultobj = 0;
53858 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53859 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53860 wxWindow *arg3 = (wxWindow *) 0 ;
53861 bool result;
53862 void *argp1 = 0 ;
53863 int res1 = 0 ;
53864 void *argp2 = 0 ;
53865 int res2 = 0 ;
53866 void *argp3 = 0 ;
53867 int res3 = 0 ;
53868 PyObject * obj0 = 0 ;
53869 PyObject * obj1 = 0 ;
53870 PyObject * obj2 = 0 ;
53871 char * kwnames[] = {
53872 (char *) "self",(char *) "constraints",(char *) "win", NULL
53873 };
53874
53875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53877 if (!SWIG_IsOK(res1)) {
53878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53879 }
53880 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53881 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53882 if (!SWIG_IsOK(res2)) {
53883 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53884 }
53885 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53886 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53887 if (!SWIG_IsOK(res3)) {
53888 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53889 }
53890 arg3 = reinterpret_cast< wxWindow * >(argp3);
53891 {
53892 PyThreadState* __tstate = wxPyBeginAllowThreads();
53893 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53894 wxPyEndAllowThreads(__tstate);
53895 if (PyErr_Occurred()) SWIG_fail;
53896 }
53897 {
53898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53899 }
53900 return resultobj;
53901 fail:
53902 return NULL;
53903 }
53904
53905
53906 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53907 PyObject *resultobj = 0;
53908 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53909 wxEdge arg2 ;
53910 wxWindow *arg3 = (wxWindow *) 0 ;
53911 wxWindow *arg4 = (wxWindow *) 0 ;
53912 int result;
53913 void *argp1 = 0 ;
53914 int res1 = 0 ;
53915 int val2 ;
53916 int ecode2 = 0 ;
53917 void *argp3 = 0 ;
53918 int res3 = 0 ;
53919 void *argp4 = 0 ;
53920 int res4 = 0 ;
53921 PyObject * obj0 = 0 ;
53922 PyObject * obj1 = 0 ;
53923 PyObject * obj2 = 0 ;
53924 PyObject * obj3 = 0 ;
53925 char * kwnames[] = {
53926 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53927 };
53928
53929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53931 if (!SWIG_IsOK(res1)) {
53932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53933 }
53934 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53935 ecode2 = SWIG_AsVal_int(obj1, &val2);
53936 if (!SWIG_IsOK(ecode2)) {
53937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53938 }
53939 arg2 = static_cast< wxEdge >(val2);
53940 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53941 if (!SWIG_IsOK(res3)) {
53942 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53943 }
53944 arg3 = reinterpret_cast< wxWindow * >(argp3);
53945 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53946 if (!SWIG_IsOK(res4)) {
53947 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53948 }
53949 arg4 = reinterpret_cast< wxWindow * >(argp4);
53950 {
53951 PyThreadState* __tstate = wxPyBeginAllowThreads();
53952 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53953 wxPyEndAllowThreads(__tstate);
53954 if (PyErr_Occurred()) SWIG_fail;
53955 }
53956 resultobj = SWIG_From_int(static_cast< int >(result));
53957 return resultobj;
53958 fail:
53959 return NULL;
53960 }
53961
53962
53963 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53964 PyObject *obj;
53965 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53966 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53967 return SWIG_Py_Void();
53968 }
53969
53970 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53971 PyObject *resultobj = 0;
53972 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53973 wxIndividualLayoutConstraint *result = 0 ;
53974 void *argp1 = 0 ;
53975 int res1 = 0 ;
53976 PyObject *swig_obj[1] ;
53977
53978 if (!args) SWIG_fail;
53979 swig_obj[0] = args;
53980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53981 if (!SWIG_IsOK(res1)) {
53982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53983 }
53984 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53985 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
53986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53987 return resultobj;
53988 fail:
53989 return NULL;
53990 }
53991
53992
53993 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53994 PyObject *resultobj = 0;
53995 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53996 wxIndividualLayoutConstraint *result = 0 ;
53997 void *argp1 = 0 ;
53998 int res1 = 0 ;
53999 PyObject *swig_obj[1] ;
54000
54001 if (!args) SWIG_fail;
54002 swig_obj[0] = args;
54003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54004 if (!SWIG_IsOK(res1)) {
54005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54006 }
54007 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54008 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
54009 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54010 return resultobj;
54011 fail:
54012 return NULL;
54013 }
54014
54015
54016 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54017 PyObject *resultobj = 0;
54018 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54019 wxIndividualLayoutConstraint *result = 0 ;
54020 void *argp1 = 0 ;
54021 int res1 = 0 ;
54022 PyObject *swig_obj[1] ;
54023
54024 if (!args) SWIG_fail;
54025 swig_obj[0] = args;
54026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54027 if (!SWIG_IsOK(res1)) {
54028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54029 }
54030 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54031 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
54032 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54033 return resultobj;
54034 fail:
54035 return NULL;
54036 }
54037
54038
54039 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54040 PyObject *resultobj = 0;
54041 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54042 wxIndividualLayoutConstraint *result = 0 ;
54043 void *argp1 = 0 ;
54044 int res1 = 0 ;
54045 PyObject *swig_obj[1] ;
54046
54047 if (!args) SWIG_fail;
54048 swig_obj[0] = args;
54049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54050 if (!SWIG_IsOK(res1)) {
54051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54052 }
54053 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54054 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
54055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54056 return resultobj;
54057 fail:
54058 return NULL;
54059 }
54060
54061
54062 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54063 PyObject *resultobj = 0;
54064 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54065 wxIndividualLayoutConstraint *result = 0 ;
54066 void *argp1 = 0 ;
54067 int res1 = 0 ;
54068 PyObject *swig_obj[1] ;
54069
54070 if (!args) SWIG_fail;
54071 swig_obj[0] = args;
54072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54073 if (!SWIG_IsOK(res1)) {
54074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54075 }
54076 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54077 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
54078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54079 return resultobj;
54080 fail:
54081 return NULL;
54082 }
54083
54084
54085 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54086 PyObject *resultobj = 0;
54087 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54088 wxIndividualLayoutConstraint *result = 0 ;
54089 void *argp1 = 0 ;
54090 int res1 = 0 ;
54091 PyObject *swig_obj[1] ;
54092
54093 if (!args) SWIG_fail;
54094 swig_obj[0] = args;
54095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54096 if (!SWIG_IsOK(res1)) {
54097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54098 }
54099 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54100 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
54101 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54102 return resultobj;
54103 fail:
54104 return NULL;
54105 }
54106
54107
54108 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54109 PyObject *resultobj = 0;
54110 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54111 wxIndividualLayoutConstraint *result = 0 ;
54112 void *argp1 = 0 ;
54113 int res1 = 0 ;
54114 PyObject *swig_obj[1] ;
54115
54116 if (!args) SWIG_fail;
54117 swig_obj[0] = args;
54118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54119 if (!SWIG_IsOK(res1)) {
54120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54121 }
54122 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54123 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
54124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54125 return resultobj;
54126 fail:
54127 return NULL;
54128 }
54129
54130
54131 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54132 PyObject *resultobj = 0;
54133 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54134 wxIndividualLayoutConstraint *result = 0 ;
54135 void *argp1 = 0 ;
54136 int res1 = 0 ;
54137 PyObject *swig_obj[1] ;
54138
54139 if (!args) SWIG_fail;
54140 swig_obj[0] = args;
54141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54142 if (!SWIG_IsOK(res1)) {
54143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54144 }
54145 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54146 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
54147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54148 return resultobj;
54149 fail:
54150 return NULL;
54151 }
54152
54153
54154 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54155 PyObject *resultobj = 0;
54156 wxLayoutConstraints *result = 0 ;
54157
54158 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
54159 {
54160 PyThreadState* __tstate = wxPyBeginAllowThreads();
54161 result = (wxLayoutConstraints *)new wxLayoutConstraints();
54162 wxPyEndAllowThreads(__tstate);
54163 if (PyErr_Occurred()) SWIG_fail;
54164 }
54165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
54166 return resultobj;
54167 fail:
54168 return NULL;
54169 }
54170
54171
54172 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54173 PyObject *resultobj = 0;
54174 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54175 void *argp1 = 0 ;
54176 int res1 = 0 ;
54177 PyObject *swig_obj[1] ;
54178
54179 if (!args) SWIG_fail;
54180 swig_obj[0] = args;
54181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
54182 if (!SWIG_IsOK(res1)) {
54183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54184 }
54185 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54186 {
54187 PyThreadState* __tstate = wxPyBeginAllowThreads();
54188 delete arg1;
54189
54190 wxPyEndAllowThreads(__tstate);
54191 if (PyErr_Occurred()) SWIG_fail;
54192 }
54193 resultobj = SWIG_Py_Void();
54194 return resultobj;
54195 fail:
54196 return NULL;
54197 }
54198
54199
54200 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54201 PyObject *resultobj = 0;
54202 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54203 wxWindow *arg2 = (wxWindow *) 0 ;
54204 int *arg3 = (int *) 0 ;
54205 bool result;
54206 void *argp1 = 0 ;
54207 int res1 = 0 ;
54208 void *argp2 = 0 ;
54209 int res2 = 0 ;
54210 int temp3 ;
54211 int res3 = SWIG_TMPOBJ ;
54212 PyObject * obj0 = 0 ;
54213 PyObject * obj1 = 0 ;
54214 char * kwnames[] = {
54215 (char *) "self",(char *) "win", NULL
54216 };
54217
54218 arg3 = &temp3;
54219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
54220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54221 if (!SWIG_IsOK(res1)) {
54222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54223 }
54224 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54225 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54226 if (!SWIG_IsOK(res2)) {
54227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
54228 }
54229 arg2 = reinterpret_cast< wxWindow * >(argp2);
54230 {
54231 PyThreadState* __tstate = wxPyBeginAllowThreads();
54232 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
54233 wxPyEndAllowThreads(__tstate);
54234 if (PyErr_Occurred()) SWIG_fail;
54235 }
54236 {
54237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54238 }
54239 if (SWIG_IsTmpObj(res3)) {
54240 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
54241 } else {
54242 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
54243 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
54244 }
54245 return resultobj;
54246 fail:
54247 return NULL;
54248 }
54249
54250
54251 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54252 PyObject *resultobj = 0;
54253 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54254 bool result;
54255 void *argp1 = 0 ;
54256 int res1 = 0 ;
54257 PyObject *swig_obj[1] ;
54258
54259 if (!args) SWIG_fail;
54260 swig_obj[0] = args;
54261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54262 if (!SWIG_IsOK(res1)) {
54263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
54264 }
54265 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54266 {
54267 PyThreadState* __tstate = wxPyBeginAllowThreads();
54268 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
54269 wxPyEndAllowThreads(__tstate);
54270 if (PyErr_Occurred()) SWIG_fail;
54271 }
54272 {
54273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54274 }
54275 return resultobj;
54276 fail:
54277 return NULL;
54278 }
54279
54280
54281 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54282 PyObject *obj;
54283 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54284 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
54285 return SWIG_Py_Void();
54286 }
54287
54288 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54289 return SWIG_Python_InitShadowInstance(args);
54290 }
54291
54292 static PyMethodDef SwigMethods[] = {
54293 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
54294 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
54295 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
54296 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
54297 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
54298 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
54299 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
54300 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
54301 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54302 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
54303 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54304 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54305 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54306 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54307 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
54308 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
54309 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
54310 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
54311 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54312 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54313 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54314 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
54315 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
54316 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
54317 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
54318 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
54319 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
54320 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
54321 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
54322 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
54323 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
54324 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
54325 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
54326 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54327 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
54328 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54329 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54330 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54331 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54332 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54333 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
54334 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
54335 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
54336 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
54337 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
54338 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
54339 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
54340 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
54341 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
54342 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54343 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54344 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54345 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54346 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54347 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54348 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54349 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
54350 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
54351 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
54352 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
54353 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
54354 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
54355 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
54356 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
54357 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
54358 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
54359 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
54360 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
54361 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
54362 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54363 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
54364 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
54365 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
54366 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54367 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
54368 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54369 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
54370 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
54371 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54372 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
54373 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
54374 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
54375 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
54376 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
54377 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54378 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
54379 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
54380 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
54381 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
54382 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54383 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
54384 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
54385 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
54386 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
54387 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
54388 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
54389 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
54390 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
54391 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
54392 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54393 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54394 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54395 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54396 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
54397 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
54398 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
54399 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54400 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
54401 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
54402 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
54403 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
54404 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
54405 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
54406 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
54407 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
54408 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
54409 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54410 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
54411 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
54412 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
54413 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
54414 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
54415 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
54416 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54417 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
54418 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
54419 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
54420 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
54421 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
54422 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
54423 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
54424 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
54425 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
54426 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54427 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54428 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
54429 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54430 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54431 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
54432 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
54433 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54434 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54435 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
54436 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
54437 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
54438 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
54439 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54440 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
54441 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
54442 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
54443 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
54444 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
54445 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
54446 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
54447 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
54448 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
54449 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
54450 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
54451 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
54452 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
54453 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
54454 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
54455 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
54456 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
54457 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
54458 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
54459 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
54460 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
54461 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
54462 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
54463 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
54464 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
54465 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
54466 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
54467 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
54468 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
54469 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
54470 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
54471 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
54472 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
54473 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
54474 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
54475 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
54476 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
54477 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
54478 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
54479 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54480 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54481 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54482 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54483 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
54484 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
54485 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54486 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
54487 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54488 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
54489 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
54490 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
54491 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
54492 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
54493 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
54494 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
54495 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54496 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54497 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
54498 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54499 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54500 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
54501 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
54502 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
54503 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
54504 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
54505 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
54506 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54507 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54508 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
54509 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
54510 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
54511 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54512 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54513 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54514 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
54515 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
54516 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
54517 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
54518 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54519 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
54520 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
54521 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54522 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54523 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54524 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54525 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
54526 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
54527 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
54528 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
54529 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
54530 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
54531 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
54532 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54533 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54534 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54535 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
54536 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
54537 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
54538 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
54539 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
54540 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54541 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
54542 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
54543 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
54544 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54545 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54546 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
54547 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54548 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
54549 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
54550 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
54551 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
54552 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
54553 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
54554 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
54555 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
54556 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
54557 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
54558 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
54559 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
54560 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
54561 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
54562 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
54563 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
54564 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
54565 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
54566 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
54567 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
54568 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
54569 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
54570 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
54571 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
54572 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
54573 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
54574 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
54575 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54576 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
54577 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54578 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54579 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
54580 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54581 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
54582 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
54583 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
54584 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
54585 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
54586 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
54587 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
54588 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
54589 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54590 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
54591 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
54592 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
54593 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
54594 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54595 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54596 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
54597 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
54598 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54599 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54600 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
54601 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54602 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
54603 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54604 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
54605 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
54606 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54607 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54608 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54609 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54610 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54611 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
54612 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
54613 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
54614 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
54615 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
54616 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
54617 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54618 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
54619 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
54620 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
54621 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
54622 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
54623 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54624 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
54625 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
54626 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
54627 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54628 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
54629 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
54630 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
54631 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54632 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54633 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54634 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54635 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54636 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54637 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54638 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54639 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54640 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54641 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54642 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54643 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54644 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54645 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54646 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54647 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54648 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54649 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54650 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54651 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54652 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54653 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54654 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54655 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54656 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54657 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54658 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54659 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54660 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54661 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54662 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54663 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54664 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54665 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54666 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54667 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54668 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54669 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54670 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54671 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54672 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54673 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54674 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54675 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54676 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54677 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54678 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54679 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54680 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54681 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54682 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54683 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54684 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54685 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54686 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54687 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54688 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54689 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54690 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54691 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54692 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54693 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54694 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54695 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54696 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54697 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54698 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54699 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54700 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54701 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54702 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54703 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54704 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54705 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54706 { (char *)"EvtHandler_AllowReentrance", (PyCFunction) _wrap_EvtHandler_AllowReentrance, METH_VARARGS | METH_KEYWORDS, NULL},
54707 { (char *)"EvtHandler_IsReentranceAllowed", (PyCFunction)_wrap_EvtHandler_IsReentranceAllowed, METH_O, NULL},
54708 { (char *)"EvtHandler_IsEventHandlingInProgress", (PyCFunction)_wrap_EvtHandler_IsEventHandlingInProgress, METH_O, NULL},
54709 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54710 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54711 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54712 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54713 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54714 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54715 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54716 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54717 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54718 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54719 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54720 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54721 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54722 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54723 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54724 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54725 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54726 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54727 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54728 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54729 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54730 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54731 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54732 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54733 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54734 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54735 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54736 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54737 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54738 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54739 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54740 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54741 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54742 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54743 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54744 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54745 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54746 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54747 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54748 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54749 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54750 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54751 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54752 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54753 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54754 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54755 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54756 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54757 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54758 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54759 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54760 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54761 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54762 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54763 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54764 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54765 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54766 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54767 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54768 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54769 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54770 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54771 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54772 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54773 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54774 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54775 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54776 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54777 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54778 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54779 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54780 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54781 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54782 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54783 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54784 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54785 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54786 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54787 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54788 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54789 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54790 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54791 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54792 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54793 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54794 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54795 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54796 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54797 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54798 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54799 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54800 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54801 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54802 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54803 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54804 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54805 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54806 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54807 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54808 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54809 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54810 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54811 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54812 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54813 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54814 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54815 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54816 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54817 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54818 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54819 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54820 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54821 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54822 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54823 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54824 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54825 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54826 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54827 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54828 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54829 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54830 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54831 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54832 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54833 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54834 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54835 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54836 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54837 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54838 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54839 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54840 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54841 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54842 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54843 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54844 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54845 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54846 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54847 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54848 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54849 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54850 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54851 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54852 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54853 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54854 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54855 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54856 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54857 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54858 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54859 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54860 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54861 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54862 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54863 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54864 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54865 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54866 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54867 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54868 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54869 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54870 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54871 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54872 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54873 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54874 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54875 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54876 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54877 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54878 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54879 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54880 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54881 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54882 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54883 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54884 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54885 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54886 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54887 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54888 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54889 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54890 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54891 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54892 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54893 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54894 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54895 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54896 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54897 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54898 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54899 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54900 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54901 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54902 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54903 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54904 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54905 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54906 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54907 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54908 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54909 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54910 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54911 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54912 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54913 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54914 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54915 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54916 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54917 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54918 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54919 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54920 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54921 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54922 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54923 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54924 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54925 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54926 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54927 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54928 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54929 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54930 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54931 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54932 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54933 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54934 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54935 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54936 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54937 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54938 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54939 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54940 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54941 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54942 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54943 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54944 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54945 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54946 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54947 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54948 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54949 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54950 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54951 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54952 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54953 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54954 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54955 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54956 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54957 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54958 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54959 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54960 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54961 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54962 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54963 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54964 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54965 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54966 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54967 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54968 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54969 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54970 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54971 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54972 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54973 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54974 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
54975 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
54976 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
54977 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
54978 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54979 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
54980 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
54981 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
54982 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
54983 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
54984 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
54985 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54986 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
54987 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
54988 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
54989 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54990 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
54991 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
54992 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
54993 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
54994 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
54995 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54996 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54997 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
54998 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
54999 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
55000 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55001 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
55002 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
55003 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
55004 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
55005 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
55006 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
55007 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55008 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
55009 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
55010 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
55011 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
55012 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
55013 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
55014 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
55015 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
55016 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
55017 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55018 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
55019 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
55020 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
55021 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55022 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
55023 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
55024 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
55025 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55026 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
55027 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55028 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
55029 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
55030 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
55031 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
55032 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
55033 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
55034 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
55035 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
55036 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
55037 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
55038 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55039 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
55040 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
55041 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55042 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
55043 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
55044 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
55045 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
55046 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
55047 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55048 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
55049 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
55050 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
55051 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
55052 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
55053 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55054 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
55055 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
55056 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
55057 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
55058 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
55059 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
55060 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55061 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
55062 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
55063 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
55064 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
55065 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
55066 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
55067 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
55068 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
55069 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
55070 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
55071 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
55072 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
55073 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
55074 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
55075 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
55076 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
55077 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
55078 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
55079 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
55080 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
55081 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55082 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
55083 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
55084 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
55085 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
55086 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
55087 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
55088 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
55089 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
55090 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
55091 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
55092 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
55093 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
55094 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
55095 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
55096 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
55097 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55098 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55099 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55100 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
55101 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
55102 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
55103 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
55104 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
55105 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
55106 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
55107 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
55108 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
55109 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
55110 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
55111 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55112 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
55113 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
55114 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
55115 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
55116 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
55117 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
55118 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
55119 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
55120 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
55121 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
55122 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
55123 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
55124 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
55125 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
55126 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
55127 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
55128 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
55129 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
55130 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
55131 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
55132 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
55133 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55134 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55135 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
55136 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
55137 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
55138 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
55139 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
55140 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
55141 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
55142 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
55143 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
55144 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
55145 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
55146 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
55147 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
55148 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
55149 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
55150 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
55151 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
55152 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
55153 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
55154 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
55155 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
55156 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
55157 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
55158 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
55159 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
55160 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
55161 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55162 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
55163 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
55164 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
55165 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
55166 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55167 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
55168 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
55169 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
55170 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
55171 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
55172 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55173 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
55174 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
55175 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
55176 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
55177 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
55178 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55179 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55180 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
55181 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
55182 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
55183 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55184 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
55185 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
55186 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
55187 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
55188 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
55189 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
55190 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55191 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
55192 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
55193 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
55194 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
55195 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
55196 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
55197 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
55198 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
55199 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
55200 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
55201 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
55202 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
55203 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
55204 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
55205 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
55206 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
55207 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
55208 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
55209 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
55210 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
55211 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
55212 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
55213 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
55214 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55215 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
55216 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55217 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
55218 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
55219 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
55220 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55221 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
55222 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
55223 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
55224 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
55225 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
55226 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
55227 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55228 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
55229 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
55230 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
55231 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55232 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
55233 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55234 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
55235 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
55236 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
55237 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
55238 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55239 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
55240 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55241 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
55242 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
55243 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
55244 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
55245 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55246 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
55247 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
55248 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
55249 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
55250 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
55251 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
55252 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
55253 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
55254 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
55255 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
55256 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
55257 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
55258 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
55259 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
55260 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
55261 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
55262 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
55263 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
55264 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
55265 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
55266 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55267 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55268 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55269 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55270 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
55271 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
55272 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
55273 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
55274 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
55275 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
55276 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
55277 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
55278 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
55279 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
55280 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
55281 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
55282 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
55283 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
55284 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
55285 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
55286 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
55287 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
55288 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
55289 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
55290 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
55291 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
55292 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
55293 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
55294 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
55295 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
55296 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
55297 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
55298 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
55299 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
55300 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
55301 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
55302 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
55303 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55304 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
55305 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
55306 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55307 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55308 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55309 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55310 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55311 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
55312 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
55313 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
55314 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
55315 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
55316 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
55317 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
55318 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
55319 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
55320 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55321 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
55322 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
55323 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
55324 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
55325 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
55326 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
55327 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
55328 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
55329 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
55330 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
55331 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
55332 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
55333 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
55334 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
55335 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
55336 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
55337 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
55338 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55339 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
55340 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
55341 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
55342 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
55343 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
55344 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
55345 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
55346 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
55347 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
55348 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
55349 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55350 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
55351 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
55352 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
55353 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
55354 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
55355 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
55356 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
55357 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
55358 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55359 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
55360 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
55361 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
55362 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
55363 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
55364 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
55365 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
55366 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55367 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
55368 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
55369 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
55370 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
55371 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55372 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
55373 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
55374 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55375 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
55376 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
55377 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
55378 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
55379 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
55380 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
55381 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
55382 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
55383 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
55384 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55385 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
55386 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
55387 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
55388 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
55389 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
55390 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
55391 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
55392 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
55393 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55394 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
55395 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
55396 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
55397 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
55398 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
55399 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55400 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
55401 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
55402 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
55403 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55404 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
55405 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55406 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55407 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55408 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55409 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
55410 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55411 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55412 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
55413 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55414 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
55415 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55416 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55417 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55418 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55419 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
55420 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55421 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55422 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55423 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55424 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
55425 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55426 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
55427 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
55428 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
55429 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
55430 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
55431 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
55432 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
55433 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55434 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55435 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55436 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55437 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55438 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55439 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55440 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55441 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55442 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55443 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
55444 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
55445 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55446 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
55447 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55448 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
55449 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
55450 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
55451 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
55452 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55453 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
55454 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
55455 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
55456 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
55457 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
55458 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
55459 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
55460 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55461 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55462 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
55463 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55464 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
55465 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55466 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
55467 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
55468 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55469 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55470 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55471 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55472 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55473 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55474 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55475 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55476 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55477 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55478 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55479 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55480 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55481 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
55482 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
55483 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55484 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
55485 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
55486 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55487 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
55488 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
55489 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
55490 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55491 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
55492 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
55493 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55494 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55495 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
55496 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
55497 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
55498 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
55499 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
55500 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
55501 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
55502 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
55503 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
55504 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
55505 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
55506 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55507 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
55508 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55509 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
55510 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55511 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
55512 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
55513 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
55514 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
55515 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
55516 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
55517 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55518 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
55519 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55520 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
55521 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
55522 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
55523 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55524 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
55525 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
55526 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55527 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
55528 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
55529 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
55530 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
55531 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
55532 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
55533 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
55534 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
55535 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
55536 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
55537 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
55538 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55539 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
55540 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
55541 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
55542 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55543 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
55544 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
55545 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55546 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
55547 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55548 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
55549 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55550 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55551 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55552 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
55553 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
55554 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
55555 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
55556 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
55557 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
55558 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55559 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
55560 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55561 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
55562 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
55563 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
55564 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
55565 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
55566 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
55567 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55568 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55569 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55570 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
55571 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
55572 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
55573 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
55574 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55575 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
55576 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
55577 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
55578 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
55579 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
55580 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
55581 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
55582 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
55583 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
55584 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
55585 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
55586 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
55587 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
55588 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55589 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
55590 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
55591 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
55592 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
55593 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55594 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
55595 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55596 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
55597 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55598 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55599 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
55600 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
55601 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
55602 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
55603 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
55604 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
55605 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
55606 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55607 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55608 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55609 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55610 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55611 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
55612 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
55613 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55614 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
55615 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55616 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
55617 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55618 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
55619 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55620 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55621 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55622 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55623 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55624 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
55625 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
55626 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
55627 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
55628 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
55629 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
55630 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
55631 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
55632 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55633 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55634 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
55635 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
55636 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55637 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55638 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55639 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55640 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55641 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55642 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55643 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55644 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55645 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55646 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55647 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55648 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55649 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55650 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55651 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55652 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55653 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55654 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55655 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55656 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55657 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55658 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55659 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55660 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55661 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55662 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55663 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55664 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55665 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55666 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55667 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55668 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55669 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55670 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55671 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55672 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55673 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55674 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55675 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55676 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55677 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55678 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55679 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55680 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55681 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55682 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55683 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55684 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55685 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55686 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55687 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55688 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55689 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55690 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55691 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55692 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55693 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55694 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55695 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55696 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55697 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55698 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55699 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55700 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55701 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55702 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55703 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55704 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55705 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55706 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55707 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55708 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55709 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55710 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55711 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55712 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55713 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55714 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55715 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55716 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55717 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55718 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55719 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55720 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55721 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55722 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55723 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55724 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55725 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55726 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55727 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55728 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55729 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55730 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55731 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55732 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55733 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55734 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55735 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55736 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55737 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55738 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55739 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55740 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55741 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55742 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55743 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55744 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55745 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55746 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55747 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55748 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55749 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55750 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55751 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55752 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55753 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55754 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55755 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55756 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55757 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55758 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55759 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55760 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55761 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55762 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55763 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55764 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55765 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55766 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55767 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55768 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55769 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55770 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55771 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55772 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55773 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55774 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55775 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55776 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55777 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55778 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55779 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55780 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55781 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55782 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55783 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55784 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55785 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55786 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55787 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55788 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55789 { NULL, NULL, 0, NULL }
55790 };
55791
55792
55793 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55794
55795 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55796 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55797 }
55798 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55799 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55800 }
55801 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55802 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55803 }
55804 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55805 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55806 }
55807 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55808 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55809 }
55810 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55811 return (void *)((wxSizer *) ((wxGridSizer *) x));
55812 }
55813 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55814 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55815 }
55816 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55817 return (void *)((wxSizer *) ((wxPySizer *) x));
55818 }
55819 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55820 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55821 }
55822 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55823 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55824 }
55825 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55826 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55827 }
55828 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55829 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55830 }
55831 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55832 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55833 }
55834 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55835 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55836 }
55837 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55838 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55839 }
55840 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55841 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55842 }
55843 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55844 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55845 }
55846 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55847 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55848 }
55849 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55850 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55851 }
55852 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55853 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55854 }
55855 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55856 return (void *)((wxEvent *) ((wxPyEvent *) x));
55857 }
55858 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55859 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55860 }
55861 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55862 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55863 }
55864 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55865 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55866 }
55867 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55868 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55869 }
55870 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55871 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55872 }
55873 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55874 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55875 }
55876 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55877 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55878 }
55879 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55880 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55881 }
55882 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55883 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55884 }
55885 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55886 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55887 }
55888 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55889 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55890 }
55891 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55892 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55893 }
55894 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55895 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55896 }
55897 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55898 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55899 }
55900 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55901 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55902 }
55903 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55904 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55905 }
55906 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55907 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55908 }
55909 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55910 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55911 }
55912 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55913 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55914 }
55915 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55916 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55917 }
55918 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55919 return (void *)((wxEvent *) ((wxShowEvent *) x));
55920 }
55921 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55922 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55923 }
55924 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55925 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55926 }
55927 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55928 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55929 }
55930 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55931 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55932 }
55933 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55934 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55935 }
55936 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55937 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55938 }
55939 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55940 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55941 }
55942 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55943 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55944 }
55945 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55946 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55947 }
55948 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55949 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55950 }
55951 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55952 return (void *)((wxControl *) ((wxControlWithItems *) x));
55953 }
55954 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55955 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55956 }
55957 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55958 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55959 }
55960 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55961 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55962 }
55963 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55964 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55965 }
55966 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55967 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55968 }
55969 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55970 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
55971 }
55972 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
55973 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
55974 }
55975 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
55976 return (void *)((wxEvtHandler *) ((wxMenu *) x));
55977 }
55978 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
55979 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
55980 }
55981 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
55982 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
55983 }
55984 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
55985 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
55986 }
55987 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
55988 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
55989 }
55990 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
55991 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
55992 }
55993 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
55994 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55995 }
55996 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
55997 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
55998 }
55999 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
56000 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
56001 }
56002 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
56003 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
56004 }
56005 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
56006 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
56007 }
56008 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
56009 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
56010 }
56011 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
56012 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
56013 }
56014 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
56015 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
56016 }
56017 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
56018 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
56019 }
56020 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
56021 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
56022 }
56023 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
56024 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
56025 }
56026 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
56027 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
56028 }
56029 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
56030 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
56031 }
56032 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
56033 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
56034 }
56035 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
56036 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
56037 }
56038 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
56039 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
56040 }
56041 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
56042 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
56043 }
56044 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
56045 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
56046 }
56047 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
56048 return (void *)((wxObject *) ((wxSizerItem *) x));
56049 }
56050 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
56051 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
56052 }
56053 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
56054 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
56055 }
56056 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
56057 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
56058 }
56059 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
56060 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
56061 }
56062 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
56063 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
56064 }
56065 static void *_p_wxSizerTo_p_wxObject(void *x) {
56066 return (void *)((wxObject *) ((wxSizer *) x));
56067 }
56068 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
56069 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
56070 }
56071 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
56072 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
56073 }
56074 static void *_p_wxEventTo_p_wxObject(void *x) {
56075 return (void *)((wxObject *) ((wxEvent *) x));
56076 }
56077 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
56078 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
56079 }
56080 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
56081 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
56082 }
56083 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
56084 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
56085 }
56086 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
56087 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
56088 }
56089 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
56090 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
56091 }
56092 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
56093 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
56094 }
56095 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
56096 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
56097 }
56098 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
56099 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
56100 }
56101 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
56102 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
56103 }
56104 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
56105 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
56106 }
56107 static void *_p_wxControlTo_p_wxObject(void *x) {
56108 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
56109 }
56110 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
56111 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
56112 }
56113 static void *_p_wxFSFileTo_p_wxObject(void *x) {
56114 return (void *)((wxObject *) ((wxFSFile *) x));
56115 }
56116 static void *_p_wxPySizerTo_p_wxObject(void *x) {
56117 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
56118 }
56119 static void *_p_wxPyEventTo_p_wxObject(void *x) {
56120 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
56121 }
56122 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
56123 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
56124 }
56125 static void *_p_wxShowEventTo_p_wxObject(void *x) {
56126 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
56127 }
56128 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
56129 return (void *)((wxObject *) ((wxMenuItem *) x));
56130 }
56131 static void *_p_wxDateEventTo_p_wxObject(void *x) {
56132 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
56133 }
56134 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
56135 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
56136 }
56137 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
56138 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
56139 }
56140 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
56141 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
56142 }
56143 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
56144 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
56145 }
56146 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
56147 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
56148 }
56149 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
56150 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
56151 }
56152 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
56153 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
56154 }
56155 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
56156 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
56157 }
56158 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
56159 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
56160 }
56161 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
56162 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
56163 }
56164 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
56165 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
56166 }
56167 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
56168 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
56169 }
56170 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
56171 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
56172 }
56173 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
56174 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
56175 }
56176 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
56177 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
56178 }
56179 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
56180 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
56181 }
56182 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
56183 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
56184 }
56185 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
56186 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
56187 }
56188 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
56189 return (void *)((wxObject *) ((wxImageHandler *) x));
56190 }
56191 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
56192 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
56193 }
56194 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
56195 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
56196 }
56197 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
56198 return (void *)((wxObject *) ((wxEvtHandler *) x));
56199 }
56200 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
56201 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
56202 }
56203 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
56204 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
56205 }
56206 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
56207 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
56208 }
56209 static void *_p_wxImageTo_p_wxObject(void *x) {
56210 return (void *)((wxObject *) ((wxImage *) x));
56211 }
56212 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
56213 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
56214 }
56215 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
56216 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
56217 }
56218 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
56219 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
56220 }
56221 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
56222 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
56223 }
56224 static void *_p_wxWindowTo_p_wxObject(void *x) {
56225 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
56226 }
56227 static void *_p_wxMenuTo_p_wxObject(void *x) {
56228 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
56229 }
56230 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
56231 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
56232 }
56233 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
56234 return (void *)((wxObject *) ((wxFileSystem *) x));
56235 }
56236 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
56237 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
56238 }
56239 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
56240 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
56241 }
56242 static void *_p_wxPyAppTo_p_wxObject(void *x) {
56243 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
56244 }
56245 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
56246 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
56247 }
56248 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
56249 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
56250 }
56251 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
56252 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
56253 }
56254 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
56255 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
56256 }
56257 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
56258 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
56259 }
56260 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
56261 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
56262 }
56263 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
56264 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
56265 }
56266 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
56267 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
56268 }
56269 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
56270 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
56271 }
56272 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
56273 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
56274 }
56275 static void *_p_wxValidatorTo_p_wxObject(void *x) {
56276 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
56277 }
56278 static void *_p_wxControlTo_p_wxWindow(void *x) {
56279 return (void *)((wxWindow *) ((wxControl *) x));
56280 }
56281 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
56282 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
56283 }
56284 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
56285 return (void *)((wxWindow *) ((wxMenuBar *) x));
56286 }
56287 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
56288 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
56289 }
56290 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
56291 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
56292 }
56293 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
56294 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
56295 }
56296 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
56297 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
56298 }
56299 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
56300 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
56301 }
56302 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
56303 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
56304 }
56305 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
56306 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
56307 }
56308 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
56309 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
56310 }
56311 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
56312 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
56313 }
56314 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
56315 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
56316 }
56317 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
56318 return (void *)((wxValidator *) ((wxPyValidator *) x));
56319 }
56320 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
56321 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
56322 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};
56323 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
56324 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
56325 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
56326 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
56327 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
56328 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
56329 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
56330 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
56331 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
56332 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
56333 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
56334 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
56335 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
56336 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
56337 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
56338 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
56339 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
56340 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
56341 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
56342 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
56343 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
56344 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
56345 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
56346 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
56347 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
56348 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
56349 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
56350 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
56351 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
56352 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
56353 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
56354 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
56355 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
56356 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
56357 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
56358 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
56359 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
56360 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
56361 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
56362 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
56363 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
56364 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
56365 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
56366 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
56367 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
56368 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
56369 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
56370 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
56371 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
56372 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
56373 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
56374 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
56375 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
56376 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
56377 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
56378 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
56379 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
56380 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
56381 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
56382 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
56383 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
56384 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
56385 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
56386 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
56387 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
56388 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
56389 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
56390 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
56391 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
56392 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
56393 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
56394 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
56395 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
56396 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
56397 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
56398 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
56399 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
56400 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
56401 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
56402 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
56403 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
56404 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
56405 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
56406 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
56407 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
56408 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
56409 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
56410 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
56411 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
56412 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
56413 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
56414 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
56415 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
56416 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
56417 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
56418 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
56419 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
56420 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
56421 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
56422 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
56423 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
56424 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
56425 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
56426 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
56427 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
56428 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
56429 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
56430 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
56431 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
56432 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
56433 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
56434 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
56435 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
56436 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
56437 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
56438 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
56439 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
56440 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
56441 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
56442 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
56443 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
56444 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
56445 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
56446 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
56447 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
56448 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
56449 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
56450 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
56451 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
56452
56453 static swig_type_info *swig_type_initial[] = {
56454 &_swigt__p_buffer,
56455 &_swigt__p_char,
56456 &_swigt__p_form_ops_t,
56457 &_swigt__p_int,
56458 &_swigt__p_long,
56459 &_swigt__p_unsigned_char,
56460 &_swigt__p_unsigned_int,
56461 &_swigt__p_unsigned_long,
56462 &_swigt__p_wxANIHandler,
56463 &_swigt__p_wxAcceleratorEntry,
56464 &_swigt__p_wxAcceleratorTable,
56465 &_swigt__p_wxActivateEvent,
56466 &_swigt__p_wxAppTraits,
56467 &_swigt__p_wxArrayString,
56468 &_swigt__p_wxBMPHandler,
56469 &_swigt__p_wxBitmap,
56470 &_swigt__p_wxBoxSizer,
56471 &_swigt__p_wxButton,
56472 &_swigt__p_wxCURHandler,
56473 &_swigt__p_wxCaret,
56474 &_swigt__p_wxChildFocusEvent,
56475 &_swigt__p_wxClipboardTextEvent,
56476 &_swigt__p_wxCloseEvent,
56477 &_swigt__p_wxColour,
56478 &_swigt__p_wxCommandEvent,
56479 &_swigt__p_wxContextMenuEvent,
56480 &_swigt__p_wxControl,
56481 &_swigt__p_wxControlWithItems,
56482 &_swigt__p_wxCursor,
56483 &_swigt__p_wxDC,
56484 &_swigt__p_wxDateEvent,
56485 &_swigt__p_wxDateTime,
56486 &_swigt__p_wxDisplayChangedEvent,
56487 &_swigt__p_wxDropFilesEvent,
56488 &_swigt__p_wxDuplexMode,
56489 &_swigt__p_wxEraseEvent,
56490 &_swigt__p_wxEvent,
56491 &_swigt__p_wxEventLoop,
56492 &_swigt__p_wxEventLoopActivator,
56493 &_swigt__p_wxEvtHandler,
56494 &_swigt__p_wxFSFile,
56495 &_swigt__p_wxFileSystem,
56496 &_swigt__p_wxFileSystemHandler,
56497 &_swigt__p_wxFlexGridSizer,
56498 &_swigt__p_wxFocusEvent,
56499 &_swigt__p_wxFont,
56500 &_swigt__p_wxFrame,
56501 &_swigt__p_wxGBPosition,
56502 &_swigt__p_wxGBSizerItem,
56503 &_swigt__p_wxGBSpan,
56504 &_swigt__p_wxGIFHandler,
56505 &_swigt__p_wxGridBagSizer,
56506 &_swigt__p_wxGridSizer,
56507 &_swigt__p_wxHelpEvent__Origin,
56508 &_swigt__p_wxICOHandler,
56509 &_swigt__p_wxIconizeEvent,
56510 &_swigt__p_wxIdleEvent,
56511 &_swigt__p_wxImage,
56512 &_swigt__p_wxImageHandler,
56513 &_swigt__p_wxImageHistogram,
56514 &_swigt__p_wxImage_HSVValue,
56515 &_swigt__p_wxImage_RGBValue,
56516 &_swigt__p_wxIndividualLayoutConstraint,
56517 &_swigt__p_wxInitDialogEvent,
56518 &_swigt__p_wxInputStream,
56519 &_swigt__p_wxInternetFSHandler,
56520 &_swigt__p_wxItemContainer,
56521 &_swigt__p_wxJPEGHandler,
56522 &_swigt__p_wxKeyEvent,
56523 &_swigt__p_wxLayoutConstraints,
56524 &_swigt__p_wxMaximizeEvent,
56525 &_swigt__p_wxMemoryFSHandler,
56526 &_swigt__p_wxMenu,
56527 &_swigt__p_wxMenuBar,
56528 &_swigt__p_wxMenuBarBase,
56529 &_swigt__p_wxMenuEvent,
56530 &_swigt__p_wxMenuItem,
56531 &_swigt__p_wxMouseCaptureChangedEvent,
56532 &_swigt__p_wxMouseCaptureLostEvent,
56533 &_swigt__p_wxMouseEvent,
56534 &_swigt__p_wxMoveEvent,
56535 &_swigt__p_wxNavigationKeyEvent,
56536 &_swigt__p_wxNcPaintEvent,
56537 &_swigt__p_wxNotifyEvent,
56538 &_swigt__p_wxObject,
56539 &_swigt__p_wxOutputStream,
56540 &_swigt__p_wxPCXHandler,
56541 &_swigt__p_wxPNGHandler,
56542 &_swigt__p_wxPNMHandler,
56543 &_swigt__p_wxPaintEvent,
56544 &_swigt__p_wxPaletteChangedEvent,
56545 &_swigt__p_wxPaperSize,
56546 &_swigt__p_wxPoint,
56547 &_swigt__p_wxPoint2D,
56548 &_swigt__p_wxPropagateOnce,
56549 &_swigt__p_wxPropagationDisabler,
56550 &_swigt__p_wxPyApp,
56551 &_swigt__p_wxPyCommandEvent,
56552 &_swigt__p_wxPyDropTarget,
56553 &_swigt__p_wxPyEvent,
56554 &_swigt__p_wxPyFileSystemHandler,
56555 &_swigt__p_wxPyImageHandler,
56556 &_swigt__p_wxPyInputStream,
56557 &_swigt__p_wxPySizer,
56558 &_swigt__p_wxPyValidator,
56559 &_swigt__p_wxQuantize,
56560 &_swigt__p_wxQueryNewPaletteEvent,
56561 &_swigt__p_wxRealPoint,
56562 &_swigt__p_wxRect,
56563 &_swigt__p_wxRegion,
56564 &_swigt__p_wxScrollEvent,
56565 &_swigt__p_wxScrollWinEvent,
56566 &_swigt__p_wxSetCursorEvent,
56567 &_swigt__p_wxShowEvent,
56568 &_swigt__p_wxSize,
56569 &_swigt__p_wxSizeEvent,
56570 &_swigt__p_wxSizer,
56571 &_swigt__p_wxSizerItem,
56572 &_swigt__p_wxStaticBox,
56573 &_swigt__p_wxStaticBoxSizer,
56574 &_swigt__p_wxStdDialogButtonSizer,
56575 &_swigt__p_wxSysColourChangedEvent,
56576 &_swigt__p_wxTIFFHandler,
56577 &_swigt__p_wxToolTip,
56578 &_swigt__p_wxUpdateUIEvent,
56579 &_swigt__p_wxValidator,
56580 &_swigt__p_wxVisualAttributes,
56581 &_swigt__p_wxWindow,
56582 &_swigt__p_wxWindowCreateEvent,
56583 &_swigt__p_wxWindowDestroyEvent,
56584 &_swigt__p_wxXPMHandler,
56585 &_swigt__p_wxZipFSHandler,
56586 };
56587
56588 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
56589 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
56590 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
56591 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
56592 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
56593 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
56594 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
56595 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
56596 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
56597 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
56598 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
56599 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
56600 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
56601 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
56602 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}};
56603 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
56604 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}};
56605 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
56606 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}};
56607 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
56608 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56609 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
56610 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
56611 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
56612 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}};
56613 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56614 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}};
56615 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
56616 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
56617 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
56618 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
56619 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
56620 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56621 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
56622 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
56623 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
56624 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
56625 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
56626 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
56627 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}};
56628 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
56629 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
56630 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}};
56631 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}};
56632 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56633 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
56634 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56635 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56636 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56637 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56638 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56639 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56640 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}};
56641 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56642 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}};
56643 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56644 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56645 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56646 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}};
56647 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56648 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56649 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56650 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56651 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56652 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56653 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56654 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}};
56655 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56656 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56657 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56658 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56659 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56660 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56661 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56662 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56663 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56664 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56665 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56666 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56667 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56668 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56669 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56670 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56671 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56672 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
56673 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56674 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56675 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56676 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56677 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56678 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56679 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56680 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56681 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56682 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56683 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56684 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56685 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56686 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56687 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56688 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56689 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56690 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56691 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56692 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56693 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56694 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56695 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56696 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56697 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56698 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56699 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56700 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56701 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56702 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56703 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56704 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}};
56705 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}};
56706 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56707 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56708 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56709 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56710 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56711 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56712 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56713 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}};
56714 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56715 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}};
56716 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56717 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56718 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56719 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56720
56721 static swig_cast_info *swig_cast_initial[] = {
56722 _swigc__p_buffer,
56723 _swigc__p_char,
56724 _swigc__p_form_ops_t,
56725 _swigc__p_int,
56726 _swigc__p_long,
56727 _swigc__p_unsigned_char,
56728 _swigc__p_unsigned_int,
56729 _swigc__p_unsigned_long,
56730 _swigc__p_wxANIHandler,
56731 _swigc__p_wxAcceleratorEntry,
56732 _swigc__p_wxAcceleratorTable,
56733 _swigc__p_wxActivateEvent,
56734 _swigc__p_wxAppTraits,
56735 _swigc__p_wxArrayString,
56736 _swigc__p_wxBMPHandler,
56737 _swigc__p_wxBitmap,
56738 _swigc__p_wxBoxSizer,
56739 _swigc__p_wxButton,
56740 _swigc__p_wxCURHandler,
56741 _swigc__p_wxCaret,
56742 _swigc__p_wxChildFocusEvent,
56743 _swigc__p_wxClipboardTextEvent,
56744 _swigc__p_wxCloseEvent,
56745 _swigc__p_wxColour,
56746 _swigc__p_wxCommandEvent,
56747 _swigc__p_wxContextMenuEvent,
56748 _swigc__p_wxControl,
56749 _swigc__p_wxControlWithItems,
56750 _swigc__p_wxCursor,
56751 _swigc__p_wxDC,
56752 _swigc__p_wxDateEvent,
56753 _swigc__p_wxDateTime,
56754 _swigc__p_wxDisplayChangedEvent,
56755 _swigc__p_wxDropFilesEvent,
56756 _swigc__p_wxDuplexMode,
56757 _swigc__p_wxEraseEvent,
56758 _swigc__p_wxEvent,
56759 _swigc__p_wxEventLoop,
56760 _swigc__p_wxEventLoopActivator,
56761 _swigc__p_wxEvtHandler,
56762 _swigc__p_wxFSFile,
56763 _swigc__p_wxFileSystem,
56764 _swigc__p_wxFileSystemHandler,
56765 _swigc__p_wxFlexGridSizer,
56766 _swigc__p_wxFocusEvent,
56767 _swigc__p_wxFont,
56768 _swigc__p_wxFrame,
56769 _swigc__p_wxGBPosition,
56770 _swigc__p_wxGBSizerItem,
56771 _swigc__p_wxGBSpan,
56772 _swigc__p_wxGIFHandler,
56773 _swigc__p_wxGridBagSizer,
56774 _swigc__p_wxGridSizer,
56775 _swigc__p_wxHelpEvent__Origin,
56776 _swigc__p_wxICOHandler,
56777 _swigc__p_wxIconizeEvent,
56778 _swigc__p_wxIdleEvent,
56779 _swigc__p_wxImage,
56780 _swigc__p_wxImageHandler,
56781 _swigc__p_wxImageHistogram,
56782 _swigc__p_wxImage_HSVValue,
56783 _swigc__p_wxImage_RGBValue,
56784 _swigc__p_wxIndividualLayoutConstraint,
56785 _swigc__p_wxInitDialogEvent,
56786 _swigc__p_wxInputStream,
56787 _swigc__p_wxInternetFSHandler,
56788 _swigc__p_wxItemContainer,
56789 _swigc__p_wxJPEGHandler,
56790 _swigc__p_wxKeyEvent,
56791 _swigc__p_wxLayoutConstraints,
56792 _swigc__p_wxMaximizeEvent,
56793 _swigc__p_wxMemoryFSHandler,
56794 _swigc__p_wxMenu,
56795 _swigc__p_wxMenuBar,
56796 _swigc__p_wxMenuBarBase,
56797 _swigc__p_wxMenuEvent,
56798 _swigc__p_wxMenuItem,
56799 _swigc__p_wxMouseCaptureChangedEvent,
56800 _swigc__p_wxMouseCaptureLostEvent,
56801 _swigc__p_wxMouseEvent,
56802 _swigc__p_wxMoveEvent,
56803 _swigc__p_wxNavigationKeyEvent,
56804 _swigc__p_wxNcPaintEvent,
56805 _swigc__p_wxNotifyEvent,
56806 _swigc__p_wxObject,
56807 _swigc__p_wxOutputStream,
56808 _swigc__p_wxPCXHandler,
56809 _swigc__p_wxPNGHandler,
56810 _swigc__p_wxPNMHandler,
56811 _swigc__p_wxPaintEvent,
56812 _swigc__p_wxPaletteChangedEvent,
56813 _swigc__p_wxPaperSize,
56814 _swigc__p_wxPoint,
56815 _swigc__p_wxPoint2D,
56816 _swigc__p_wxPropagateOnce,
56817 _swigc__p_wxPropagationDisabler,
56818 _swigc__p_wxPyApp,
56819 _swigc__p_wxPyCommandEvent,
56820 _swigc__p_wxPyDropTarget,
56821 _swigc__p_wxPyEvent,
56822 _swigc__p_wxPyFileSystemHandler,
56823 _swigc__p_wxPyImageHandler,
56824 _swigc__p_wxPyInputStream,
56825 _swigc__p_wxPySizer,
56826 _swigc__p_wxPyValidator,
56827 _swigc__p_wxQuantize,
56828 _swigc__p_wxQueryNewPaletteEvent,
56829 _swigc__p_wxRealPoint,
56830 _swigc__p_wxRect,
56831 _swigc__p_wxRegion,
56832 _swigc__p_wxScrollEvent,
56833 _swigc__p_wxScrollWinEvent,
56834 _swigc__p_wxSetCursorEvent,
56835 _swigc__p_wxShowEvent,
56836 _swigc__p_wxSize,
56837 _swigc__p_wxSizeEvent,
56838 _swigc__p_wxSizer,
56839 _swigc__p_wxSizerItem,
56840 _swigc__p_wxStaticBox,
56841 _swigc__p_wxStaticBoxSizer,
56842 _swigc__p_wxStdDialogButtonSizer,
56843 _swigc__p_wxSysColourChangedEvent,
56844 _swigc__p_wxTIFFHandler,
56845 _swigc__p_wxToolTip,
56846 _swigc__p_wxUpdateUIEvent,
56847 _swigc__p_wxValidator,
56848 _swigc__p_wxVisualAttributes,
56849 _swigc__p_wxWindow,
56850 _swigc__p_wxWindowCreateEvent,
56851 _swigc__p_wxWindowDestroyEvent,
56852 _swigc__p_wxXPMHandler,
56853 _swigc__p_wxZipFSHandler,
56854 };
56855
56856
56857 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56858
56859 static swig_const_info swig_const_table[] = {
56860 {0, 0, 0, 0.0, 0, 0}};
56861
56862 #ifdef __cplusplus
56863 }
56864 #endif
56865 /* -----------------------------------------------------------------------------
56866 * Type initialization:
56867 * This problem is tough by the requirement that no dynamic
56868 * memory is used. Also, since swig_type_info structures store pointers to
56869 * swig_cast_info structures and swig_cast_info structures store pointers back
56870 * to swig_type_info structures, we need some lookup code at initialization.
56871 * The idea is that swig generates all the structures that are needed.
56872 * The runtime then collects these partially filled structures.
56873 * The SWIG_InitializeModule function takes these initial arrays out of
56874 * swig_module, and does all the lookup, filling in the swig_module.types
56875 * array with the correct data and linking the correct swig_cast_info
56876 * structures together.
56877 *
56878 * The generated swig_type_info structures are assigned staticly to an initial
56879 * array. We just loop though that array, and handle each type individually.
56880 * First we lookup if this type has been already loaded, and if so, use the
56881 * loaded structure instead of the generated one. Then we have to fill in the
56882 * cast linked list. The cast data is initially stored in something like a
56883 * two-dimensional array. Each row corresponds to a type (there are the same
56884 * number of rows as there are in the swig_type_initial array). Each entry in
56885 * a column is one of the swig_cast_info structures for that type.
56886 * The cast_initial array is actually an array of arrays, because each row has
56887 * a variable number of columns. So to actually build the cast linked list,
56888 * we find the array of casts associated with the type, and loop through it
56889 * adding the casts to the list. The one last trick we need to do is making
56890 * sure the type pointer in the swig_cast_info struct is correct.
56891 *
56892 * First off, we lookup the cast->type name to see if it is already loaded.
56893 * There are three cases to handle:
56894 * 1) If the cast->type has already been loaded AND the type we are adding
56895 * casting info to has not been loaded (it is in this module), THEN we
56896 * replace the cast->type pointer with the type pointer that has already
56897 * been loaded.
56898 * 2) If BOTH types (the one we are adding casting info to, and the
56899 * cast->type) are loaded, THEN the cast info has already been loaded by
56900 * the previous module so we just ignore it.
56901 * 3) Finally, if cast->type has not already been loaded, then we add that
56902 * swig_cast_info to the linked list (because the cast->type) pointer will
56903 * be correct.
56904 * ----------------------------------------------------------------------------- */
56905
56906 #ifdef __cplusplus
56907 extern "C" {
56908 #if 0
56909 } /* c-mode */
56910 #endif
56911 #endif
56912
56913 #if 0
56914 #define SWIGRUNTIME_DEBUG
56915 #endif
56916
56917 SWIGRUNTIME void
56918 SWIG_InitializeModule(void *clientdata) {
56919 size_t i;
56920 swig_module_info *module_head;
56921 static int init_run = 0;
56922
56923 clientdata = clientdata;
56924
56925 if (init_run) return;
56926 init_run = 1;
56927
56928 /* Initialize the swig_module */
56929 swig_module.type_initial = swig_type_initial;
56930 swig_module.cast_initial = swig_cast_initial;
56931
56932 /* Try and load any already created modules */
56933 module_head = SWIG_GetModule(clientdata);
56934 if (module_head) {
56935 swig_module.next = module_head->next;
56936 module_head->next = &swig_module;
56937 } else {
56938 /* This is the first module loaded */
56939 swig_module.next = &swig_module;
56940 SWIG_SetModule(clientdata, &swig_module);
56941 }
56942
56943 /* Now work on filling in swig_module.types */
56944 #ifdef SWIGRUNTIME_DEBUG
56945 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56946 #endif
56947 for (i = 0; i < swig_module.size; ++i) {
56948 swig_type_info *type = 0;
56949 swig_type_info *ret;
56950 swig_cast_info *cast;
56951
56952 #ifdef SWIGRUNTIME_DEBUG
56953 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56954 #endif
56955
56956 /* if there is another module already loaded */
56957 if (swig_module.next != &swig_module) {
56958 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56959 }
56960 if (type) {
56961 /* Overwrite clientdata field */
56962 #ifdef SWIGRUNTIME_DEBUG
56963 printf("SWIG_InitializeModule: found type %s\n", type->name);
56964 #endif
56965 if (swig_module.type_initial[i]->clientdata) {
56966 type->clientdata = swig_module.type_initial[i]->clientdata;
56967 #ifdef SWIGRUNTIME_DEBUG
56968 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56969 #endif
56970 }
56971 } else {
56972 type = swig_module.type_initial[i];
56973 }
56974
56975 /* Insert casting types */
56976 cast = swig_module.cast_initial[i];
56977 while (cast->type) {
56978 /* Don't need to add information already in the list */
56979 ret = 0;
56980 #ifdef SWIGRUNTIME_DEBUG
56981 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
56982 #endif
56983 if (swig_module.next != &swig_module) {
56984 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
56985 #ifdef SWIGRUNTIME_DEBUG
56986 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
56987 #endif
56988 }
56989 if (ret) {
56990 if (type == swig_module.type_initial[i]) {
56991 #ifdef SWIGRUNTIME_DEBUG
56992 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
56993 #endif
56994 cast->type = ret;
56995 ret = 0;
56996 } else {
56997 /* Check for casting already in the list */
56998 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
56999 #ifdef SWIGRUNTIME_DEBUG
57000 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
57001 #endif
57002 if (!ocast) ret = 0;
57003 }
57004 }
57005
57006 if (!ret) {
57007 #ifdef SWIGRUNTIME_DEBUG
57008 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
57009 #endif
57010 if (type->cast) {
57011 type->cast->prev = cast;
57012 cast->next = type->cast;
57013 }
57014 type->cast = cast;
57015 }
57016 cast++;
57017 }
57018 /* Set entry in modules->types array equal to the type */
57019 swig_module.types[i] = type;
57020 }
57021 swig_module.types[i] = 0;
57022
57023 #ifdef SWIGRUNTIME_DEBUG
57024 printf("**** SWIG_InitializeModule: Cast List ******\n");
57025 for (i = 0; i < swig_module.size; ++i) {
57026 int j = 0;
57027 swig_cast_info *cast = swig_module.cast_initial[i];
57028 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
57029 while (cast->type) {
57030 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
57031 cast++;
57032 ++j;
57033 }
57034 printf("---- Total casts: %d\n",j);
57035 }
57036 printf("**** SWIG_InitializeModule: Cast List ******\n");
57037 #endif
57038 }
57039
57040 /* This function will propagate the clientdata field of type to
57041 * any new swig_type_info structures that have been added into the list
57042 * of equivalent types. It is like calling
57043 * SWIG_TypeClientData(type, clientdata) a second time.
57044 */
57045 SWIGRUNTIME void
57046 SWIG_PropagateClientData(void) {
57047 size_t i;
57048 swig_cast_info *equiv;
57049 static int init_run = 0;
57050
57051 if (init_run) return;
57052 init_run = 1;
57053
57054 for (i = 0; i < swig_module.size; i++) {
57055 if (swig_module.types[i]->clientdata) {
57056 equiv = swig_module.types[i]->cast;
57057 while (equiv) {
57058 if (!equiv->converter) {
57059 if (equiv->type && !equiv->type->clientdata)
57060 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
57061 }
57062 equiv = equiv->next;
57063 }
57064 }
57065 }
57066 }
57067
57068 #ifdef __cplusplus
57069 #if 0
57070 {
57071 /* c-mode */
57072 #endif
57073 }
57074 #endif
57075
57076
57077
57078 #ifdef __cplusplus
57079 extern "C" {
57080 #endif
57081
57082 /* Python-specific SWIG API */
57083 #define SWIG_newvarlink() SWIG_Python_newvarlink()
57084 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
57085 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
57086
57087 /* -----------------------------------------------------------------------------
57088 * global variable support code.
57089 * ----------------------------------------------------------------------------- */
57090
57091 typedef struct swig_globalvar {
57092 char *name; /* Name of global variable */
57093 PyObject *(*get_attr)(void); /* Return the current value */
57094 int (*set_attr)(PyObject *); /* Set the value */
57095 struct swig_globalvar *next;
57096 } swig_globalvar;
57097
57098 typedef struct swig_varlinkobject {
57099 PyObject_HEAD
57100 swig_globalvar *vars;
57101 } swig_varlinkobject;
57102
57103 SWIGINTERN PyObject *
57104 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
57105 return PyString_FromString("<Swig global variables>");
57106 }
57107
57108 SWIGINTERN PyObject *
57109 swig_varlink_str(swig_varlinkobject *v) {
57110 PyObject *str = PyString_FromString("(");
57111 swig_globalvar *var;
57112 for (var = v->vars; var; var=var->next) {
57113 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
57114 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
57115 }
57116 PyString_ConcatAndDel(&str,PyString_FromString(")"));
57117 return str;
57118 }
57119
57120 SWIGINTERN int
57121 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
57122 PyObject *str = swig_varlink_str(v);
57123 fprintf(fp,"Swig global variables ");
57124 fprintf(fp,"%s\n", PyString_AsString(str));
57125 Py_DECREF(str);
57126 return 0;
57127 }
57128
57129 SWIGINTERN void
57130 swig_varlink_dealloc(swig_varlinkobject *v) {
57131 swig_globalvar *var = v->vars;
57132 while (var) {
57133 swig_globalvar *n = var->next;
57134 free(var->name);
57135 free(var);
57136 var = n;
57137 }
57138 }
57139
57140 SWIGINTERN PyObject *
57141 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
57142 PyObject *res = NULL;
57143 swig_globalvar *var = v->vars;
57144 while (var) {
57145 if (strcmp(var->name,n) == 0) {
57146 res = (*var->get_attr)();
57147 break;
57148 }
57149 var = var->next;
57150 }
57151 if (res == NULL && !PyErr_Occurred()) {
57152 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
57153 }
57154 return res;
57155 }
57156
57157 SWIGINTERN int
57158 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
57159 int res = 1;
57160 swig_globalvar *var = v->vars;
57161 while (var) {
57162 if (strcmp(var->name,n) == 0) {
57163 res = (*var->set_attr)(p);
57164 break;
57165 }
57166 var = var->next;
57167 }
57168 if (res == 1 && !PyErr_Occurred()) {
57169 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
57170 }
57171 return res;
57172 }
57173
57174 SWIGINTERN PyTypeObject*
57175 swig_varlink_type(void) {
57176 static char varlink__doc__[] = "Swig var link object";
57177 static PyTypeObject varlink_type;
57178 static int type_init = 0;
57179 if (!type_init) {
57180 const PyTypeObject tmp
57181 = {
57182 PyObject_HEAD_INIT(NULL)
57183 0, /* Number of items in variable part (ob_size) */
57184 (char *)"swigvarlink", /* Type name (tp_name) */
57185 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
57186 0, /* Itemsize (tp_itemsize) */
57187 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
57188 (printfunc) swig_varlink_print, /* Print (tp_print) */
57189 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
57190 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
57191 0, /* tp_compare */
57192 (reprfunc) swig_varlink_repr, /* tp_repr */
57193 0, /* tp_as_number */
57194 0, /* tp_as_sequence */
57195 0, /* tp_as_mapping */
57196 0, /* tp_hash */
57197 0, /* tp_call */
57198 (reprfunc)swig_varlink_str, /* tp_str */
57199 0, /* tp_getattro */
57200 0, /* tp_setattro */
57201 0, /* tp_as_buffer */
57202 0, /* tp_flags */
57203 varlink__doc__, /* tp_doc */
57204 0, /* tp_traverse */
57205 0, /* tp_clear */
57206 0, /* tp_richcompare */
57207 0, /* tp_weaklistoffset */
57208 #if PY_VERSION_HEX >= 0x02020000
57209 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
57210 #endif
57211 #if PY_VERSION_HEX >= 0x02030000
57212 0, /* tp_del */
57213 #endif
57214 #ifdef COUNT_ALLOCS
57215 0,0,0,0 /* tp_alloc -> tp_next */
57216 #endif
57217 };
57218 varlink_type = tmp;
57219 varlink_type.ob_type = &PyType_Type;
57220 type_init = 1;
57221 }
57222 return &varlink_type;
57223 }
57224
57225 /* Create a variable linking object for use later */
57226 SWIGINTERN PyObject *
57227 SWIG_Python_newvarlink(void) {
57228 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
57229 if (result) {
57230 result->vars = 0;
57231 }
57232 return ((PyObject*) result);
57233 }
57234
57235 SWIGINTERN void
57236 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
57237 swig_varlinkobject *v = (swig_varlinkobject *) p;
57238 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
57239 if (gv) {
57240 size_t size = strlen(name)+1;
57241 gv->name = (char *)malloc(size);
57242 if (gv->name) {
57243 strncpy(gv->name,name,size);
57244 gv->get_attr = get_attr;
57245 gv->set_attr = set_attr;
57246 gv->next = v->vars;
57247 }
57248 }
57249 v->vars = gv;
57250 }
57251
57252 SWIGINTERN PyObject *
57253 SWIG_globals() {
57254 static PyObject *_SWIG_globals = 0;
57255 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
57256 return _SWIG_globals;
57257 }
57258
57259 /* -----------------------------------------------------------------------------
57260 * constants/methods manipulation
57261 * ----------------------------------------------------------------------------- */
57262
57263 /* Install Constants */
57264 SWIGINTERN void
57265 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
57266 PyObject *obj = 0;
57267 size_t i;
57268 for (i = 0; constants[i].type; ++i) {
57269 switch(constants[i].type) {
57270 case SWIG_PY_POINTER:
57271 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
57272 break;
57273 case SWIG_PY_BINARY:
57274 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
57275 break;
57276 default:
57277 obj = 0;
57278 break;
57279 }
57280 if (obj) {
57281 PyDict_SetItemString(d, constants[i].name, obj);
57282 Py_DECREF(obj);
57283 }
57284 }
57285 }
57286
57287 /* -----------------------------------------------------------------------------*/
57288 /* Fix SwigMethods to carry the callback ptrs when needed */
57289 /* -----------------------------------------------------------------------------*/
57290
57291 SWIGINTERN void
57292 SWIG_Python_FixMethods(PyMethodDef *methods,
57293 swig_const_info *const_table,
57294 swig_type_info **types,
57295 swig_type_info **types_initial) {
57296 size_t i;
57297 for (i = 0; methods[i].ml_name; ++i) {
57298 const char *c = methods[i].ml_doc;
57299 if (c && (c = strstr(c, "swig_ptr: "))) {
57300 int j;
57301 swig_const_info *ci = 0;
57302 const char *name = c + 10;
57303 for (j = 0; const_table[j].type; ++j) {
57304 if (strncmp(const_table[j].name, name,
57305 strlen(const_table[j].name)) == 0) {
57306 ci = &(const_table[j]);
57307 break;
57308 }
57309 }
57310 if (ci) {
57311 size_t shift = (ci->ptype) - types;
57312 swig_type_info *ty = types_initial[shift];
57313 size_t ldoc = (c - methods[i].ml_doc);
57314 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
57315 char *ndoc = (char*)malloc(ldoc + lptr + 10);
57316 if (ndoc) {
57317 char *buff = ndoc;
57318 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
57319 if (ptr) {
57320 strncpy(buff, methods[i].ml_doc, ldoc);
57321 buff += ldoc;
57322 strncpy(buff, "swig_ptr: ", 10);
57323 buff += 10;
57324 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
57325 methods[i].ml_doc = ndoc;
57326 }
57327 }
57328 }
57329 }
57330 }
57331 }
57332
57333 #ifdef __cplusplus
57334 }
57335 #endif
57336
57337 /* -----------------------------------------------------------------------------*
57338 * Partial Init method
57339 * -----------------------------------------------------------------------------*/
57340
57341 #ifdef __cplusplus
57342 extern "C"
57343 #endif
57344 SWIGEXPORT void SWIG_init(void) {
57345 PyObject *m, *d;
57346
57347 /* Fix SwigMethods to carry the callback ptrs when needed */
57348 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
57349
57350 m = Py_InitModule((char *) SWIG_name, SwigMethods);
57351 d = PyModule_GetDict(m);
57352
57353 SWIG_InitializeModule(0);
57354 SWIG_InstallConstants(d,swig_const_table);
57355
57356
57357
57358 #ifndef wxPyUSE_EXPORT
57359 // Make our API structure a CObject so other modules can import it
57360 // from this module.
57361 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
57362 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
57363 Py_XDECREF(cobj);
57364 #endif
57365
57366 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
57367 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
57368 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
57369 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
57370 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
57371 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
57372 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
57373 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
57374 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
57375 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
57376 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
57377 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
57378 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
57379 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
57380 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
57381 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
57382 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
57383 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
57384 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
57385 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
57386 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
57387 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
57388 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
57389 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
57390 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
57391 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
57392 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
57393 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
57394 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
57395 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
57396 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
57397 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
57398 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
57399 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
57400 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
57401 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
57402 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
57403 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
57404 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
57405 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
57406 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
57407 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
57408 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
57409 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
57410 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
57411 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
57412 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
57413 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
57414 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
57415 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
57416 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
57417 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
57418 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
57419 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
57420 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
57421 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
57422 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
57423 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
57424 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
57425 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
57426 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
57427 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
57428 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
57429 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
57430 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
57431 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
57432 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
57433 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
57434 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
57435 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
57436 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
57437 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
57438 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
57439 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
57440 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
57441 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
57442 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
57443 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
57444 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
57445 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
57446 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
57447 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
57448 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
57449 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
57450 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
57451 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
57452 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
57453 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
57454 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
57455 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
57456 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
57457 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
57458 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
57459 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
57460 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
57461 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
57462 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
57463 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
57464 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
57465 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
57466 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
57467 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
57468 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
57469 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
57470 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
57471 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
57472 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
57473 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
57474 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
57475 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
57476 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
57477 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
57478 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
57479 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
57480 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
57481 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
57482 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
57483 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
57484 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
57485 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
57486 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
57487 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
57488 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
57489 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
57490 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
57491 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
57492 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
57493 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
57494 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
57495 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
57496 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
57497 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
57498 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
57499 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
57500 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
57501 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
57502 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
57503 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
57504 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
57505 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
57506 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
57507 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
57508 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
57509 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
57510 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
57511 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
57512 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
57513 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
57514 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
57515 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
57516 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
57517 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
57518 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
57519 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
57520 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
57521 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
57522 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
57523 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
57524 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
57525 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
57526 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
57527 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
57528 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
57529 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
57530 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
57531 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
57532 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
57533 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
57534 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
57535 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
57536 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
57537 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
57538 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
57539 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
57540 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
57541 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
57542 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
57543 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
57544 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
57545 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
57546 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
57547 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
57548 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
57549 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
57550 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
57551 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
57552 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
57553 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
57554 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
57555 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
57556 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
57557 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
57558 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
57559 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
57560 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
57561 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
57562 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
57563 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
57564 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
57565 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
57566 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
57567 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
57568 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
57569 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
57570 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
57571 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
57572 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
57573 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
57574 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
57575 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
57576 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
57577 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
57578 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
57579 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
57580 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
57581 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
57582 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
57583 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
57584 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
57585 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
57586 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
57587 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
57588 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
57589 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
57590 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
57591 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
57592 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
57593 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
57594 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
57595 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
57596 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
57597 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
57598 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
57599 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
57600 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
57601 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
57602 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
57603 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
57604 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
57605 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
57606 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
57607 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
57608 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
57609 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
57610 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
57611 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
57612 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
57613 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
57614 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
57615 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
57616 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
57617 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
57618 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
57619 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
57620 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
57621 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
57622 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
57623 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
57624 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
57625 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
57626 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
57627 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
57628 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
57629 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
57630 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
57631 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
57632 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57633 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57634 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57635 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57636 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57637 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57638 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57639 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57640 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57641 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57642 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57643 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57644 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57645 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57646 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57647 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57648 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57649 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57650 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57651 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57652 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57653 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57654 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57655 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57656 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57657 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57658 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57659 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57660 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57661 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57662 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57663 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57664 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57665 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57666 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57667 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57668 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57669 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57670 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57671 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57672 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57673 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57674 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57675 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57676 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57677 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57678 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57679 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57680 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57681 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57682 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57683 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57684 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57685 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57686 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57687 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57688 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57689 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57690 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57691 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57692 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57693 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57694 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57695 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57696 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57697 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57698 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57699 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57700 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57701 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57702 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57703 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57704 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57705 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57706 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57707 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57708 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57709 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57710 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57711 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57712 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57713 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57714 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57715 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57716 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57717 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57718 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57719 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57720 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57721 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57722 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57723 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57724 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57725 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57726 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57727 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57728 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57729 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57730 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57731 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57732 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57733 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57734 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57735 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57736 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57737 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57738 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57739 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57740 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57741 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57742 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57743 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57744 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57745 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57746 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57747 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57748 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57749 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57750 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57751 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57752 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57753 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57754 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57755 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57756 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57757 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57758 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57759 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57760 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57761 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57762 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57763 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57764 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57765 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57766 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57767 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57768 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57769 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57770 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57771 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57772 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57773 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57774 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57775 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57776 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57777 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57778 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57779 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57780 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57781 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57782 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57783 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57784 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57785 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57786 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57787 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57788 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57789 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57790 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57791 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57792 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57793 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57794 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57795 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57796 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57797 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57798 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57799 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57800 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57801 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57802 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57803 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57804 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57805 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57806 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57807 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57808 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57809 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57810 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57811 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57812 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57813 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57814 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57815 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57816 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57817 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57818 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57819 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57820 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57821 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57822 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57823 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57824 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57825 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57826 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57827 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57828 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57829 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57830 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57831 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57832 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57833 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57834 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57835 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57836 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57837 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57838 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57839 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57840 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57841 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57842 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57843 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57844 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57845 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57846 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57847 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57848 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57849 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57850 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57851 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57852 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57853 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57854 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57855 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57856 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57857 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57858 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57859 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57860 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57861 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57862 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57863 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57864 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57865 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57866 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57867 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57868 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57869 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57870 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57871 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57872 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57873 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57874 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57875 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57876 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57877 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57878 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57879 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57880 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57881 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57882 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57883 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57884 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57885 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57886 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57887 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57888 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57889 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57890 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57891 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57892 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57893 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57894 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57895 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57896 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57897 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57898 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57899 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57900 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57901 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57902 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57903 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57904 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57905 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57906 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57907 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57908 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57909 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57910 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57911 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57912 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57913 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57914 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57915 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57916 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57917 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57918 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57919 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57920 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57921 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57922 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57923 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57924 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57925 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57926 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57927 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57928 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57929 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57930 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57931 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57932 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57933 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57934 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57935 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57936 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57937 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57938 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57939 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57940 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57941 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57942 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57943 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57944 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57945 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57946 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57947 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57948 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57949 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57950 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57951 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57952 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57953 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57954 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57955 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57956 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57957 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57958 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57959 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57960 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57961 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57962 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57963 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57964 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
57965 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
57966 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
57967 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57968 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57969 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57970 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
57971 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
57972 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
57973 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
57974 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
57975 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
57976 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
57977 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
57978 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
57979 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
57980 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
57981 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
57982 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
57983 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
57984 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
57985 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
57986 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
57987 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
57988 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
57989 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
57990 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
57991 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
57992 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
57993 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
57994 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
57995 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
57996 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
57997 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
57998 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
57999 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
58000 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
58001 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
58002 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
58003 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
58004 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
58005 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
58006 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
58007 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
58008 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
58009 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
58010 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
58011 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
58012 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
58013 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
58014 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
58015 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
58016 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
58017 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
58018 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
58019 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
58020 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
58021 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
58022 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
58023 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
58024 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
58025
58026 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
58027
58028
58029 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
58030
58031 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
58032 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
58033 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
58034 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
58035 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
58036 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
58037 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
58038 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
58039 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
58040 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
58041 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
58042 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
58043 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
58044 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
58045 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
58046 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
58047 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
58048 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
58049 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
58050 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
58051 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
58052 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
58053 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
58054 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
58055 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
58056 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
58057 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
58058 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
58059 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
58060 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
58061 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
58062 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
58063 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
58064 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
58065 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
58066 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
58067 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
58068 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
58069 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
58070 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
58071 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
58072 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
58073 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
58074 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
58075 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
58076 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
58077 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
58078 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
58079 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
58080 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
58081 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
58082 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
58083 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
58084 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
58085 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
58086 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
58087 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
58088 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
58089 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
58090 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
58091 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
58092 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
58093 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
58094 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
58095 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
58096 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
58097 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
58098 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
58099 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
58100 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
58101 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
58102 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
58103 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
58104 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
58105 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
58106 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
58107 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
58108 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
58109 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
58110 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
58111 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
58112 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
58113 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
58114 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
58115 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
58116 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
58117 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
58118 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
58119 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
58120 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
58121 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
58122 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
58123 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
58124 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
58125 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
58126 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
58127 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
58128 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
58129 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
58130 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
58131 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
58132 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
58133 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
58134 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
58135 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
58136 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
58137 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
58138 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
58139 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
58140 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
58141 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
58142 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
58143 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
58144 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
58145 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
58146 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
58147 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
58148 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
58149 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
58150 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
58151 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
58152 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
58153 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
58154 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
58155 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
58156 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
58157 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
58158 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
58159 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
58160 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
58161 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
58162 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
58163 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
58164 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
58165 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
58166 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
58167 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
58168 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
58169 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
58170 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
58171 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
58172 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
58173 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
58174 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
58175 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
58176 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
58177 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
58178 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
58179 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
58180 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
58181 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
58182 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
58183 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
58184 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
58185 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
58186 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
58187 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
58188 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
58189 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
58190 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
58191 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
58192 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
58193 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
58194 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
58195 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
58196 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
58197 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
58198 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
58199 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
58200 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
58201 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
58202 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
58203 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
58204 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
58205 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
58206 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
58207 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
58208 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
58209 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
58210 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
58211 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
58212 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
58213 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
58214 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
58215 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
58216 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
58217 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
58218 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
58219 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
58220 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
58221 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
58222 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
58223 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
58224 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
58225 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
58226 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
58227 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
58228 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
58229 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
58230 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
58231 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
58232 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
58233 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
58234 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
58235 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
58236 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
58237 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
58238 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
58239 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
58240 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
58241 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
58242 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
58243 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
58244 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
58245
58246 // Initialize threading, some globals and such
58247 __wxPyPreStart(d);
58248
58249
58250 // Although these are defined in __version__ they need to be here too so
58251 // that an assert can be done to ensure that the wxPython and the wxWindows
58252 // versions match.
58253 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
58254 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
58255 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
58256
58257 }
58258
wxWidgets (Impactor)