]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #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_wxDouble swig_types[33]
2500 #define SWIGTYPE_p_wxDropFilesEvent swig_types[34]
2501 #define SWIGTYPE_p_wxDuplexMode swig_types[35]
2502 #define SWIGTYPE_p_wxEraseEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEvent swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoop swig_types[38]
2505 #define SWIGTYPE_p_wxEventLoopActivator swig_types[39]
2506 #define SWIGTYPE_p_wxEvtHandler swig_types[40]
2507 #define SWIGTYPE_p_wxFSFile swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystem swig_types[42]
2509 #define SWIGTYPE_p_wxFileSystemHandler swig_types[43]
2510 #define SWIGTYPE_p_wxFlexGridSizer swig_types[44]
2511 #define SWIGTYPE_p_wxFocusEvent swig_types[45]
2512 #define SWIGTYPE_p_wxFont swig_types[46]
2513 #define SWIGTYPE_p_wxFrame swig_types[47]
2514 #define SWIGTYPE_p_wxGBPosition swig_types[48]
2515 #define SWIGTYPE_p_wxGBSizerItem swig_types[49]
2516 #define SWIGTYPE_p_wxGBSpan swig_types[50]
2517 #define SWIGTYPE_p_wxGIFHandler swig_types[51]
2518 #define SWIGTYPE_p_wxGridBagSizer swig_types[52]
2519 #define SWIGTYPE_p_wxGridSizer swig_types[53]
2520 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[54]
2521 #define SWIGTYPE_p_wxICOHandler swig_types[55]
2522 #define SWIGTYPE_p_wxIconizeEvent swig_types[56]
2523 #define SWIGTYPE_p_wxIdleEvent swig_types[57]
2524 #define SWIGTYPE_p_wxImage swig_types[58]
2525 #define SWIGTYPE_p_wxImageHandler swig_types[59]
2526 #define SWIGTYPE_p_wxImageHistogram swig_types[60]
2527 #define SWIGTYPE_p_wxImage_HSVValue swig_types[61]
2528 #define SWIGTYPE_p_wxImage_RGBValue swig_types[62]
2529 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[63]
2530 #define SWIGTYPE_p_wxInitDialogEvent swig_types[64]
2531 #define SWIGTYPE_p_wxInputStream swig_types[65]
2532 #define SWIGTYPE_p_wxInternetFSHandler swig_types[66]
2533 #define SWIGTYPE_p_wxItemContainer swig_types[67]
2534 #define SWIGTYPE_p_wxJPEGHandler swig_types[68]
2535 #define SWIGTYPE_p_wxKeyEvent swig_types[69]
2536 #define SWIGTYPE_p_wxLayoutConstraints swig_types[70]
2537 #define SWIGTYPE_p_wxMaximizeEvent swig_types[71]
2538 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[72]
2539 #define SWIGTYPE_p_wxMenu swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBar swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBarBase swig_types[75]
2542 #define SWIGTYPE_p_wxMenuEvent swig_types[76]
2543 #define SWIGTYPE_p_wxMenuItem swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMoveEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNcPaintEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNotifyEvent swig_types[84]
2551 #define SWIGTYPE_p_wxObject swig_types[85]
2552 #define SWIGTYPE_p_wxOutputStream swig_types[86]
2553 #define SWIGTYPE_p_wxPCXHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNGHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNMHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPaintEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaperSize swig_types[92]
2559 #define SWIGTYPE_p_wxPoint swig_types[93]
2560 #define SWIGTYPE_p_wxPoint2D swig_types[94]
2561 #define SWIGTYPE_p_wxPropagateOnce swig_types[95]
2562 #define SWIGTYPE_p_wxPropagationDisabler swig_types[96]
2563 #define SWIGTYPE_p_wxPyApp swig_types[97]
2564 #define SWIGTYPE_p_wxPyCommandEvent swig_types[98]
2565 #define SWIGTYPE_p_wxPyDropTarget swig_types[99]
2566 #define SWIGTYPE_p_wxPyEvent swig_types[100]
2567 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyImageHandler swig_types[102]
2569 #define SWIGTYPE_p_wxPyInputStream swig_types[103]
2570 #define SWIGTYPE_p_wxPySizer swig_types[104]
2571 #define SWIGTYPE_p_wxPyValidator swig_types[105]
2572 #define SWIGTYPE_p_wxQuantize swig_types[106]
2573 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[107]
2574 #define SWIGTYPE_p_wxRealPoint swig_types[108]
2575 #define SWIGTYPE_p_wxRect swig_types[109]
2576 #define SWIGTYPE_p_wxRect2D swig_types[110]
2577 #define SWIGTYPE_p_wxRegion swig_types[111]
2578 #define SWIGTYPE_p_wxScrollEvent swig_types[112]
2579 #define SWIGTYPE_p_wxScrollWinEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSetCursorEvent swig_types[114]
2581 #define SWIGTYPE_p_wxShowEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSize swig_types[116]
2583 #define SWIGTYPE_p_wxSizeEvent swig_types[117]
2584 #define SWIGTYPE_p_wxSizer swig_types[118]
2585 #define SWIGTYPE_p_wxSizerItem swig_types[119]
2586 #define SWIGTYPE_p_wxStaticBox swig_types[120]
2587 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[121]
2588 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[122]
2589 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[123]
2590 #define SWIGTYPE_p_wxTGAHandler swig_types[124]
2591 #define SWIGTYPE_p_wxTIFFHandler swig_types[125]
2592 #define SWIGTYPE_p_wxToolTip swig_types[126]
2593 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[127]
2594 #define SWIGTYPE_p_wxValidator swig_types[128]
2595 #define SWIGTYPE_p_wxVisualAttributes swig_types[129]
2596 #define SWIGTYPE_p_wxWindow swig_types[130]
2597 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[131]
2598 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[132]
2599 #define SWIGTYPE_p_wxXPMHandler swig_types[133]
2600 #define SWIGTYPE_p_wxZipFSHandler swig_types[134]
2601 static swig_type_info *swig_types[136];
2602 static swig_module_info swig_module = {swig_types, 135, 0, 0, 0, 0};
2603 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2604 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2605
2606 /* -------- TYPES TABLE (END) -------- */
2607
2608 #if (PY_VERSION_HEX <= 0x02000000)
2609 # if !defined(SWIG_PYTHON_CLASSIC)
2610 # error "This python version requires to use swig with the '-classic' option"
2611 # endif
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodern' option"
2615 #endif
2616 #if (PY_VERSION_HEX <= 0x02020000)
2617 # error "This python version requires to use swig with the '-nomodernargs' option"
2618 #endif
2619 #ifndef METH_O
2620 # error "This python version requires to use swig with the '-nofastunpack' option"
2621 #endif
2622
2623 /*-----------------------------------------------
2624 @(target):= _core_.so
2625 ------------------------------------------------*/
2626 #define SWIG_init init_core_
2627
2628 #define SWIG_name "_core_"
2629
2630 #define SWIGVERSION 0x010329
2631
2632
2633 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2634 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2635
2636
2637 #include <stdexcept>
2638
2639
2640 namespace swig {
2641 class PyObject_ptr {
2642 protected:
2643 PyObject *_obj;
2644
2645 public:
2646 PyObject_ptr() :_obj(0)
2647 {
2648 }
2649
2650 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2651 {
2652 Py_XINCREF(_obj);
2653 }
2654
2655 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2656 {
2657 if (initial_ref) Py_XINCREF(_obj);
2658 }
2659
2660 PyObject_ptr & operator=(const PyObject_ptr& item)
2661 {
2662 Py_XINCREF(item._obj);
2663 Py_XDECREF(_obj);
2664 _obj = item._obj;
2665 return *this;
2666 }
2667
2668 ~PyObject_ptr()
2669 {
2670 Py_XDECREF(_obj);
2671 }
2672
2673 operator PyObject *() const
2674 {
2675 return _obj;
2676 }
2677
2678 PyObject *operator->() const
2679 {
2680 return _obj;
2681 }
2682 };
2683 }
2684
2685
2686 namespace swig {
2687 struct PyObject_var : PyObject_ptr {
2688 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2689
2690 PyObject_var & operator = (PyObject* obj)
2691 {
2692 Py_XDECREF(_obj);
2693 _obj = obj;
2694 return *this;
2695 }
2696 };
2697 }
2698
2699
2700 #include "wx/wxPython/wxPython_int.h"
2701 #include "wx/wxPython/pyclasses.h"
2702 #include "wx/wxPython/twoitem.h"
2703
2704
2705 #ifndef wxPyUSE_EXPORT
2706 // Helper functions for dealing with SWIG objects and such. These are
2707 // located here so they know about the SWIG types and functions declared
2708 // in the wrapper code.
2709
2710 #include <wx/hashmap.h>
2711 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2712
2713
2714 // Maintains a hashmap of className to swig_type_info pointers. Given the
2715 // name of a class either looks up the type info in the cache, or scans the
2716 // SWIG tables for it.
2717 extern PyObject* wxPyPtrTypeMap;
2718 static
2719 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2720
2721 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2722
2723 if (typeInfoCache == NULL)
2724 typeInfoCache = new wxPyTypeInfoHashMap;
2725
2726 wxString name(className);
2727 swig_type_info* swigType = (*typeInfoCache)[name];
2728
2729 if (! swigType) {
2730 // it wasn't in the cache, so look it up from SWIG
2731 name.Append(wxT(" *"));
2732 swigType = SWIG_TypeQuery(name.mb_str());
2733
2734 // if it still wasn't found, try looking for a mapped name
2735 if (!swigType) {
2736 PyObject* item;
2737 name = className;
2738
2739 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2740 (char*)(const char*)name.mbc_str())) != NULL) {
2741 name = wxString(PyString_AsString(item), *wxConvCurrent);
2742 name.Append(wxT(" *"));
2743 swigType = SWIG_TypeQuery(name.mb_str());
2744 }
2745 }
2746 if (swigType) {
2747 // and add it to the map if found
2748 (*typeInfoCache)[className] = swigType;
2749 }
2750 }
2751 return swigType;
2752 }
2753
2754
2755 // Check if a class name is a type known to SWIG
2756 bool wxPyCheckSwigType(const wxChar* className) {
2757
2758 swig_type_info* swigType = wxPyFindSwigType(className);
2759 return swigType != NULL;
2760 }
2761
2762
2763 // Given a pointer to a C++ object and a class name, construct a Python proxy
2764 // object for it.
2765 PyObject* wxPyConstructObject(void* ptr,
2766 const wxChar* className,
2767 int setThisOwn) {
2768
2769 swig_type_info* swigType = wxPyFindSwigType(className);
2770 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2771
2772 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2773 }
2774
2775
2776 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2777 // Ensures that the proxy object is of the specified (or derived) type. If
2778 // not able to perform the conversion then a Python exception is set and the
2779 // error should be handled properly in the caller. Returns True on success.
2780 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2781 const wxChar* className) {
2782
2783 swig_type_info* swigType = wxPyFindSwigType(className);
2784 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2785
2786 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2787 }
2788
2789
2790
2791 // Make a SWIGified pointer object suitable for a .this attribute
2792 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2793
2794 PyObject* robj = NULL;
2795
2796 swig_type_info* swigType = wxPyFindSwigType(className);
2797 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2798
2799 robj = PySwigObject_New(ptr, swigType, 0);
2800 return robj;
2801 }
2802
2803
2804 // Python's PyInstance_Check does not return True for instances of new-style
2805 // classes. This should get close enough for both new and old classes but I
2806 // should re-evaluate the need for doing instance checks...
2807 bool wxPyInstance_Check(PyObject* obj) {
2808 return PyObject_HasAttrString(obj, "__class__") != 0;
2809 }
2810
2811
2812 // This one checks if the object is an instance of a SWIG proxy class (it has
2813 // a .this attribute, and the .this attribute is a PySwigObject.)
2814 bool wxPySwigInstance_Check(PyObject* obj) {
2815 static PyObject* this_str = NULL;
2816 if (this_str == NULL)
2817 this_str = PyString_FromString("this");
2818
2819 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2820 if (this_attr) {
2821 bool retval = (PySwigObject_Check(this_attr) != 0);
2822 Py_DECREF(this_attr);
2823 return retval;
2824 }
2825
2826 PyErr_Clear();
2827 return false;
2828 }
2829
2830
2831 // Export a C API in a struct. Other modules will be able to load this from
2832 // the wx._core_ module and will then have safe access to these functions,
2833 // even if they are located in another shared library.
2834 static wxPyCoreAPI API = {
2835
2836 wxPyCheckSwigType,
2837 wxPyConstructObject,
2838 wxPyConvertSwigPtr,
2839 wxPyMakeSwigPtr,
2840
2841 wxPyBeginAllowThreads,
2842 wxPyEndAllowThreads,
2843 wxPyBeginBlockThreads,
2844 wxPyEndBlockThreads,
2845
2846 wxPy_ConvertList,
2847
2848 wxString_in_helper,
2849 Py2wxString,
2850 wx2PyString,
2851
2852 byte_LIST_helper,
2853 int_LIST_helper,
2854 long_LIST_helper,
2855 string_LIST_helper,
2856 wxPoint_LIST_helper,
2857 wxBitmap_LIST_helper,
2858 wxString_LIST_helper,
2859 wxAcceleratorEntry_LIST_helper,
2860
2861 wxSize_helper,
2862 wxPoint_helper,
2863 wxRealPoint_helper,
2864 wxRect_helper,
2865 wxColour_helper,
2866 wxPoint2D_helper,
2867
2868 wxPySimple_typecheck,
2869 wxColour_typecheck,
2870
2871 wxPyCBH_setCallbackInfo,
2872 wxPyCBH_findCallback,
2873 wxPyCBH_callCallback,
2874 wxPyCBH_callCallbackObj,
2875 wxPyCBH_delete,
2876
2877 wxPyMake_wxObject,
2878 wxPyMake_wxSizer,
2879 wxPyPtrTypeMap_Add,
2880 wxPy2int_seq_helper,
2881 wxPy4int_seq_helper,
2882 wxArrayString2PyList_helper,
2883 wxArrayInt2PyList_helper,
2884
2885 wxPyClientData_dtor,
2886 wxPyUserData_dtor,
2887 wxPyOORClientData_dtor,
2888
2889 wxPyCBInputStream_create,
2890 wxPyCBInputStream_copy,
2891
2892 wxPyInstance_Check,
2893 wxPySwigInstance_Check,
2894
2895 wxPyCheckForApp,
2896
2897 wxArrayDouble2PyList_helper,
2898 wxPoint2D_LIST_helper,
2899 wxRect2D_helper,
2900
2901 };
2902
2903 #endif
2904
2905
2906 #if !WXWIN_COMPATIBILITY_2_4
2907 #define wxHIDE_READONLY 0
2908 #endif
2909
2910
2911 #define SWIG_From_long PyInt_FromLong
2912
2913
2914 SWIGINTERNINLINE PyObject *
2915 SWIG_From_int (int value)
2916 {
2917 return SWIG_From_long (value);
2918 }
2919
2920 static const wxString wxPyEmptyString(wxEmptyString);
2921 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2922 return self->GetClassInfo()->GetClassName();
2923 }
2924 SWIGINTERN void wxObject_Destroy(wxObject *self){
2925 delete self;
2926 }
2927
2928 #ifndef __WXMAC__
2929 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2930 #endif
2931
2932
2933 #include <limits.h>
2934 #ifndef LLONG_MIN
2935 # define LLONG_MIN LONG_LONG_MIN
2936 #endif
2937 #ifndef LLONG_MAX
2938 # define LLONG_MAX LONG_LONG_MAX
2939 #endif
2940 #ifndef ULLONG_MAX
2941 # define ULLONG_MAX ULONG_LONG_MAX
2942 #endif
2943
2944
2945 SWIGINTERN int
2946 SWIG_AsVal_long (PyObject* obj, long* val)
2947 {
2948 if (PyNumber_Check(obj)) {
2949 if (val) *val = PyInt_AsLong(obj);
2950 return SWIG_OK;
2951 }
2952 return SWIG_TypeError;
2953 }
2954
2955
2956 SWIGINTERN int
2957 SWIG_AsVal_int (PyObject * obj, int *val)
2958 {
2959 long v;
2960 int res = SWIG_AsVal_long (obj, &v);
2961 if (SWIG_IsOK(res)) {
2962 if ((v < INT_MIN || v > INT_MAX)) {
2963 return SWIG_OverflowError;
2964 } else {
2965 if (val) *val = static_cast< int >(v);
2966 }
2967 }
2968 return res;
2969 }
2970
2971 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2972 wxSize temp, *obj = &temp;
2973 if ( other == Py_None ) return false;
2974 if ( ! wxSize_helper(other, &obj) ) {
2975 PyErr_Clear();
2976 return false;
2977 }
2978 return self->operator==(*obj);
2979 }
2980 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2981 wxSize temp, *obj = &temp;
2982 if ( other == Py_None ) return true;
2983 if ( ! wxSize_helper(other, &obj)) {
2984 PyErr_Clear();
2985 return true;
2986 }
2987 return self->operator!=(*obj);
2988 }
2989
2990 #include <float.h>
2991
2992
2993 SWIGINTERN int
2994 SWIG_AsVal_double (PyObject *obj, double* val)
2995 {
2996 if (PyNumber_Check(obj)) {
2997 if (val) *val = PyFloat_AsDouble(obj);
2998 return SWIG_OK;
2999 }
3000 return SWIG_TypeError;
3001 }
3002
3003
3004 SWIGINTERN int
3005 SWIG_AsVal_float (PyObject * obj, float *val)
3006 {
3007 double v;
3008 int res = SWIG_AsVal_double (obj, &v);
3009 if (SWIG_IsOK(res)) {
3010 if ((v < -FLT_MAX || v > FLT_MAX)) {
3011 return SWIG_OverflowError;
3012 } else {
3013 if (val) *val = static_cast< float >(v);
3014 }
3015 }
3016 return res;
3017 }
3018
3019 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3020 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3021 PyObject* tup = PyTuple_New(2);
3022 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3023 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3024 //wxPyEndBlockThreads(blocked);
3025 return tup;
3026 }
3027
3028 #define SWIG_From_double PyFloat_FromDouble
3029
3030 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3031 wxRealPoint temp, *obj = &temp;
3032 if ( other == Py_None ) return false;
3033 if ( ! wxRealPoint_helper(other, &obj) ) {
3034 PyErr_Clear();
3035 return false;
3036 }
3037 return self->operator==(*obj);
3038 }
3039 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3040 wxRealPoint temp, *obj = &temp;
3041 if ( other == Py_None ) return true;
3042 if ( ! wxRealPoint_helper(other, &obj)) {
3043 PyErr_Clear();
3044 return true;
3045 }
3046 return self->operator!=(*obj);
3047 }
3048 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3049 self->x = x;
3050 self->y = y;
3051 }
3052 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3053 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3054 PyObject* tup = PyTuple_New(2);
3055 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3056 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3057 //PyEndBlockThreads(blocked);
3058 return tup;
3059 }
3060 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3061 wxPoint temp, *obj = &temp;
3062 if ( other == Py_None ) return false;
3063 if ( ! wxPoint_helper(other, &obj) ) {
3064 PyErr_Clear();
3065 return false;
3066 }
3067 return self->operator==(*obj);
3068 }
3069 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3070 wxPoint temp, *obj = &temp;
3071 if ( other == Py_None ) return true;
3072 if ( ! wxPoint_helper(other, &obj)) {
3073 PyErr_Clear();
3074 return true;
3075 }
3076 return self->operator!=(*obj);
3077 }
3078 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3079 self->x = x;
3080 self->y = y;
3081 }
3082 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3083 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3084 PyObject* tup = PyTuple_New(2);
3085 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3086 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3087 //wxPyEndBlockThreads(blocked);
3088 return tup;
3089 }
3090 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3091 wxRect temp, *obj = &temp;
3092 if ( other == Py_None ) return false;
3093 if ( ! wxRect_helper(other, &obj) ) {
3094 PyErr_Clear();
3095 return false;
3096 }
3097 return self->operator==(*obj);
3098 }
3099 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3100 wxRect temp, *obj = &temp;
3101 if ( other == Py_None ) return true;
3102 if ( ! wxRect_helper(other, &obj)) {
3103 PyErr_Clear();
3104 return true;
3105 }
3106 return self->operator!=(*obj);
3107 }
3108 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3109 self->x = x;
3110 self->y = y;
3111 self->width = width;
3112 self->height = height;
3113 }
3114 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3115 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3116 PyObject* tup = PyTuple_New(4);
3117 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3118 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3119 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3120 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3121 //wxPyEndBlockThreads(blocked);
3122 return tup;
3123 }
3124
3125 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3126 wxRegion reg1(*r1);
3127 wxRegion reg2(*r2);
3128 wxRect dest(0,0,0,0);
3129 PyObject* obj;
3130
3131 reg1.Intersect(reg2);
3132 dest = reg1.GetBox();
3133
3134 if (dest != wxRect(0,0,0,0)) {
3135 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3136 wxRect* newRect = new wxRect(dest);
3137 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3138 //wxPyEndBlockThreads(blocked);
3139 return obj;
3140 }
3141 Py_INCREF(Py_None);
3142 return Py_None;
3143 }
3144
3145 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3146 wxPoint2D temp, *obj = &temp;
3147 if ( other == Py_None ) return false;
3148 if ( ! wxPoint2D_helper(other, &obj) ) {
3149 PyErr_Clear();
3150 return false;
3151 }
3152 return self->operator==(*obj);
3153 }
3154 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3155 wxPoint2D temp, *obj = &temp;
3156 if ( other == Py_None ) return true;
3157 if ( ! wxPoint2D_helper(other, &obj)) {
3158 PyErr_Clear();
3159 return true;
3160 }
3161 return self->operator!=(*obj);
3162 }
3163 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3164 self->m_x = x;
3165 self->m_y = y;
3166 }
3167 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3168 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3169 PyObject* tup = PyTuple_New(2);
3170 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3171 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3172 //wxPyEndBlockThreads(blocked);
3173 return tup;
3174 }
3175 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3176 wxRect2D temp, *obj = &temp;
3177 if ( other == Py_None ) return false;
3178 if ( ! wxRect2D_helper(other, &obj) ) {
3179 PyErr_Clear();
3180 return false;
3181 }
3182 return self->operator==(*obj);
3183 }
3184 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3185 wxRect2D temp, *obj = &temp;
3186 if ( other == Py_None ) return true;
3187 if ( ! wxRect2D_helper(other, &obj)) {
3188 PyErr_Clear();
3189 return true;
3190 }
3191 return self->operator!=(*obj);
3192 }
3193 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3194 self->m_x = x;
3195 self->m_y = y;
3196 self->m_width = width;
3197 self->m_height = height;
3198 }
3199 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3200 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3201 PyObject* tup = PyTuple_New(4);
3202 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3203 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3204 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3205 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3206 //wxPyEndBlockThreads(blocked);
3207 return tup;
3208 }
3209
3210 #include "wx/wxPython/pyistream.h"
3211
3212 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3213 wxInputStream* wxis = wxPyCBInputStream::create(p);
3214 if (wxis)
3215 return new wxPyInputStream(wxis);
3216 else
3217 return NULL;
3218 }
3219
3220 SWIGINTERN swig_type_info*
3221 SWIG_pchar_descriptor()
3222 {
3223 static int init = 0;
3224 static swig_type_info* info = 0;
3225 if (!init) {
3226 info = SWIG_TypeQuery("_p_char");
3227 init = 1;
3228 }
3229 return info;
3230 }
3231
3232
3233 SWIGINTERNINLINE PyObject *
3234 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3235 {
3236 if (carray) {
3237 if (size > INT_MAX) {
3238 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3239 return pchar_descriptor ?
3240 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3241 } else {
3242 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3243 }
3244 } else {
3245 return SWIG_Py_Void();
3246 }
3247 }
3248
3249
3250 SWIGINTERNINLINE PyObject *
3251 SWIG_From_char (char c)
3252 {
3253 return SWIG_FromCharPtrAndSize(&c,1);
3254 }
3255
3256
3257 SWIGINTERNINLINE PyObject*
3258 SWIG_From_unsigned_SS_long (unsigned long value)
3259 {
3260 return (value > LONG_MAX) ?
3261 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3262 }
3263
3264
3265 SWIGINTERNINLINE PyObject *
3266 SWIG_From_size_t (size_t value)
3267 {
3268 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3269 }
3270
3271
3272 SWIGINTERN int
3273 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3274 {
3275 if (PyString_Check(obj)) {
3276 char *cstr; Py_ssize_t len;
3277 PyString_AsStringAndSize(obj, &cstr, &len);
3278 if (cptr) {
3279 if (alloc) {
3280 /*
3281 In python the user should not be able to modify the inner
3282 string representation. To warranty that, if you define
3283 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3284 buffer is always returned.
3285
3286 The default behavior is just to return the pointer value,
3287 so, be careful.
3288 */
3289 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3290 if (*alloc != SWIG_OLDOBJ)
3291 #else
3292 if (*alloc == SWIG_NEWOBJ)
3293 #endif
3294 {
3295 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3296 *alloc = SWIG_NEWOBJ;
3297 }
3298 else {
3299 *cptr = cstr;
3300 *alloc = SWIG_OLDOBJ;
3301 }
3302 } else {
3303 *cptr = PyString_AsString(obj);
3304 }
3305 }
3306 if (psize) *psize = len + 1;
3307 return SWIG_OK;
3308 } else {
3309 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3310 if (pchar_descriptor) {
3311 void* vptr = 0;
3312 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3313 if (cptr) *cptr = (char *) vptr;
3314 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3315 if (alloc) *alloc = SWIG_OLDOBJ;
3316 return SWIG_OK;
3317 }
3318 }
3319 }
3320 return SWIG_TypeError;
3321 }
3322
3323
3324 SWIGINTERN int
3325 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3326 {
3327 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3328 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3329 if (SWIG_IsOK(res)) {
3330 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3331 if (csize <= size) {
3332 if (val) {
3333 if (csize) memcpy(val, cptr, csize*sizeof(char));
3334 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3335 }
3336 if (alloc == SWIG_NEWOBJ) {
3337 delete[] cptr;
3338 res = SWIG_DelNewMask(res);
3339 }
3340 return res;
3341 }
3342 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3343 }
3344 return SWIG_TypeError;
3345 }
3346
3347
3348 SWIGINTERN int
3349 SWIG_AsVal_char (PyObject * obj, char *val)
3350 {
3351 int res = SWIG_AsCharArray(obj, val, 1);
3352 if (!SWIG_IsOK(res)) {
3353 long v;
3354 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3355 if (SWIG_IsOK(res)) {
3356 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3357 if (val) *val = static_cast< char >(v);
3358 } else {
3359 res = SWIG_OverflowError;
3360 }
3361 }
3362 }
3363 return res;
3364 }
3365
3366 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3367 // We use only strings for the streams, not unicode
3368 PyObject* str = PyObject_Str(obj);
3369 if (! str) {
3370 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3371 return;
3372 }
3373 self->Write(PyString_AS_STRING(str),
3374 PyString_GET_SIZE(str));
3375 Py_DECREF(str);
3376 }
3377
3378 #include "wx/wxPython/pyistream.h"
3379
3380
3381 class wxPyFileSystemHandler : public wxFileSystemHandler
3382 {
3383 public:
3384 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3385
3386 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3387 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3388 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3389 DEC_PYCALLBACK_STRING__pure(FindNext);
3390
3391 wxString GetProtocol(const wxString& location) {
3392 return wxFileSystemHandler::GetProtocol(location);
3393 }
3394
3395 wxString GetLeftLocation(const wxString& location) {
3396 return wxFileSystemHandler::GetLeftLocation(location);
3397 }
3398
3399 wxString GetAnchor(const wxString& location) {
3400 return wxFileSystemHandler::GetAnchor(location);
3401 }
3402
3403 wxString GetRightLocation(const wxString& location) {
3404 return wxFileSystemHandler::GetRightLocation(location);
3405 }
3406
3407 wxString GetMimeTypeFromExt(const wxString& location) {
3408 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3409 }
3410
3411 PYPRIVATE;
3412 };
3413
3414
3415 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3416 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3417 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3418 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3419
3420
3421 SWIGINTERN int
3422 SWIG_AsVal_bool (PyObject *obj, bool *val)
3423 {
3424 if (obj == Py_True) {
3425 if (val) *val = true;
3426 return SWIG_OK;
3427 } else if (obj == Py_False) {
3428 if (val) *val = false;
3429 return SWIG_OK;
3430 } else {
3431 long v = 0;
3432 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3433 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3434 return res;
3435 }
3436 }
3437
3438 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3439 wxFileName fname = wxFileSystem::URLToFileName(url);
3440 return fname.GetFullPath();
3441 }
3442
3443 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3444 wxImage& image,
3445 long type) {
3446 wxMemoryFSHandler::AddFile(filename, image, type);
3447 }
3448
3449 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3450 const wxBitmap& bitmap,
3451 long type) {
3452 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3453 }
3454
3455 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3456 PyObject* data) {
3457 if (! PyString_Check(data)) {
3458 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3459 "Expected string object"));
3460 return;
3461 }
3462
3463 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3464 void* ptr = (void*)PyString_AsString(data);
3465 size_t size = PyString_Size(data);
3466 wxPyEndBlockThreads(blocked);
3467
3468 wxMemoryFSHandler::AddFile(filename, ptr, size);
3469 }
3470
3471
3472 #include "wx/wxPython/pyistream.h"
3473
3474
3475 SWIGINTERN int
3476 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3477 {
3478 long v = 0;
3479 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3480 return SWIG_TypeError;
3481 }
3482 else if (val)
3483 *val = (unsigned long)v;
3484 return SWIG_OK;
3485 }
3486
3487
3488 SWIGINTERN int
3489 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3490 {
3491 unsigned long v;
3492 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3493 if (SWIG_IsOK(res)) {
3494 if ((v > UCHAR_MAX)) {
3495 return SWIG_OverflowError;
3496 } else {
3497 if (val) *val = static_cast< unsigned char >(v);
3498 }
3499 }
3500 return res;
3501 }
3502
3503
3504 SWIGINTERNINLINE PyObject *
3505 SWIG_From_unsigned_SS_char (unsigned char value)
3506 {
3507 return SWIG_From_unsigned_SS_long (value);
3508 }
3509
3510 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3511 wxImageHistogramEntry e = (*self)[key];
3512 return e.value;
3513 }
3514 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3515 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3516 wxImageHistogramEntry e = (*self)[key];
3517 return e.value;
3518 }
3519 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3520 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3521 colour.Green(),
3522 colour.Blue());
3523 wxImageHistogramEntry e = (*self)[key];
3524 return e.value;
3525 }
3526
3527 // Pull the nested class out to the top level for SWIG's sake
3528 #define wxImage_RGBValue wxImage::RGBValue
3529 #define wxImage_HSVValue wxImage::HSVValue
3530
3531 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3532 if (width > 0 && height > 0)
3533 return new wxImage(width, height, clear);
3534 else
3535 return new wxImage;
3536 }
3537 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3538 return new wxImage(bitmap.ConvertToImage());
3539 }
3540 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3541 if (DATASIZE != width*height*3) {
3542 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3543 return NULL;
3544 }
3545
3546 // Copy the source data so the wxImage can clean it up later
3547 buffer copy = (buffer)malloc(DATASIZE);
3548 if (copy == NULL) {
3549 wxPyBLOCK_THREADS(PyErr_NoMemory());
3550 return NULL;
3551 }
3552 memcpy(copy, data, DATASIZE);
3553 return new wxImage(width, height, copy, false);
3554 }
3555 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3556 if (DATASIZE != width*height*3) {
3557 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3558 return NULL;
3559 }
3560 if (ALPHASIZE != width*height) {
3561 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3562 return NULL;
3563 }
3564
3565 // Copy the source data so the wxImage can clean it up later
3566 buffer dcopy = (buffer)malloc(DATASIZE);
3567 if (dcopy == NULL) {
3568 wxPyBLOCK_THREADS(PyErr_NoMemory());
3569 return NULL;
3570 }
3571 memcpy(dcopy, data, DATASIZE);
3572
3573 buffer acopy = (buffer)malloc(ALPHASIZE);
3574 if (acopy == NULL) {
3575 wxPyBLOCK_THREADS(PyErr_NoMemory());
3576 return NULL;
3577 }
3578 memcpy(acopy, alpha, ALPHASIZE);
3579
3580 return new wxImage(width, height, dcopy, acopy, false);
3581 }
3582 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3583 wxSize size(self->GetWidth(), self->GetHeight());
3584 return size;
3585 }
3586 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3587 buffer data = self->GetData();
3588 int len = self->GetWidth() * self->GetHeight() * 3;
3589 PyObject* rv;
3590 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3591 return rv;
3592 }
3593 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3594 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3595 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3596 return;
3597 }
3598 buffer copy = (buffer)malloc(DATASIZE);
3599 if (copy == NULL) {
3600 wxPyBLOCK_THREADS(PyErr_NoMemory());
3601 return;
3602 }
3603 memcpy(copy, data, DATASIZE);
3604 self->SetData(copy, false);
3605 // wxImage takes ownership of copy...
3606 }
3607 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3608 buffer data = self->GetData();
3609 int len = self->GetWidth() * self->GetHeight() * 3;
3610 PyObject* rv;
3611 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3612 return rv;
3613 }
3614 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3615 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3616 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3617 return;
3618 }
3619 self->SetData(data, true);
3620 }
3621 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3622 buffer data = self->GetAlpha();
3623 if (! data) {
3624 RETURN_NONE();
3625 } else {
3626 int len = self->GetWidth() * self->GetHeight();
3627 PyObject* rv;
3628 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3629 return rv;
3630 }
3631 }
3632 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3633 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3634 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3635 return;
3636 }
3637 buffer acopy = (buffer)malloc(ALPHASIZE);
3638 if (acopy == NULL) {
3639 wxPyBLOCK_THREADS(PyErr_NoMemory());
3640 return;
3641 }
3642 memcpy(acopy, alpha, ALPHASIZE);
3643 self->SetAlpha(acopy, false);
3644 // wxImage takes ownership of acopy...
3645 }
3646 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3647 buffer data = self->GetAlpha();
3648 int len = self->GetWidth() * self->GetHeight();
3649 PyObject* rv;
3650 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3651 return rv;
3652 }
3653 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3654 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3655 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3656 return;
3657 }
3658 self->SetAlpha(alpha, true);
3659 }
3660 SWIGINTERN PyObject *wxImage_GetHandlers(){
3661 wxList& list = wxImage::GetHandlers();
3662 return wxPy_ConvertList(&list);
3663 }
3664 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3665 wxBitmap bitmap(*self, depth);
3666 return bitmap;
3667 }
3668 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3669 wxImage mono = self->ConvertToMono( red, green, blue );
3670 wxBitmap bitmap( mono, 1 );
3671 return bitmap;
3672 }
3673
3674 wxImage* _ImageFromBuffer(int width, int height,
3675 buffer data, int DATASIZE,
3676 buffer alpha=NULL, int ALPHASIZE=0)
3677 {
3678 if (DATASIZE != width*height*3) {
3679 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3680 return NULL;
3681 }
3682 if (alpha != NULL) {
3683 if (ALPHASIZE != width*height) {
3684 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3685 return NULL;
3686 }
3687 return new wxImage(width, height, data, alpha, true);
3688 }
3689 return new wxImage(width, height, data, true);
3690 }
3691
3692 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3693 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3694 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3695 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3696 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3697 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3698 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3699 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3700 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3701 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3702 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3703 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3704 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3705 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3706 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3707
3708 #include <wx/imagtga.h>
3709
3710
3711 #include <wx/quantize.h>
3712
3713 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3714 return wxQuantize::Quantize(src, dest,
3715 //NULL, // palette
3716 desiredNoColours,
3717 NULL, // eightBitData
3718 flags);
3719 }
3720 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3721 if (PyCallable_Check(func)) {
3722 self->Connect(id, lastId, eventType,
3723 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3724 new wxPyCallback(func));
3725 }
3726 else if (func == Py_None) {
3727 self->Disconnect(id, lastId, eventType,
3728 (wxObjectEventFunction)
3729 &wxPyCallback::EventThunker);
3730 }
3731 else {
3732 wxPyBLOCK_THREADS(
3733 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3734 }
3735 }
3736 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3737 return self->Disconnect(id, lastId, eventType,
3738 (wxObjectEventFunction)
3739 &wxPyCallback::EventThunker);
3740 }
3741 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3742 if (_self && _self != Py_None) {
3743 self->SetClientObject(new wxPyOORClientData(_self, incref));
3744 }
3745 else {
3746 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3747 if (data) {
3748 self->SetClientObject(NULL); // This will delete it too
3749 }
3750 }
3751 }
3752
3753 #if ! wxUSE_HOTKEY
3754 #define wxEVT_HOTKEY -9999
3755 #endif
3756
3757 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3758 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3759 if (data) {
3760 Py_INCREF(data->m_obj);
3761 return data->m_obj;
3762 } else {
3763 Py_INCREF(Py_None);
3764 return Py_None;
3765 }
3766 }
3767 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3768 wxPyClientData* data = new wxPyClientData(clientData);
3769 self->SetClientObject(data);
3770 }
3771 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3772 #if wxUSE_UNICODE
3773 return self->GetUnicodeKey();
3774 #else
3775 return 0;
3776 #endif
3777 }
3778 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3779 #if wxUSE_UNICODE
3780 self->m_uniChar = uniChar;
3781 #endif
3782 }
3783
3784 SWIGINTERNINLINE PyObject *
3785 SWIG_From_unsigned_SS_int (unsigned int value)
3786 {
3787 return SWIG_From_unsigned_SS_long (value);
3788 }
3789
3790
3791 SWIGINTERN int
3792 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3793 {
3794 unsigned long v;
3795 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3796 if (SWIG_IsOK(res)) {
3797 if ((v > UINT_MAX)) {
3798 return SWIG_OverflowError;
3799 } else {
3800 if (val) *val = static_cast< unsigned int >(v);
3801 }
3802 }
3803 return res;
3804 }
3805
3806 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3807 self->m_size = size;
3808 }
3809 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3810 int count = self->GetNumberOfFiles();
3811 wxString* files = self->GetFiles();
3812 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3813 PyObject* list = PyList_New(count);
3814
3815 if (!list) {
3816 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3817 wxPyEndBlockThreads(blocked);
3818 return NULL;
3819 }
3820
3821 for (int i=0; i<count; i++) {
3822 PyList_SetItem(list, i, wx2PyString(files[i]));
3823 }
3824 wxPyEndBlockThreads(blocked);
3825 return list;
3826 }
3827
3828
3829 SWIGINTERN wxPyApp *new_wxPyApp(){
3830 wxPythonApp = new wxPyApp();
3831 return wxPythonApp;
3832 }
3833 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3834 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3835 return wxPyTestDisplayAvailable();
3836 }
3837
3838 void wxApp_CleanUp() {
3839 __wxPyCleanup();
3840 }
3841
3842
3843 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3844
3845
3846
3847
3848
3849 SWIGINTERNINLINE PyObject *
3850 SWIG_FromCharPtr(const char *cptr)
3851 {
3852 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3853 }
3854
3855
3856 #if 0 // #ifdef __WXMAC__
3857
3858 // A dummy class that raises an exception if used...
3859 class wxEventLoop
3860 {
3861 public:
3862 wxEventLoop() { wxPyRaiseNotImplemented(); }
3863 int Run() { return 0; }
3864 void Exit(int rc = 0) {}
3865 bool Pending() const { return false; }
3866 bool Dispatch() { return false; }
3867 bool IsRunning() const { return false; }
3868 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3869 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3870 };
3871
3872 #else
3873
3874 #include <wx/evtloop.h>
3875
3876 #endif
3877
3878
3879
3880 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3881 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3882 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3883 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3884 wxWindowList& list = self->GetChildren();
3885 return wxPy_ConvertList(&list);
3886 }
3887 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3888 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3889 #if wxUSE_HOTKEY
3890 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3891 #else
3892 return false;
3893 #endif
3894 }
3895 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3896
3897
3898
3899 return false;
3900
3901 }
3902 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3903 return wxPyGetWinHandle(self);
3904 }
3905 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3906 self->AssociateHandle((WXWidget)handle);
3907 }
3908 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3909
3910 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3911 return wxWindow::FindWindowById(id, parent);
3912 }
3913
3914 wxWindow* wxFindWindowByName( const wxString& name,
3915 const wxWindow *parent = NULL ) {
3916 return wxWindow::FindWindowByName(name, parent);
3917 }
3918
3919 wxWindow* wxFindWindowByLabel( const wxString& label,
3920 const wxWindow *parent = NULL ) {
3921 return wxWindow::FindWindowByLabel(label, parent);
3922 }
3923
3924
3925 #ifdef __WXMSW__
3926 #include <wx/msw/private.h> // to get wxGetWindowId
3927 #endif
3928
3929
3930 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3931 #ifdef __WXMSW__
3932 WXHWND hWnd = (WXHWND)_hWnd;
3933 long id = wxGetWindowId(hWnd);
3934 wxWindow* win = new wxWindow;
3935 if (parent)
3936 parent->AddChild(win);
3937 win->SetEventHandler(win);
3938 win->SetHWND(hWnd);
3939 win->SetId(id);
3940 win->SubclassWin(hWnd);
3941 win->AdoptAttributesFromHWND();
3942 win->SetupColours();
3943 return win;
3944 #else
3945 wxPyRaiseNotImplemented();
3946 return NULL;
3947 #endif
3948 }
3949
3950
3951 PyObject* GetTopLevelWindows() {
3952 return wxPy_ConvertList(&wxTopLevelWindows);
3953 }
3954
3955
3956 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3957 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3958 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3959
3960 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3961
3962
3963 SWIGINTERNINLINE int
3964 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3965 {
3966 unsigned long v;
3967 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3968 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3969 return res;
3970 }
3971
3972 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3973 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3974 wxMenuItemList& list = self->GetMenuItems();
3975 return wxPy_ConvertList(&list);
3976 }
3977 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3978 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3979 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3980 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3981 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3982 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3983 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3984 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3985 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3986 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3987 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3988 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3989 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3990 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3991 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3992 static const wxString wxPyControlNameStr(wxControlNameStr);
3993 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3994 if (clientData) {
3995 wxPyClientData* data = new wxPyClientData(clientData);
3996 return self->Append(item, data);
3997 } else
3998 return self->Append(item);
3999 }
4000 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
4001 if (clientData) {
4002 wxPyClientData* data = new wxPyClientData(clientData);
4003 return self->Insert(item, pos, data);
4004 } else
4005 return self->Insert(item, pos);
4006 }
4007 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
4008 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
4009 if (data) {
4010 Py_INCREF(data->m_obj);
4011 return data->m_obj;
4012 } else {
4013 Py_INCREF(Py_None);
4014 return Py_None;
4015 }
4016 }
4017 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
4018 wxPyClientData* data = new wxPyClientData(clientData);
4019 self->SetClientObject(n, data);
4020 }
4021
4022
4023 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4024 wxPyUserData* data = NULL;
4025 if ( userData ) {
4026 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4027 data = new wxPyUserData(userData);
4028 wxPyEndBlockThreads(blocked);
4029 }
4030 return new wxSizerItem(window, proportion, flag, border, data);
4031 }
4032 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4033 wxPyUserData* data = NULL;
4034 if ( userData ) {
4035 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4036 data = new wxPyUserData(userData);
4037 wxPyEndBlockThreads(blocked);
4038 }
4039 return new wxSizerItem(width, height, proportion, flag, border, data);
4040 }
4041 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4042 wxPyUserData* data = NULL;
4043 if ( userData ) {
4044 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4045 data = new wxPyUserData(userData);
4046 wxPyEndBlockThreads(blocked);
4047 }
4048 return new wxSizerItem(sizer, proportion, flag, border, data);
4049 }
4050
4051 SWIGINTERNINLINE PyObject *
4052 SWIG_From_float (float value)
4053 {
4054 return SWIG_From_double (value);
4055 }
4056
4057 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4058 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4059 if (data) {
4060 Py_INCREF(data->m_obj);
4061 return data->m_obj;
4062 } else {
4063 Py_INCREF(Py_None);
4064 return Py_None;
4065 }
4066 }
4067 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4068 wxPyUserData* data = NULL;
4069 if ( userData ) {
4070 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4071 data = new wxPyUserData(userData);
4072 wxPyEndBlockThreads(blocked);
4073 }
4074 self->SetUserData(data);
4075 }
4076
4077 // Figure out the type of the sizer item
4078
4079 struct wxPySizerItemInfo {
4080 wxPySizerItemInfo()
4081 : window(NULL), sizer(NULL), gotSize(false),
4082 size(wxDefaultSize), gotPos(false), pos(-1)
4083 {}
4084
4085 wxWindow* window;
4086 wxSizer* sizer;
4087 bool gotSize;
4088 wxSize size;
4089 bool gotPos;
4090 int pos;
4091 };
4092
4093 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4094
4095 wxPySizerItemInfo info;
4096 wxSize size;
4097 wxSize* sizePtr = &size;
4098
4099 // Find out what the type of the item is
4100 // try wxWindow
4101 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4102 PyErr_Clear();
4103 info.window = NULL;
4104
4105 // try wxSizer
4106 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4107 PyErr_Clear();
4108 info.sizer = NULL;
4109
4110 // try wxSize or (w,h)
4111 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4112 info.size = *sizePtr;
4113 info.gotSize = true;
4114 }
4115
4116 // or a single int
4117 if (checkIdx && PyInt_Check(item)) {
4118 info.pos = PyInt_AsLong(item);
4119 info.gotPos = true;
4120 }
4121 }
4122 }
4123
4124 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4125 // no expected type, figure out what kind of error message to generate
4126 if ( !checkSize && !checkIdx )
4127 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4128 else if ( checkSize && !checkIdx )
4129 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4130 else if ( !checkSize && checkIdx)
4131 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4132 else
4133 // can this one happen?
4134 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4135 }
4136
4137 return info;
4138 }
4139
4140 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4141 if (!self->GetClientObject())
4142 self->SetClientObject(new wxPyOORClientData(_self));
4143 }
4144 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4145
4146 wxPyUserData* data = NULL;
4147 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4148 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4149 if ( userData && (info.window || info.sizer || info.gotSize) )
4150 data = new wxPyUserData(userData);
4151 if ( info.sizer )
4152 PyObject_SetAttrString(item,"thisown",Py_False);
4153 wxPyEndBlockThreads(blocked);
4154
4155 // Now call the real Add method if a valid item type was found
4156 if ( info.window )
4157 return self->Add(info.window, proportion, flag, border, data);
4158 else if ( info.sizer )
4159 return self->Add(info.sizer, proportion, flag, border, data);
4160 else if (info.gotSize)
4161 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4162 proportion, flag, border, data);
4163 else
4164 return NULL;
4165 }
4166 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4167
4168 wxPyUserData* data = NULL;
4169 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4170 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4171 if ( userData && (info.window || info.sizer || info.gotSize) )
4172 data = new wxPyUserData(userData);
4173 if ( info.sizer )
4174 PyObject_SetAttrString(item,"thisown",Py_False);
4175 wxPyEndBlockThreads(blocked);
4176
4177 // Now call the real Insert method if a valid item type was found
4178 if ( info.window )
4179 return self->Insert(before, info.window, proportion, flag, border, data);
4180 else if ( info.sizer )
4181 return self->Insert(before, info.sizer, proportion, flag, border, data);
4182 else if (info.gotSize)
4183 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4184 proportion, flag, border, data);
4185 else
4186 return NULL;
4187 }
4188 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4189
4190 wxPyUserData* data = NULL;
4191 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4192 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4193 if ( userData && (info.window || info.sizer || info.gotSize) )
4194 data = new wxPyUserData(userData);
4195 if ( info.sizer )
4196 PyObject_SetAttrString(item,"thisown",Py_False);
4197 wxPyEndBlockThreads(blocked);
4198
4199 // Now call the real Prepend method if a valid item type was found
4200 if ( info.window )
4201 return self->Prepend(info.window, proportion, flag, border, data);
4202 else if ( info.sizer )
4203 return self->Prepend(info.sizer, proportion, flag, border, data);
4204 else if (info.gotSize)
4205 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4206 proportion, flag, border, data);
4207 else
4208 return NULL;
4209 }
4210 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4211 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4212 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4213 wxPyEndBlockThreads(blocked);
4214 if ( info.window )
4215 return self->Remove(info.window);
4216 else if ( info.sizer )
4217 return self->Remove(info.sizer);
4218 else if ( info.gotPos )
4219 return self->Remove(info.pos);
4220 else
4221 return false;
4222 }
4223 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4224 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4225 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4226 wxPyEndBlockThreads(blocked);
4227 if ( info.window )
4228 return self->Detach(info.window);
4229 else if ( info.sizer )
4230 return self->Detach(info.sizer);
4231 else if ( info.gotPos )
4232 return self->Detach(info.pos);
4233 else
4234 return false;
4235 }
4236 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4237 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4238 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4239 wxPyEndBlockThreads(blocked);
4240 if ( info.window )
4241 return self->GetItem(info.window);
4242 else if ( info.sizer )
4243 return self->GetItem(info.sizer);
4244 else if ( info.gotPos )
4245 return self->GetItem(info.pos);
4246 else
4247 return NULL;
4248 }
4249 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4250 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4251 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4252 wxPyEndBlockThreads(blocked);
4253 if ( info.window )
4254 self->SetItemMinSize(info.window, size);
4255 else if ( info.sizer )
4256 self->SetItemMinSize(info.sizer, size);
4257 else if ( info.gotPos )
4258 self->SetItemMinSize(info.pos, size);
4259 }
4260 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4261 wxSizerItemList& list = self->GetChildren();
4262 return wxPy_ConvertList(&list);
4263 }
4264 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4265 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4266 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4267 wxPyEndBlockThreads(blocked);
4268 if ( info.window )
4269 return self->Show(info.window, show, recursive);
4270 else if ( info.sizer )
4271 return self->Show(info.sizer, show, recursive);
4272 else if ( info.gotPos )
4273 return self->Show(info.pos, show);
4274 else
4275 return false;
4276 }
4277 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4278 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4279 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4280 wxPyEndBlockThreads(blocked);
4281 if ( info.window )
4282 return self->IsShown(info.window);
4283 else if ( info.sizer )
4284 return self->IsShown(info.sizer);
4285 else if ( info.gotPos )
4286 return self->IsShown(info.pos);
4287 else
4288 return false;
4289 }
4290
4291 // See pyclasses.h
4292 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4293 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4294 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4295
4296
4297
4298
4299 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4300 {
4301 if (source == Py_None) {
4302 **obj = wxGBPosition(-1,-1);
4303 return true;
4304 }
4305 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4306 }
4307
4308 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4309 {
4310 if (source == Py_None) {
4311 **obj = wxGBSpan(-1,-1);
4312 return true;
4313 }
4314 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4315 }
4316
4317
4318 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4319 wxGBPosition temp, *obj = &temp;
4320 if ( other == Py_None ) return false;
4321 if ( ! wxGBPosition_helper(other, &obj) ) {
4322 PyErr_Clear();
4323 return false;
4324 }
4325 return self->operator==(*obj);
4326 }
4327 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4328 wxGBPosition temp, *obj = &temp;
4329 if ( other == Py_None ) return true;
4330 if ( ! wxGBPosition_helper(other, &obj)) {
4331 PyErr_Clear();
4332 return true;
4333 }
4334 return self->operator!=(*obj);
4335 }
4336 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4337 self->SetRow(row);
4338 self->SetCol(col);
4339 }
4340 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4341 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4342 PyObject* tup = PyTuple_New(2);
4343 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4344 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4345 wxPyEndBlockThreads(blocked);
4346 return tup;
4347 }
4348 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4349 wxGBSpan temp, *obj = &temp;
4350 if ( other == Py_None ) return false;
4351 if ( ! wxGBSpan_helper(other, &obj) ) {
4352 PyErr_Clear();
4353 return false;
4354 }
4355 return self->operator==(*obj);
4356 }
4357 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4358 wxGBSpan temp, *obj = &temp;
4359 if ( other == Py_None ) return true;
4360 if ( ! wxGBSpan_helper(other, &obj)) {
4361 PyErr_Clear();
4362 return true;
4363 }
4364 return self->operator!=(*obj);
4365 }
4366 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4367 self->SetRowspan(rowspan);
4368 self->SetColspan(colspan);
4369 }
4370 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4371 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4372 PyObject* tup = PyTuple_New(2);
4373 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4374 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4375 wxPyEndBlockThreads(blocked);
4376 return tup;
4377 }
4378 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4379 wxPyUserData* data = NULL;
4380 if ( userData ) {
4381 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4382 data = new wxPyUserData(userData);
4383 wxPyEndBlockThreads(blocked);
4384 }
4385 return new wxGBSizerItem(window, pos, span, flag, border, data);
4386 }
4387 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4388 wxPyUserData* data = NULL;
4389 if ( userData ) {
4390 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4391 data = new wxPyUserData(userData);
4392 wxPyEndBlockThreads(blocked);
4393 }
4394 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4395 }
4396 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4397 wxPyUserData* data = NULL;
4398 if ( userData ) {
4399 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4400 data = new wxPyUserData(userData);
4401 wxPyEndBlockThreads(blocked);
4402 }
4403 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4404 }
4405 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4406 int row, col;
4407 self->GetEndPos(row, col);
4408 return wxGBPosition(row, col);
4409 }
4410 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4411
4412 wxPyUserData* data = NULL;
4413 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4414 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4415 if ( userData && (info.window || info.sizer || info.gotSize) )
4416 data = new wxPyUserData(userData);
4417 if ( info.sizer )
4418 PyObject_SetAttrString(item,"thisown",Py_False);
4419 wxPyEndBlockThreads(blocked);
4420
4421 // Now call the real Add method if a valid item type was found
4422 if ( info.window )
4423 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4424 else if ( info.sizer )
4425 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4426 else if (info.gotSize)
4427 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4428 pos, span, flag, border, data);
4429 return NULL;
4430 }
4431
4432
4433 #ifdef __cplusplus
4434 extern "C" {
4435 #endif
4436 SWIGINTERN int EmptyString_set(PyObject *) {
4437 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4438 return 1;
4439 }
4440
4441
4442 SWIGINTERN PyObject *EmptyString_get(void) {
4443 PyObject *pyobj = 0;
4444
4445 {
4446 #if wxUSE_UNICODE
4447 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4448 #else
4449 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4450 #endif
4451 }
4452 return pyobj;
4453 }
4454
4455
4456 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4457 PyObject *resultobj = 0;
4458 wxObject *arg1 = (wxObject *) 0 ;
4459 wxString result;
4460 void *argp1 = 0 ;
4461 int res1 = 0 ;
4462 PyObject *swig_obj[1] ;
4463
4464 if (!args) SWIG_fail;
4465 swig_obj[0] = args;
4466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4467 if (!SWIG_IsOK(res1)) {
4468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4469 }
4470 arg1 = reinterpret_cast< wxObject * >(argp1);
4471 {
4472 PyThreadState* __tstate = wxPyBeginAllowThreads();
4473 result = wxObject_GetClassName(arg1);
4474 wxPyEndAllowThreads(__tstate);
4475 if (PyErr_Occurred()) SWIG_fail;
4476 }
4477 {
4478 #if wxUSE_UNICODE
4479 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4480 #else
4481 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4482 #endif
4483 }
4484 return resultobj;
4485 fail:
4486 return NULL;
4487 }
4488
4489
4490 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4491 PyObject *resultobj = 0;
4492 wxObject *arg1 = (wxObject *) 0 ;
4493 void *argp1 = 0 ;
4494 int res1 = 0 ;
4495 PyObject *swig_obj[1] ;
4496
4497 if (!args) SWIG_fail;
4498 swig_obj[0] = args;
4499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4500 if (!SWIG_IsOK(res1)) {
4501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4502 }
4503 arg1 = reinterpret_cast< wxObject * >(argp1);
4504 {
4505 PyThreadState* __tstate = wxPyBeginAllowThreads();
4506 wxObject_Destroy(arg1);
4507 wxPyEndAllowThreads(__tstate);
4508 if (PyErr_Occurred()) SWIG_fail;
4509 }
4510 resultobj = SWIG_Py_Void();
4511 return resultobj;
4512 fail:
4513 return NULL;
4514 }
4515
4516
4517 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4518 PyObject *resultobj = 0;
4519 wxObject *arg1 = (wxObject *) 0 ;
4520 wxObject *arg2 = 0 ;
4521 bool result;
4522 void *argp1 = 0 ;
4523 int res1 = 0 ;
4524 void *argp2 = 0 ;
4525 int res2 = 0 ;
4526 PyObject * obj0 = 0 ;
4527 PyObject * obj1 = 0 ;
4528 char * kwnames[] = {
4529 (char *) "self",(char *) "p", NULL
4530 };
4531
4532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4534 if (!SWIG_IsOK(res1)) {
4535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4536 }
4537 arg1 = reinterpret_cast< wxObject * >(argp1);
4538 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4539 if (!SWIG_IsOK(res2)) {
4540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4541 }
4542 if (!argp2) {
4543 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4544 }
4545 arg2 = reinterpret_cast< wxObject * >(argp2);
4546 {
4547 PyThreadState* __tstate = wxPyBeginAllowThreads();
4548 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4549 wxPyEndAllowThreads(__tstate);
4550 if (PyErr_Occurred()) SWIG_fail;
4551 }
4552 {
4553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4554 }
4555 return resultobj;
4556 fail:
4557 return NULL;
4558 }
4559
4560
4561 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4562 PyObject *obj;
4563 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4564 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4565 return SWIG_Py_Void();
4566 }
4567
4568 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4569 PyObject *resultobj = 0;
4570 wxSize *arg1 = (wxSize *) 0 ;
4571 int arg2 ;
4572 void *argp1 = 0 ;
4573 int res1 = 0 ;
4574 int val2 ;
4575 int ecode2 = 0 ;
4576 PyObject *swig_obj[2] ;
4577
4578 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4580 if (!SWIG_IsOK(res1)) {
4581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4582 }
4583 arg1 = reinterpret_cast< wxSize * >(argp1);
4584 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4585 if (!SWIG_IsOK(ecode2)) {
4586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4587 }
4588 arg2 = static_cast< int >(val2);
4589 if (arg1) (arg1)->x = arg2;
4590
4591 resultobj = SWIG_Py_Void();
4592 return resultobj;
4593 fail:
4594 return NULL;
4595 }
4596
4597
4598 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4599 PyObject *resultobj = 0;
4600 wxSize *arg1 = (wxSize *) 0 ;
4601 int result;
4602 void *argp1 = 0 ;
4603 int res1 = 0 ;
4604 PyObject *swig_obj[1] ;
4605
4606 if (!args) SWIG_fail;
4607 swig_obj[0] = args;
4608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4609 if (!SWIG_IsOK(res1)) {
4610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4611 }
4612 arg1 = reinterpret_cast< wxSize * >(argp1);
4613 result = (int) ((arg1)->x);
4614 resultobj = SWIG_From_int(static_cast< int >(result));
4615 return resultobj;
4616 fail:
4617 return NULL;
4618 }
4619
4620
4621 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4622 PyObject *resultobj = 0;
4623 wxSize *arg1 = (wxSize *) 0 ;
4624 int arg2 ;
4625 void *argp1 = 0 ;
4626 int res1 = 0 ;
4627 int val2 ;
4628 int ecode2 = 0 ;
4629 PyObject *swig_obj[2] ;
4630
4631 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4633 if (!SWIG_IsOK(res1)) {
4634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4635 }
4636 arg1 = reinterpret_cast< wxSize * >(argp1);
4637 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4638 if (!SWIG_IsOK(ecode2)) {
4639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4640 }
4641 arg2 = static_cast< int >(val2);
4642 if (arg1) (arg1)->y = arg2;
4643
4644 resultobj = SWIG_Py_Void();
4645 return resultobj;
4646 fail:
4647 return NULL;
4648 }
4649
4650
4651 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4652 PyObject *resultobj = 0;
4653 wxSize *arg1 = (wxSize *) 0 ;
4654 int result;
4655 void *argp1 = 0 ;
4656 int res1 = 0 ;
4657 PyObject *swig_obj[1] ;
4658
4659 if (!args) SWIG_fail;
4660 swig_obj[0] = args;
4661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4662 if (!SWIG_IsOK(res1)) {
4663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4664 }
4665 arg1 = reinterpret_cast< wxSize * >(argp1);
4666 result = (int) ((arg1)->y);
4667 resultobj = SWIG_From_int(static_cast< int >(result));
4668 return resultobj;
4669 fail:
4670 return NULL;
4671 }
4672
4673
4674 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4675 PyObject *resultobj = 0;
4676 int arg1 = (int) 0 ;
4677 int arg2 = (int) 0 ;
4678 wxSize *result = 0 ;
4679 int val1 ;
4680 int ecode1 = 0 ;
4681 int val2 ;
4682 int ecode2 = 0 ;
4683 PyObject * obj0 = 0 ;
4684 PyObject * obj1 = 0 ;
4685 char * kwnames[] = {
4686 (char *) "w",(char *) "h", NULL
4687 };
4688
4689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4690 if (obj0) {
4691 ecode1 = SWIG_AsVal_int(obj0, &val1);
4692 if (!SWIG_IsOK(ecode1)) {
4693 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4694 }
4695 arg1 = static_cast< int >(val1);
4696 }
4697 if (obj1) {
4698 ecode2 = SWIG_AsVal_int(obj1, &val2);
4699 if (!SWIG_IsOK(ecode2)) {
4700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4701 }
4702 arg2 = static_cast< int >(val2);
4703 }
4704 {
4705 result = (wxSize *)new wxSize(arg1,arg2);
4706 if (PyErr_Occurred()) SWIG_fail;
4707 }
4708 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4709 return resultobj;
4710 fail:
4711 return NULL;
4712 }
4713
4714
4715 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4716 PyObject *resultobj = 0;
4717 wxSize *arg1 = (wxSize *) 0 ;
4718 void *argp1 = 0 ;
4719 int res1 = 0 ;
4720 PyObject *swig_obj[1] ;
4721
4722 if (!args) SWIG_fail;
4723 swig_obj[0] = args;
4724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4725 if (!SWIG_IsOK(res1)) {
4726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4727 }
4728 arg1 = reinterpret_cast< wxSize * >(argp1);
4729 {
4730 delete arg1;
4731
4732 if (PyErr_Occurred()) SWIG_fail;
4733 }
4734 resultobj = SWIG_Py_Void();
4735 return resultobj;
4736 fail:
4737 return NULL;
4738 }
4739
4740
4741 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4742 PyObject *resultobj = 0;
4743 wxSize *arg1 = (wxSize *) 0 ;
4744 PyObject *arg2 = (PyObject *) 0 ;
4745 bool result;
4746 void *argp1 = 0 ;
4747 int res1 = 0 ;
4748 PyObject * obj0 = 0 ;
4749 PyObject * obj1 = 0 ;
4750 char * kwnames[] = {
4751 (char *) "self",(char *) "other", NULL
4752 };
4753
4754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4756 if (!SWIG_IsOK(res1)) {
4757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4758 }
4759 arg1 = reinterpret_cast< wxSize * >(argp1);
4760 arg2 = obj1;
4761 {
4762 result = (bool)wxSize___eq__(arg1,arg2);
4763 if (PyErr_Occurred()) SWIG_fail;
4764 }
4765 {
4766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4767 }
4768 return resultobj;
4769 fail:
4770 return NULL;
4771 }
4772
4773
4774 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4775 PyObject *resultobj = 0;
4776 wxSize *arg1 = (wxSize *) 0 ;
4777 PyObject *arg2 = (PyObject *) 0 ;
4778 bool result;
4779 void *argp1 = 0 ;
4780 int res1 = 0 ;
4781 PyObject * obj0 = 0 ;
4782 PyObject * obj1 = 0 ;
4783 char * kwnames[] = {
4784 (char *) "self",(char *) "other", NULL
4785 };
4786
4787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4789 if (!SWIG_IsOK(res1)) {
4790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4791 }
4792 arg1 = reinterpret_cast< wxSize * >(argp1);
4793 arg2 = obj1;
4794 {
4795 result = (bool)wxSize___ne__(arg1,arg2);
4796 if (PyErr_Occurred()) SWIG_fail;
4797 }
4798 {
4799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4800 }
4801 return resultobj;
4802 fail:
4803 return NULL;
4804 }
4805
4806
4807 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4808 PyObject *resultobj = 0;
4809 wxSize *arg1 = (wxSize *) 0 ;
4810 wxSize *arg2 = 0 ;
4811 wxSize result;
4812 void *argp1 = 0 ;
4813 int res1 = 0 ;
4814 wxSize temp2 ;
4815 PyObject * obj0 = 0 ;
4816 PyObject * obj1 = 0 ;
4817 char * kwnames[] = {
4818 (char *) "self",(char *) "sz", NULL
4819 };
4820
4821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4823 if (!SWIG_IsOK(res1)) {
4824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4825 }
4826 arg1 = reinterpret_cast< wxSize * >(argp1);
4827 {
4828 arg2 = &temp2;
4829 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4830 }
4831 {
4832 result = (arg1)->operator +((wxSize const &)*arg2);
4833 if (PyErr_Occurred()) SWIG_fail;
4834 }
4835 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4836 return resultobj;
4837 fail:
4838 return NULL;
4839 }
4840
4841
4842 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4843 PyObject *resultobj = 0;
4844 wxSize *arg1 = (wxSize *) 0 ;
4845 wxSize *arg2 = 0 ;
4846 wxSize result;
4847 void *argp1 = 0 ;
4848 int res1 = 0 ;
4849 wxSize temp2 ;
4850 PyObject * obj0 = 0 ;
4851 PyObject * obj1 = 0 ;
4852 char * kwnames[] = {
4853 (char *) "self",(char *) "sz", NULL
4854 };
4855
4856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4858 if (!SWIG_IsOK(res1)) {
4859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4860 }
4861 arg1 = reinterpret_cast< wxSize * >(argp1);
4862 {
4863 arg2 = &temp2;
4864 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4865 }
4866 {
4867 result = (arg1)->operator -((wxSize const &)*arg2);
4868 if (PyErr_Occurred()) SWIG_fail;
4869 }
4870 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4871 return resultobj;
4872 fail:
4873 return NULL;
4874 }
4875
4876
4877 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4878 PyObject *resultobj = 0;
4879 wxSize *arg1 = (wxSize *) 0 ;
4880 wxSize *arg2 = 0 ;
4881 void *argp1 = 0 ;
4882 int res1 = 0 ;
4883 wxSize temp2 ;
4884 PyObject * obj0 = 0 ;
4885 PyObject * obj1 = 0 ;
4886 char * kwnames[] = {
4887 (char *) "self",(char *) "sz", NULL
4888 };
4889
4890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) 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_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4894 }
4895 arg1 = reinterpret_cast< wxSize * >(argp1);
4896 {
4897 arg2 = &temp2;
4898 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4899 }
4900 {
4901 (arg1)->IncTo((wxSize const &)*arg2);
4902 if (PyErr_Occurred()) SWIG_fail;
4903 }
4904 resultobj = SWIG_Py_Void();
4905 return resultobj;
4906 fail:
4907 return NULL;
4908 }
4909
4910
4911 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4912 PyObject *resultobj = 0;
4913 wxSize *arg1 = (wxSize *) 0 ;
4914 wxSize *arg2 = 0 ;
4915 void *argp1 = 0 ;
4916 int res1 = 0 ;
4917 wxSize temp2 ;
4918 PyObject * obj0 = 0 ;
4919 PyObject * obj1 = 0 ;
4920 char * kwnames[] = {
4921 (char *) "self",(char *) "sz", NULL
4922 };
4923
4924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4926 if (!SWIG_IsOK(res1)) {
4927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4928 }
4929 arg1 = reinterpret_cast< wxSize * >(argp1);
4930 {
4931 arg2 = &temp2;
4932 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4933 }
4934 {
4935 (arg1)->DecTo((wxSize const &)*arg2);
4936 if (PyErr_Occurred()) SWIG_fail;
4937 }
4938 resultobj = SWIG_Py_Void();
4939 return resultobj;
4940 fail:
4941 return NULL;
4942 }
4943
4944
4945 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4946 PyObject *resultobj = 0;
4947 wxSize *arg1 = (wxSize *) 0 ;
4948 int arg2 ;
4949 int arg3 ;
4950 void *argp1 = 0 ;
4951 int res1 = 0 ;
4952 int val2 ;
4953 int ecode2 = 0 ;
4954 int val3 ;
4955 int ecode3 = 0 ;
4956 PyObject * obj0 = 0 ;
4957 PyObject * obj1 = 0 ;
4958 PyObject * obj2 = 0 ;
4959 char * kwnames[] = {
4960 (char *) "self",(char *) "dx",(char *) "dy", NULL
4961 };
4962
4963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4965 if (!SWIG_IsOK(res1)) {
4966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4967 }
4968 arg1 = reinterpret_cast< wxSize * >(argp1);
4969 ecode2 = SWIG_AsVal_int(obj1, &val2);
4970 if (!SWIG_IsOK(ecode2)) {
4971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4972 }
4973 arg2 = static_cast< int >(val2);
4974 ecode3 = SWIG_AsVal_int(obj2, &val3);
4975 if (!SWIG_IsOK(ecode3)) {
4976 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4977 }
4978 arg3 = static_cast< int >(val3);
4979 {
4980 (arg1)->IncBy(arg2,arg3);
4981 if (PyErr_Occurred()) SWIG_fail;
4982 }
4983 resultobj = SWIG_Py_Void();
4984 return resultobj;
4985 fail:
4986 return NULL;
4987 }
4988
4989
4990 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4991 PyObject *resultobj = 0;
4992 wxSize *arg1 = (wxSize *) 0 ;
4993 int arg2 ;
4994 int arg3 ;
4995 void *argp1 = 0 ;
4996 int res1 = 0 ;
4997 int val2 ;
4998 int ecode2 = 0 ;
4999 int val3 ;
5000 int ecode3 = 0 ;
5001 PyObject * obj0 = 0 ;
5002 PyObject * obj1 = 0 ;
5003 PyObject * obj2 = 0 ;
5004 char * kwnames[] = {
5005 (char *) "self",(char *) "dx",(char *) "dy", NULL
5006 };
5007
5008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5010 if (!SWIG_IsOK(res1)) {
5011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
5012 }
5013 arg1 = reinterpret_cast< wxSize * >(argp1);
5014 ecode2 = SWIG_AsVal_int(obj1, &val2);
5015 if (!SWIG_IsOK(ecode2)) {
5016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5017 }
5018 arg2 = static_cast< int >(val2);
5019 ecode3 = SWIG_AsVal_int(obj2, &val3);
5020 if (!SWIG_IsOK(ecode3)) {
5021 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5022 }
5023 arg3 = static_cast< int >(val3);
5024 {
5025 (arg1)->DecBy(arg2,arg3);
5026 if (PyErr_Occurred()) SWIG_fail;
5027 }
5028 resultobj = SWIG_Py_Void();
5029 return resultobj;
5030 fail:
5031 return NULL;
5032 }
5033
5034
5035 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5036 PyObject *resultobj = 0;
5037 wxSize *arg1 = (wxSize *) 0 ;
5038 float arg2 ;
5039 float arg3 ;
5040 void *argp1 = 0 ;
5041 int res1 = 0 ;
5042 float val2 ;
5043 int ecode2 = 0 ;
5044 float val3 ;
5045 int ecode3 = 0 ;
5046 PyObject * obj0 = 0 ;
5047 PyObject * obj1 = 0 ;
5048 PyObject * obj2 = 0 ;
5049 char * kwnames[] = {
5050 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5051 };
5052
5053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5055 if (!SWIG_IsOK(res1)) {
5056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5057 }
5058 arg1 = reinterpret_cast< wxSize * >(argp1);
5059 ecode2 = SWIG_AsVal_float(obj1, &val2);
5060 if (!SWIG_IsOK(ecode2)) {
5061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5062 }
5063 arg2 = static_cast< float >(val2);
5064 ecode3 = SWIG_AsVal_float(obj2, &val3);
5065 if (!SWIG_IsOK(ecode3)) {
5066 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5067 }
5068 arg3 = static_cast< float >(val3);
5069 {
5070 (arg1)->Scale(arg2,arg3);
5071 if (PyErr_Occurred()) SWIG_fail;
5072 }
5073 resultobj = SWIG_Py_Void();
5074 return resultobj;
5075 fail:
5076 return NULL;
5077 }
5078
5079
5080 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5081 PyObject *resultobj = 0;
5082 wxSize *arg1 = (wxSize *) 0 ;
5083 int arg2 ;
5084 int arg3 ;
5085 void *argp1 = 0 ;
5086 int res1 = 0 ;
5087 int val2 ;
5088 int ecode2 = 0 ;
5089 int val3 ;
5090 int ecode3 = 0 ;
5091 PyObject * obj0 = 0 ;
5092 PyObject * obj1 = 0 ;
5093 PyObject * obj2 = 0 ;
5094 char * kwnames[] = {
5095 (char *) "self",(char *) "w",(char *) "h", NULL
5096 };
5097
5098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5100 if (!SWIG_IsOK(res1)) {
5101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5102 }
5103 arg1 = reinterpret_cast< wxSize * >(argp1);
5104 ecode2 = SWIG_AsVal_int(obj1, &val2);
5105 if (!SWIG_IsOK(ecode2)) {
5106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5107 }
5108 arg2 = static_cast< int >(val2);
5109 ecode3 = SWIG_AsVal_int(obj2, &val3);
5110 if (!SWIG_IsOK(ecode3)) {
5111 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5112 }
5113 arg3 = static_cast< int >(val3);
5114 {
5115 (arg1)->Set(arg2,arg3);
5116 if (PyErr_Occurred()) SWIG_fail;
5117 }
5118 resultobj = SWIG_Py_Void();
5119 return resultobj;
5120 fail:
5121 return NULL;
5122 }
5123
5124
5125 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5126 PyObject *resultobj = 0;
5127 wxSize *arg1 = (wxSize *) 0 ;
5128 int arg2 ;
5129 void *argp1 = 0 ;
5130 int res1 = 0 ;
5131 int val2 ;
5132 int ecode2 = 0 ;
5133 PyObject * obj0 = 0 ;
5134 PyObject * obj1 = 0 ;
5135 char * kwnames[] = {
5136 (char *) "self",(char *) "w", NULL
5137 };
5138
5139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5141 if (!SWIG_IsOK(res1)) {
5142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5143 }
5144 arg1 = reinterpret_cast< wxSize * >(argp1);
5145 ecode2 = SWIG_AsVal_int(obj1, &val2);
5146 if (!SWIG_IsOK(ecode2)) {
5147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5148 }
5149 arg2 = static_cast< int >(val2);
5150 {
5151 (arg1)->SetWidth(arg2);
5152 if (PyErr_Occurred()) SWIG_fail;
5153 }
5154 resultobj = SWIG_Py_Void();
5155 return resultobj;
5156 fail:
5157 return NULL;
5158 }
5159
5160
5161 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5162 PyObject *resultobj = 0;
5163 wxSize *arg1 = (wxSize *) 0 ;
5164 int arg2 ;
5165 void *argp1 = 0 ;
5166 int res1 = 0 ;
5167 int val2 ;
5168 int ecode2 = 0 ;
5169 PyObject * obj0 = 0 ;
5170 PyObject * obj1 = 0 ;
5171 char * kwnames[] = {
5172 (char *) "self",(char *) "h", NULL
5173 };
5174
5175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5177 if (!SWIG_IsOK(res1)) {
5178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5179 }
5180 arg1 = reinterpret_cast< wxSize * >(argp1);
5181 ecode2 = SWIG_AsVal_int(obj1, &val2);
5182 if (!SWIG_IsOK(ecode2)) {
5183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5184 }
5185 arg2 = static_cast< int >(val2);
5186 {
5187 (arg1)->SetHeight(arg2);
5188 if (PyErr_Occurred()) SWIG_fail;
5189 }
5190 resultobj = SWIG_Py_Void();
5191 return resultobj;
5192 fail:
5193 return NULL;
5194 }
5195
5196
5197 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5198 PyObject *resultobj = 0;
5199 wxSize *arg1 = (wxSize *) 0 ;
5200 int result;
5201 void *argp1 = 0 ;
5202 int res1 = 0 ;
5203 PyObject *swig_obj[1] ;
5204
5205 if (!args) SWIG_fail;
5206 swig_obj[0] = args;
5207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5208 if (!SWIG_IsOK(res1)) {
5209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5210 }
5211 arg1 = reinterpret_cast< wxSize * >(argp1);
5212 {
5213 result = (int)((wxSize const *)arg1)->GetWidth();
5214 if (PyErr_Occurred()) SWIG_fail;
5215 }
5216 resultobj = SWIG_From_int(static_cast< int >(result));
5217 return resultobj;
5218 fail:
5219 return NULL;
5220 }
5221
5222
5223 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5224 PyObject *resultobj = 0;
5225 wxSize *arg1 = (wxSize *) 0 ;
5226 int result;
5227 void *argp1 = 0 ;
5228 int res1 = 0 ;
5229 PyObject *swig_obj[1] ;
5230
5231 if (!args) SWIG_fail;
5232 swig_obj[0] = args;
5233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5234 if (!SWIG_IsOK(res1)) {
5235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5236 }
5237 arg1 = reinterpret_cast< wxSize * >(argp1);
5238 {
5239 result = (int)((wxSize const *)arg1)->GetHeight();
5240 if (PyErr_Occurred()) SWIG_fail;
5241 }
5242 resultobj = SWIG_From_int(static_cast< int >(result));
5243 return resultobj;
5244 fail:
5245 return NULL;
5246 }
5247
5248
5249 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5250 PyObject *resultobj = 0;
5251 wxSize *arg1 = (wxSize *) 0 ;
5252 bool result;
5253 void *argp1 = 0 ;
5254 int res1 = 0 ;
5255 PyObject *swig_obj[1] ;
5256
5257 if (!args) SWIG_fail;
5258 swig_obj[0] = args;
5259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5260 if (!SWIG_IsOK(res1)) {
5261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5262 }
5263 arg1 = reinterpret_cast< wxSize * >(argp1);
5264 {
5265 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5266 if (PyErr_Occurred()) SWIG_fail;
5267 }
5268 {
5269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5270 }
5271 return resultobj;
5272 fail:
5273 return NULL;
5274 }
5275
5276
5277 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5278 PyObject *resultobj = 0;
5279 wxSize *arg1 = (wxSize *) 0 ;
5280 wxSize *arg2 = 0 ;
5281 void *argp1 = 0 ;
5282 int res1 = 0 ;
5283 wxSize temp2 ;
5284 PyObject * obj0 = 0 ;
5285 PyObject * obj1 = 0 ;
5286 char * kwnames[] = {
5287 (char *) "self",(char *) "size", NULL
5288 };
5289
5290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5292 if (!SWIG_IsOK(res1)) {
5293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5294 }
5295 arg1 = reinterpret_cast< wxSize * >(argp1);
5296 {
5297 arg2 = &temp2;
5298 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5299 }
5300 {
5301 (arg1)->SetDefaults((wxSize const &)*arg2);
5302 if (PyErr_Occurred()) SWIG_fail;
5303 }
5304 resultobj = SWIG_Py_Void();
5305 return resultobj;
5306 fail:
5307 return NULL;
5308 }
5309
5310
5311 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5312 PyObject *resultobj = 0;
5313 wxSize *arg1 = (wxSize *) 0 ;
5314 PyObject *result = 0 ;
5315 void *argp1 = 0 ;
5316 int res1 = 0 ;
5317 PyObject *swig_obj[1] ;
5318
5319 if (!args) SWIG_fail;
5320 swig_obj[0] = args;
5321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5322 if (!SWIG_IsOK(res1)) {
5323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5324 }
5325 arg1 = reinterpret_cast< wxSize * >(argp1);
5326 {
5327 result = (PyObject *)wxSize_Get(arg1);
5328 if (PyErr_Occurred()) SWIG_fail;
5329 }
5330 resultobj = result;
5331 return resultobj;
5332 fail:
5333 return NULL;
5334 }
5335
5336
5337 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5338 PyObject *obj;
5339 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5340 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5341 return SWIG_Py_Void();
5342 }
5343
5344 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5345 return SWIG_Python_InitShadowInstance(args);
5346 }
5347
5348 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5349 PyObject *resultobj = 0;
5350 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5351 double arg2 ;
5352 void *argp1 = 0 ;
5353 int res1 = 0 ;
5354 double val2 ;
5355 int ecode2 = 0 ;
5356 PyObject *swig_obj[2] ;
5357
5358 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5360 if (!SWIG_IsOK(res1)) {
5361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5362 }
5363 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5364 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5365 if (!SWIG_IsOK(ecode2)) {
5366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5367 }
5368 arg2 = static_cast< double >(val2);
5369 if (arg1) (arg1)->x = arg2;
5370
5371 resultobj = SWIG_Py_Void();
5372 return resultobj;
5373 fail:
5374 return NULL;
5375 }
5376
5377
5378 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5379 PyObject *resultobj = 0;
5380 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5381 double result;
5382 void *argp1 = 0 ;
5383 int res1 = 0 ;
5384 PyObject *swig_obj[1] ;
5385
5386 if (!args) SWIG_fail;
5387 swig_obj[0] = args;
5388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5389 if (!SWIG_IsOK(res1)) {
5390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5391 }
5392 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5393 result = (double) ((arg1)->x);
5394 resultobj = SWIG_From_double(static_cast< double >(result));
5395 return resultobj;
5396 fail:
5397 return NULL;
5398 }
5399
5400
5401 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5402 PyObject *resultobj = 0;
5403 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5404 double arg2 ;
5405 void *argp1 = 0 ;
5406 int res1 = 0 ;
5407 double val2 ;
5408 int ecode2 = 0 ;
5409 PyObject *swig_obj[2] ;
5410
5411 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5413 if (!SWIG_IsOK(res1)) {
5414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5415 }
5416 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5417 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5418 if (!SWIG_IsOK(ecode2)) {
5419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5420 }
5421 arg2 = static_cast< double >(val2);
5422 if (arg1) (arg1)->y = arg2;
5423
5424 resultobj = SWIG_Py_Void();
5425 return resultobj;
5426 fail:
5427 return NULL;
5428 }
5429
5430
5431 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5432 PyObject *resultobj = 0;
5433 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5434 double result;
5435 void *argp1 = 0 ;
5436 int res1 = 0 ;
5437 PyObject *swig_obj[1] ;
5438
5439 if (!args) SWIG_fail;
5440 swig_obj[0] = args;
5441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5442 if (!SWIG_IsOK(res1)) {
5443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5444 }
5445 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5446 result = (double) ((arg1)->y);
5447 resultobj = SWIG_From_double(static_cast< double >(result));
5448 return resultobj;
5449 fail:
5450 return NULL;
5451 }
5452
5453
5454 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5455 PyObject *resultobj = 0;
5456 double arg1 = (double) 0.0 ;
5457 double arg2 = (double) 0.0 ;
5458 wxRealPoint *result = 0 ;
5459 double val1 ;
5460 int ecode1 = 0 ;
5461 double val2 ;
5462 int ecode2 = 0 ;
5463 PyObject * obj0 = 0 ;
5464 PyObject * obj1 = 0 ;
5465 char * kwnames[] = {
5466 (char *) "x",(char *) "y", NULL
5467 };
5468
5469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5470 if (obj0) {
5471 ecode1 = SWIG_AsVal_double(obj0, &val1);
5472 if (!SWIG_IsOK(ecode1)) {
5473 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5474 }
5475 arg1 = static_cast< double >(val1);
5476 }
5477 if (obj1) {
5478 ecode2 = SWIG_AsVal_double(obj1, &val2);
5479 if (!SWIG_IsOK(ecode2)) {
5480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5481 }
5482 arg2 = static_cast< double >(val2);
5483 }
5484 {
5485 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5486 if (PyErr_Occurred()) SWIG_fail;
5487 }
5488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5489 return resultobj;
5490 fail:
5491 return NULL;
5492 }
5493
5494
5495 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5496 PyObject *resultobj = 0;
5497 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5498 void *argp1 = 0 ;
5499 int res1 = 0 ;
5500 PyObject *swig_obj[1] ;
5501
5502 if (!args) SWIG_fail;
5503 swig_obj[0] = args;
5504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5505 if (!SWIG_IsOK(res1)) {
5506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5507 }
5508 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5509 {
5510 delete arg1;
5511
5512 if (PyErr_Occurred()) SWIG_fail;
5513 }
5514 resultobj = SWIG_Py_Void();
5515 return resultobj;
5516 fail:
5517 return NULL;
5518 }
5519
5520
5521 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5522 PyObject *resultobj = 0;
5523 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5524 PyObject *arg2 = (PyObject *) 0 ;
5525 bool result;
5526 void *argp1 = 0 ;
5527 int res1 = 0 ;
5528 PyObject * obj0 = 0 ;
5529 PyObject * obj1 = 0 ;
5530 char * kwnames[] = {
5531 (char *) "self",(char *) "other", NULL
5532 };
5533
5534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5536 if (!SWIG_IsOK(res1)) {
5537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5538 }
5539 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5540 arg2 = obj1;
5541 {
5542 result = (bool)wxRealPoint___eq__(arg1,arg2);
5543 if (PyErr_Occurred()) SWIG_fail;
5544 }
5545 {
5546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5547 }
5548 return resultobj;
5549 fail:
5550 return NULL;
5551 }
5552
5553
5554 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5555 PyObject *resultobj = 0;
5556 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5557 PyObject *arg2 = (PyObject *) 0 ;
5558 bool result;
5559 void *argp1 = 0 ;
5560 int res1 = 0 ;
5561 PyObject * obj0 = 0 ;
5562 PyObject * obj1 = 0 ;
5563 char * kwnames[] = {
5564 (char *) "self",(char *) "other", NULL
5565 };
5566
5567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5569 if (!SWIG_IsOK(res1)) {
5570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5571 }
5572 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5573 arg2 = obj1;
5574 {
5575 result = (bool)wxRealPoint___ne__(arg1,arg2);
5576 if (PyErr_Occurred()) SWIG_fail;
5577 }
5578 {
5579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5580 }
5581 return resultobj;
5582 fail:
5583 return NULL;
5584 }
5585
5586
5587 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5588 PyObject *resultobj = 0;
5589 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5590 wxRealPoint *arg2 = 0 ;
5591 wxRealPoint result;
5592 void *argp1 = 0 ;
5593 int res1 = 0 ;
5594 wxRealPoint temp2 ;
5595 PyObject * obj0 = 0 ;
5596 PyObject * obj1 = 0 ;
5597 char * kwnames[] = {
5598 (char *) "self",(char *) "pt", NULL
5599 };
5600
5601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5603 if (!SWIG_IsOK(res1)) {
5604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5605 }
5606 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5607 {
5608 arg2 = &temp2;
5609 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5610 }
5611 {
5612 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5613 if (PyErr_Occurred()) SWIG_fail;
5614 }
5615 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5616 return resultobj;
5617 fail:
5618 return NULL;
5619 }
5620
5621
5622 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5623 PyObject *resultobj = 0;
5624 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5625 wxRealPoint *arg2 = 0 ;
5626 wxRealPoint result;
5627 void *argp1 = 0 ;
5628 int res1 = 0 ;
5629 wxRealPoint temp2 ;
5630 PyObject * obj0 = 0 ;
5631 PyObject * obj1 = 0 ;
5632 char * kwnames[] = {
5633 (char *) "self",(char *) "pt", NULL
5634 };
5635
5636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5638 if (!SWIG_IsOK(res1)) {
5639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5640 }
5641 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5642 {
5643 arg2 = &temp2;
5644 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5645 }
5646 {
5647 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5648 if (PyErr_Occurred()) SWIG_fail;
5649 }
5650 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5651 return resultobj;
5652 fail:
5653 return NULL;
5654 }
5655
5656
5657 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5658 PyObject *resultobj = 0;
5659 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5660 double arg2 ;
5661 double arg3 ;
5662 void *argp1 = 0 ;
5663 int res1 = 0 ;
5664 double val2 ;
5665 int ecode2 = 0 ;
5666 double val3 ;
5667 int ecode3 = 0 ;
5668 PyObject * obj0 = 0 ;
5669 PyObject * obj1 = 0 ;
5670 PyObject * obj2 = 0 ;
5671 char * kwnames[] = {
5672 (char *) "self",(char *) "x",(char *) "y", NULL
5673 };
5674
5675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5677 if (!SWIG_IsOK(res1)) {
5678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5679 }
5680 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5681 ecode2 = SWIG_AsVal_double(obj1, &val2);
5682 if (!SWIG_IsOK(ecode2)) {
5683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5684 }
5685 arg2 = static_cast< double >(val2);
5686 ecode3 = SWIG_AsVal_double(obj2, &val3);
5687 if (!SWIG_IsOK(ecode3)) {
5688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5689 }
5690 arg3 = static_cast< double >(val3);
5691 {
5692 wxRealPoint_Set(arg1,arg2,arg3);
5693 if (PyErr_Occurred()) SWIG_fail;
5694 }
5695 resultobj = SWIG_Py_Void();
5696 return resultobj;
5697 fail:
5698 return NULL;
5699 }
5700
5701
5702 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5703 PyObject *resultobj = 0;
5704 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5705 PyObject *result = 0 ;
5706 void *argp1 = 0 ;
5707 int res1 = 0 ;
5708 PyObject *swig_obj[1] ;
5709
5710 if (!args) SWIG_fail;
5711 swig_obj[0] = args;
5712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5713 if (!SWIG_IsOK(res1)) {
5714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5715 }
5716 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5717 {
5718 result = (PyObject *)wxRealPoint_Get(arg1);
5719 if (PyErr_Occurred()) SWIG_fail;
5720 }
5721 resultobj = result;
5722 return resultobj;
5723 fail:
5724 return NULL;
5725 }
5726
5727
5728 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5729 PyObject *obj;
5730 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5731 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5732 return SWIG_Py_Void();
5733 }
5734
5735 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5736 return SWIG_Python_InitShadowInstance(args);
5737 }
5738
5739 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5740 PyObject *resultobj = 0;
5741 wxPoint *arg1 = (wxPoint *) 0 ;
5742 int arg2 ;
5743 void *argp1 = 0 ;
5744 int res1 = 0 ;
5745 int val2 ;
5746 int ecode2 = 0 ;
5747 PyObject *swig_obj[2] ;
5748
5749 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5751 if (!SWIG_IsOK(res1)) {
5752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5753 }
5754 arg1 = reinterpret_cast< wxPoint * >(argp1);
5755 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5756 if (!SWIG_IsOK(ecode2)) {
5757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5758 }
5759 arg2 = static_cast< int >(val2);
5760 if (arg1) (arg1)->x = arg2;
5761
5762 resultobj = SWIG_Py_Void();
5763 return resultobj;
5764 fail:
5765 return NULL;
5766 }
5767
5768
5769 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5770 PyObject *resultobj = 0;
5771 wxPoint *arg1 = (wxPoint *) 0 ;
5772 int result;
5773 void *argp1 = 0 ;
5774 int res1 = 0 ;
5775 PyObject *swig_obj[1] ;
5776
5777 if (!args) SWIG_fail;
5778 swig_obj[0] = args;
5779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5780 if (!SWIG_IsOK(res1)) {
5781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5782 }
5783 arg1 = reinterpret_cast< wxPoint * >(argp1);
5784 result = (int) ((arg1)->x);
5785 resultobj = SWIG_From_int(static_cast< int >(result));
5786 return resultobj;
5787 fail:
5788 return NULL;
5789 }
5790
5791
5792 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5793 PyObject *resultobj = 0;
5794 wxPoint *arg1 = (wxPoint *) 0 ;
5795 int arg2 ;
5796 void *argp1 = 0 ;
5797 int res1 = 0 ;
5798 int val2 ;
5799 int ecode2 = 0 ;
5800 PyObject *swig_obj[2] ;
5801
5802 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5804 if (!SWIG_IsOK(res1)) {
5805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5806 }
5807 arg1 = reinterpret_cast< wxPoint * >(argp1);
5808 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5809 if (!SWIG_IsOK(ecode2)) {
5810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5811 }
5812 arg2 = static_cast< int >(val2);
5813 if (arg1) (arg1)->y = arg2;
5814
5815 resultobj = SWIG_Py_Void();
5816 return resultobj;
5817 fail:
5818 return NULL;
5819 }
5820
5821
5822 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5823 PyObject *resultobj = 0;
5824 wxPoint *arg1 = (wxPoint *) 0 ;
5825 int result;
5826 void *argp1 = 0 ;
5827 int res1 = 0 ;
5828 PyObject *swig_obj[1] ;
5829
5830 if (!args) SWIG_fail;
5831 swig_obj[0] = args;
5832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5833 if (!SWIG_IsOK(res1)) {
5834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5835 }
5836 arg1 = reinterpret_cast< wxPoint * >(argp1);
5837 result = (int) ((arg1)->y);
5838 resultobj = SWIG_From_int(static_cast< int >(result));
5839 return resultobj;
5840 fail:
5841 return NULL;
5842 }
5843
5844
5845 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5846 PyObject *resultobj = 0;
5847 int arg1 = (int) 0 ;
5848 int arg2 = (int) 0 ;
5849 wxPoint *result = 0 ;
5850 int val1 ;
5851 int ecode1 = 0 ;
5852 int val2 ;
5853 int ecode2 = 0 ;
5854 PyObject * obj0 = 0 ;
5855 PyObject * obj1 = 0 ;
5856 char * kwnames[] = {
5857 (char *) "x",(char *) "y", NULL
5858 };
5859
5860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5861 if (obj0) {
5862 ecode1 = SWIG_AsVal_int(obj0, &val1);
5863 if (!SWIG_IsOK(ecode1)) {
5864 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5865 }
5866 arg1 = static_cast< int >(val1);
5867 }
5868 if (obj1) {
5869 ecode2 = SWIG_AsVal_int(obj1, &val2);
5870 if (!SWIG_IsOK(ecode2)) {
5871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5872 }
5873 arg2 = static_cast< int >(val2);
5874 }
5875 {
5876 result = (wxPoint *)new wxPoint(arg1,arg2);
5877 if (PyErr_Occurred()) SWIG_fail;
5878 }
5879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5880 return resultobj;
5881 fail:
5882 return NULL;
5883 }
5884
5885
5886 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5887 PyObject *resultobj = 0;
5888 wxPoint *arg1 = (wxPoint *) 0 ;
5889 void *argp1 = 0 ;
5890 int res1 = 0 ;
5891 PyObject *swig_obj[1] ;
5892
5893 if (!args) SWIG_fail;
5894 swig_obj[0] = args;
5895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5896 if (!SWIG_IsOK(res1)) {
5897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5898 }
5899 arg1 = reinterpret_cast< wxPoint * >(argp1);
5900 {
5901 delete arg1;
5902
5903 if (PyErr_Occurred()) SWIG_fail;
5904 }
5905 resultobj = SWIG_Py_Void();
5906 return resultobj;
5907 fail:
5908 return NULL;
5909 }
5910
5911
5912 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5913 PyObject *resultobj = 0;
5914 wxPoint *arg1 = (wxPoint *) 0 ;
5915 PyObject *arg2 = (PyObject *) 0 ;
5916 bool result;
5917 void *argp1 = 0 ;
5918 int res1 = 0 ;
5919 PyObject * obj0 = 0 ;
5920 PyObject * obj1 = 0 ;
5921 char * kwnames[] = {
5922 (char *) "self",(char *) "other", NULL
5923 };
5924
5925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5927 if (!SWIG_IsOK(res1)) {
5928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5929 }
5930 arg1 = reinterpret_cast< wxPoint * >(argp1);
5931 arg2 = obj1;
5932 {
5933 result = (bool)wxPoint___eq__(arg1,arg2);
5934 if (PyErr_Occurred()) SWIG_fail;
5935 }
5936 {
5937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5938 }
5939 return resultobj;
5940 fail:
5941 return NULL;
5942 }
5943
5944
5945 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5946 PyObject *resultobj = 0;
5947 wxPoint *arg1 = (wxPoint *) 0 ;
5948 PyObject *arg2 = (PyObject *) 0 ;
5949 bool result;
5950 void *argp1 = 0 ;
5951 int res1 = 0 ;
5952 PyObject * obj0 = 0 ;
5953 PyObject * obj1 = 0 ;
5954 char * kwnames[] = {
5955 (char *) "self",(char *) "other", NULL
5956 };
5957
5958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5960 if (!SWIG_IsOK(res1)) {
5961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5962 }
5963 arg1 = reinterpret_cast< wxPoint * >(argp1);
5964 arg2 = obj1;
5965 {
5966 result = (bool)wxPoint___ne__(arg1,arg2);
5967 if (PyErr_Occurred()) SWIG_fail;
5968 }
5969 {
5970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5971 }
5972 return resultobj;
5973 fail:
5974 return NULL;
5975 }
5976
5977
5978 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5979 PyObject *resultobj = 0;
5980 wxPoint *arg1 = (wxPoint *) 0 ;
5981 wxPoint *arg2 = 0 ;
5982 wxPoint result;
5983 void *argp1 = 0 ;
5984 int res1 = 0 ;
5985 wxPoint temp2 ;
5986 PyObject * obj0 = 0 ;
5987 PyObject * obj1 = 0 ;
5988 char * kwnames[] = {
5989 (char *) "self",(char *) "pt", NULL
5990 };
5991
5992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5994 if (!SWIG_IsOK(res1)) {
5995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5996 }
5997 arg1 = reinterpret_cast< wxPoint * >(argp1);
5998 {
5999 arg2 = &temp2;
6000 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6001 }
6002 {
6003 result = (arg1)->operator +((wxPoint const &)*arg2);
6004 if (PyErr_Occurred()) SWIG_fail;
6005 }
6006 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6007 return resultobj;
6008 fail:
6009 return NULL;
6010 }
6011
6012
6013 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6014 PyObject *resultobj = 0;
6015 wxPoint *arg1 = (wxPoint *) 0 ;
6016 wxPoint *arg2 = 0 ;
6017 wxPoint result;
6018 void *argp1 = 0 ;
6019 int res1 = 0 ;
6020 wxPoint temp2 ;
6021 PyObject * obj0 = 0 ;
6022 PyObject * obj1 = 0 ;
6023 char * kwnames[] = {
6024 (char *) "self",(char *) "pt", NULL
6025 };
6026
6027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6029 if (!SWIG_IsOK(res1)) {
6030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6031 }
6032 arg1 = reinterpret_cast< wxPoint * >(argp1);
6033 {
6034 arg2 = &temp2;
6035 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6036 }
6037 {
6038 result = (arg1)->operator -((wxPoint const &)*arg2);
6039 if (PyErr_Occurred()) SWIG_fail;
6040 }
6041 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6042 return resultobj;
6043 fail:
6044 return NULL;
6045 }
6046
6047
6048 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6049 PyObject *resultobj = 0;
6050 wxPoint *arg1 = (wxPoint *) 0 ;
6051 wxPoint *arg2 = 0 ;
6052 wxPoint *result = 0 ;
6053 void *argp1 = 0 ;
6054 int res1 = 0 ;
6055 wxPoint temp2 ;
6056 PyObject * obj0 = 0 ;
6057 PyObject * obj1 = 0 ;
6058 char * kwnames[] = {
6059 (char *) "self",(char *) "pt", NULL
6060 };
6061
6062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6064 if (!SWIG_IsOK(res1)) {
6065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6066 }
6067 arg1 = reinterpret_cast< wxPoint * >(argp1);
6068 {
6069 arg2 = &temp2;
6070 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6071 }
6072 {
6073 {
6074 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6075 result = (wxPoint *) &_result_ref;
6076 }
6077 if (PyErr_Occurred()) SWIG_fail;
6078 }
6079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6080 return resultobj;
6081 fail:
6082 return NULL;
6083 }
6084
6085
6086 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6087 PyObject *resultobj = 0;
6088 wxPoint *arg1 = (wxPoint *) 0 ;
6089 wxPoint *arg2 = 0 ;
6090 wxPoint *result = 0 ;
6091 void *argp1 = 0 ;
6092 int res1 = 0 ;
6093 wxPoint temp2 ;
6094 PyObject * obj0 = 0 ;
6095 PyObject * obj1 = 0 ;
6096 char * kwnames[] = {
6097 (char *) "self",(char *) "pt", NULL
6098 };
6099
6100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6102 if (!SWIG_IsOK(res1)) {
6103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6104 }
6105 arg1 = reinterpret_cast< wxPoint * >(argp1);
6106 {
6107 arg2 = &temp2;
6108 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6109 }
6110 {
6111 {
6112 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6113 result = (wxPoint *) &_result_ref;
6114 }
6115 if (PyErr_Occurred()) SWIG_fail;
6116 }
6117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6118 return resultobj;
6119 fail:
6120 return NULL;
6121 }
6122
6123
6124 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6125 PyObject *resultobj = 0;
6126 wxPoint *arg1 = (wxPoint *) 0 ;
6127 long arg2 ;
6128 long arg3 ;
6129 void *argp1 = 0 ;
6130 int res1 = 0 ;
6131 long val2 ;
6132 int ecode2 = 0 ;
6133 long val3 ;
6134 int ecode3 = 0 ;
6135 PyObject * obj0 = 0 ;
6136 PyObject * obj1 = 0 ;
6137 PyObject * obj2 = 0 ;
6138 char * kwnames[] = {
6139 (char *) "self",(char *) "x",(char *) "y", NULL
6140 };
6141
6142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6144 if (!SWIG_IsOK(res1)) {
6145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6146 }
6147 arg1 = reinterpret_cast< wxPoint * >(argp1);
6148 ecode2 = SWIG_AsVal_long(obj1, &val2);
6149 if (!SWIG_IsOK(ecode2)) {
6150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6151 }
6152 arg2 = static_cast< long >(val2);
6153 ecode3 = SWIG_AsVal_long(obj2, &val3);
6154 if (!SWIG_IsOK(ecode3)) {
6155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6156 }
6157 arg3 = static_cast< long >(val3);
6158 {
6159 wxPoint_Set(arg1,arg2,arg3);
6160 if (PyErr_Occurred()) SWIG_fail;
6161 }
6162 resultobj = SWIG_Py_Void();
6163 return resultobj;
6164 fail:
6165 return NULL;
6166 }
6167
6168
6169 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6170 PyObject *resultobj = 0;
6171 wxPoint *arg1 = (wxPoint *) 0 ;
6172 PyObject *result = 0 ;
6173 void *argp1 = 0 ;
6174 int res1 = 0 ;
6175 PyObject *swig_obj[1] ;
6176
6177 if (!args) SWIG_fail;
6178 swig_obj[0] = args;
6179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6180 if (!SWIG_IsOK(res1)) {
6181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6182 }
6183 arg1 = reinterpret_cast< wxPoint * >(argp1);
6184 {
6185 result = (PyObject *)wxPoint_Get(arg1);
6186 if (PyErr_Occurred()) SWIG_fail;
6187 }
6188 resultobj = result;
6189 return resultobj;
6190 fail:
6191 return NULL;
6192 }
6193
6194
6195 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6196 PyObject *obj;
6197 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6198 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6199 return SWIG_Py_Void();
6200 }
6201
6202 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6203 return SWIG_Python_InitShadowInstance(args);
6204 }
6205
6206 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6207 PyObject *resultobj = 0;
6208 int arg1 = (int) 0 ;
6209 int arg2 = (int) 0 ;
6210 int arg3 = (int) 0 ;
6211 int arg4 = (int) 0 ;
6212 wxRect *result = 0 ;
6213 int val1 ;
6214 int ecode1 = 0 ;
6215 int val2 ;
6216 int ecode2 = 0 ;
6217 int val3 ;
6218 int ecode3 = 0 ;
6219 int val4 ;
6220 int ecode4 = 0 ;
6221 PyObject * obj0 = 0 ;
6222 PyObject * obj1 = 0 ;
6223 PyObject * obj2 = 0 ;
6224 PyObject * obj3 = 0 ;
6225 char * kwnames[] = {
6226 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6227 };
6228
6229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6230 if (obj0) {
6231 ecode1 = SWIG_AsVal_int(obj0, &val1);
6232 if (!SWIG_IsOK(ecode1)) {
6233 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6234 }
6235 arg1 = static_cast< int >(val1);
6236 }
6237 if (obj1) {
6238 ecode2 = SWIG_AsVal_int(obj1, &val2);
6239 if (!SWIG_IsOK(ecode2)) {
6240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6241 }
6242 arg2 = static_cast< int >(val2);
6243 }
6244 if (obj2) {
6245 ecode3 = SWIG_AsVal_int(obj2, &val3);
6246 if (!SWIG_IsOK(ecode3)) {
6247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6248 }
6249 arg3 = static_cast< int >(val3);
6250 }
6251 if (obj3) {
6252 ecode4 = SWIG_AsVal_int(obj3, &val4);
6253 if (!SWIG_IsOK(ecode4)) {
6254 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6255 }
6256 arg4 = static_cast< int >(val4);
6257 }
6258 {
6259 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6260 if (PyErr_Occurred()) SWIG_fail;
6261 }
6262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6263 return resultobj;
6264 fail:
6265 return NULL;
6266 }
6267
6268
6269 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6270 PyObject *resultobj = 0;
6271 wxPoint *arg1 = 0 ;
6272 wxPoint *arg2 = 0 ;
6273 wxRect *result = 0 ;
6274 wxPoint temp1 ;
6275 wxPoint temp2 ;
6276 PyObject * obj0 = 0 ;
6277 PyObject * obj1 = 0 ;
6278 char * kwnames[] = {
6279 (char *) "topLeft",(char *) "bottomRight", NULL
6280 };
6281
6282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6283 {
6284 arg1 = &temp1;
6285 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6286 }
6287 {
6288 arg2 = &temp2;
6289 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6290 }
6291 {
6292 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6293 if (PyErr_Occurred()) SWIG_fail;
6294 }
6295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6296 return resultobj;
6297 fail:
6298 return NULL;
6299 }
6300
6301
6302 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6303 PyObject *resultobj = 0;
6304 wxPoint *arg1 = 0 ;
6305 wxSize *arg2 = 0 ;
6306 wxRect *result = 0 ;
6307 wxPoint temp1 ;
6308 wxSize temp2 ;
6309 PyObject * obj0 = 0 ;
6310 PyObject * obj1 = 0 ;
6311 char * kwnames[] = {
6312 (char *) "pos",(char *) "size", NULL
6313 };
6314
6315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6316 {
6317 arg1 = &temp1;
6318 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6319 }
6320 {
6321 arg2 = &temp2;
6322 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6323 }
6324 {
6325 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6326 if (PyErr_Occurred()) SWIG_fail;
6327 }
6328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6329 return resultobj;
6330 fail:
6331 return NULL;
6332 }
6333
6334
6335 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6336 PyObject *resultobj = 0;
6337 wxSize *arg1 = 0 ;
6338 wxRect *result = 0 ;
6339 wxSize temp1 ;
6340 PyObject * obj0 = 0 ;
6341 char * kwnames[] = {
6342 (char *) "size", NULL
6343 };
6344
6345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6346 {
6347 arg1 = &temp1;
6348 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6349 }
6350 {
6351 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6352 if (PyErr_Occurred()) SWIG_fail;
6353 }
6354 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6355 return resultobj;
6356 fail:
6357 return NULL;
6358 }
6359
6360
6361 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6362 PyObject *resultobj = 0;
6363 wxRect *arg1 = (wxRect *) 0 ;
6364 void *argp1 = 0 ;
6365 int res1 = 0 ;
6366 PyObject *swig_obj[1] ;
6367
6368 if (!args) SWIG_fail;
6369 swig_obj[0] = args;
6370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6371 if (!SWIG_IsOK(res1)) {
6372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6373 }
6374 arg1 = reinterpret_cast< wxRect * >(argp1);
6375 {
6376 delete arg1;
6377
6378 if (PyErr_Occurred()) SWIG_fail;
6379 }
6380 resultobj = SWIG_Py_Void();
6381 return resultobj;
6382 fail:
6383 return NULL;
6384 }
6385
6386
6387 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6388 PyObject *resultobj = 0;
6389 wxRect *arg1 = (wxRect *) 0 ;
6390 int result;
6391 void *argp1 = 0 ;
6392 int res1 = 0 ;
6393 PyObject *swig_obj[1] ;
6394
6395 if (!args) SWIG_fail;
6396 swig_obj[0] = args;
6397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6398 if (!SWIG_IsOK(res1)) {
6399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6400 }
6401 arg1 = reinterpret_cast< wxRect * >(argp1);
6402 {
6403 result = (int)((wxRect const *)arg1)->GetX();
6404 if (PyErr_Occurred()) SWIG_fail;
6405 }
6406 resultobj = SWIG_From_int(static_cast< int >(result));
6407 return resultobj;
6408 fail:
6409 return NULL;
6410 }
6411
6412
6413 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6414 PyObject *resultobj = 0;
6415 wxRect *arg1 = (wxRect *) 0 ;
6416 int arg2 ;
6417 void *argp1 = 0 ;
6418 int res1 = 0 ;
6419 int val2 ;
6420 int ecode2 = 0 ;
6421 PyObject * obj0 = 0 ;
6422 PyObject * obj1 = 0 ;
6423 char * kwnames[] = {
6424 (char *) "self",(char *) "x", NULL
6425 };
6426
6427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6429 if (!SWIG_IsOK(res1)) {
6430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6431 }
6432 arg1 = reinterpret_cast< wxRect * >(argp1);
6433 ecode2 = SWIG_AsVal_int(obj1, &val2);
6434 if (!SWIG_IsOK(ecode2)) {
6435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6436 }
6437 arg2 = static_cast< int >(val2);
6438 {
6439 (arg1)->SetX(arg2);
6440 if (PyErr_Occurred()) SWIG_fail;
6441 }
6442 resultobj = SWIG_Py_Void();
6443 return resultobj;
6444 fail:
6445 return NULL;
6446 }
6447
6448
6449 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6450 PyObject *resultobj = 0;
6451 wxRect *arg1 = (wxRect *) 0 ;
6452 int result;
6453 void *argp1 = 0 ;
6454 int res1 = 0 ;
6455 PyObject *swig_obj[1] ;
6456
6457 if (!args) SWIG_fail;
6458 swig_obj[0] = args;
6459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6460 if (!SWIG_IsOK(res1)) {
6461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6462 }
6463 arg1 = reinterpret_cast< wxRect * >(argp1);
6464 {
6465 result = (int)(arg1)->GetY();
6466 if (PyErr_Occurred()) SWIG_fail;
6467 }
6468 resultobj = SWIG_From_int(static_cast< int >(result));
6469 return resultobj;
6470 fail:
6471 return NULL;
6472 }
6473
6474
6475 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6476 PyObject *resultobj = 0;
6477 wxRect *arg1 = (wxRect *) 0 ;
6478 int arg2 ;
6479 void *argp1 = 0 ;
6480 int res1 = 0 ;
6481 int val2 ;
6482 int ecode2 = 0 ;
6483 PyObject * obj0 = 0 ;
6484 PyObject * obj1 = 0 ;
6485 char * kwnames[] = {
6486 (char *) "self",(char *) "y", NULL
6487 };
6488
6489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6491 if (!SWIG_IsOK(res1)) {
6492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6493 }
6494 arg1 = reinterpret_cast< wxRect * >(argp1);
6495 ecode2 = SWIG_AsVal_int(obj1, &val2);
6496 if (!SWIG_IsOK(ecode2)) {
6497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6498 }
6499 arg2 = static_cast< int >(val2);
6500 {
6501 (arg1)->SetY(arg2);
6502 if (PyErr_Occurred()) SWIG_fail;
6503 }
6504 resultobj = SWIG_Py_Void();
6505 return resultobj;
6506 fail:
6507 return NULL;
6508 }
6509
6510
6511 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6512 PyObject *resultobj = 0;
6513 wxRect *arg1 = (wxRect *) 0 ;
6514 int result;
6515 void *argp1 = 0 ;
6516 int res1 = 0 ;
6517 PyObject *swig_obj[1] ;
6518
6519 if (!args) SWIG_fail;
6520 swig_obj[0] = args;
6521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6522 if (!SWIG_IsOK(res1)) {
6523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6524 }
6525 arg1 = reinterpret_cast< wxRect * >(argp1);
6526 {
6527 result = (int)((wxRect const *)arg1)->GetWidth();
6528 if (PyErr_Occurred()) SWIG_fail;
6529 }
6530 resultobj = SWIG_From_int(static_cast< int >(result));
6531 return resultobj;
6532 fail:
6533 return NULL;
6534 }
6535
6536
6537 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6538 PyObject *resultobj = 0;
6539 wxRect *arg1 = (wxRect *) 0 ;
6540 int arg2 ;
6541 void *argp1 = 0 ;
6542 int res1 = 0 ;
6543 int val2 ;
6544 int ecode2 = 0 ;
6545 PyObject * obj0 = 0 ;
6546 PyObject * obj1 = 0 ;
6547 char * kwnames[] = {
6548 (char *) "self",(char *) "w", NULL
6549 };
6550
6551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6553 if (!SWIG_IsOK(res1)) {
6554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6555 }
6556 arg1 = reinterpret_cast< wxRect * >(argp1);
6557 ecode2 = SWIG_AsVal_int(obj1, &val2);
6558 if (!SWIG_IsOK(ecode2)) {
6559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6560 }
6561 arg2 = static_cast< int >(val2);
6562 {
6563 (arg1)->SetWidth(arg2);
6564 if (PyErr_Occurred()) SWIG_fail;
6565 }
6566 resultobj = SWIG_Py_Void();
6567 return resultobj;
6568 fail:
6569 return NULL;
6570 }
6571
6572
6573 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6574 PyObject *resultobj = 0;
6575 wxRect *arg1 = (wxRect *) 0 ;
6576 int result;
6577 void *argp1 = 0 ;
6578 int res1 = 0 ;
6579 PyObject *swig_obj[1] ;
6580
6581 if (!args) SWIG_fail;
6582 swig_obj[0] = args;
6583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6584 if (!SWIG_IsOK(res1)) {
6585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6586 }
6587 arg1 = reinterpret_cast< wxRect * >(argp1);
6588 {
6589 result = (int)((wxRect const *)arg1)->GetHeight();
6590 if (PyErr_Occurred()) SWIG_fail;
6591 }
6592 resultobj = SWIG_From_int(static_cast< int >(result));
6593 return resultobj;
6594 fail:
6595 return NULL;
6596 }
6597
6598
6599 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6600 PyObject *resultobj = 0;
6601 wxRect *arg1 = (wxRect *) 0 ;
6602 int arg2 ;
6603 void *argp1 = 0 ;
6604 int res1 = 0 ;
6605 int val2 ;
6606 int ecode2 = 0 ;
6607 PyObject * obj0 = 0 ;
6608 PyObject * obj1 = 0 ;
6609 char * kwnames[] = {
6610 (char *) "self",(char *) "h", NULL
6611 };
6612
6613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6615 if (!SWIG_IsOK(res1)) {
6616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6617 }
6618 arg1 = reinterpret_cast< wxRect * >(argp1);
6619 ecode2 = SWIG_AsVal_int(obj1, &val2);
6620 if (!SWIG_IsOK(ecode2)) {
6621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6622 }
6623 arg2 = static_cast< int >(val2);
6624 {
6625 (arg1)->SetHeight(arg2);
6626 if (PyErr_Occurred()) SWIG_fail;
6627 }
6628 resultobj = SWIG_Py_Void();
6629 return resultobj;
6630 fail:
6631 return NULL;
6632 }
6633
6634
6635 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6636 PyObject *resultobj = 0;
6637 wxRect *arg1 = (wxRect *) 0 ;
6638 wxPoint result;
6639 void *argp1 = 0 ;
6640 int res1 = 0 ;
6641 PyObject *swig_obj[1] ;
6642
6643 if (!args) SWIG_fail;
6644 swig_obj[0] = args;
6645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6646 if (!SWIG_IsOK(res1)) {
6647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6648 }
6649 arg1 = reinterpret_cast< wxRect * >(argp1);
6650 {
6651 result = ((wxRect const *)arg1)->GetPosition();
6652 if (PyErr_Occurred()) SWIG_fail;
6653 }
6654 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6655 return resultobj;
6656 fail:
6657 return NULL;
6658 }
6659
6660
6661 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6662 PyObject *resultobj = 0;
6663 wxRect *arg1 = (wxRect *) 0 ;
6664 wxPoint *arg2 = 0 ;
6665 void *argp1 = 0 ;
6666 int res1 = 0 ;
6667 wxPoint temp2 ;
6668 PyObject * obj0 = 0 ;
6669 PyObject * obj1 = 0 ;
6670 char * kwnames[] = {
6671 (char *) "self",(char *) "p", NULL
6672 };
6673
6674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6676 if (!SWIG_IsOK(res1)) {
6677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6678 }
6679 arg1 = reinterpret_cast< wxRect * >(argp1);
6680 {
6681 arg2 = &temp2;
6682 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6683 }
6684 {
6685 (arg1)->SetPosition((wxPoint const &)*arg2);
6686 if (PyErr_Occurred()) SWIG_fail;
6687 }
6688 resultobj = SWIG_Py_Void();
6689 return resultobj;
6690 fail:
6691 return NULL;
6692 }
6693
6694
6695 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6696 PyObject *resultobj = 0;
6697 wxRect *arg1 = (wxRect *) 0 ;
6698 wxSize result;
6699 void *argp1 = 0 ;
6700 int res1 = 0 ;
6701 PyObject *swig_obj[1] ;
6702
6703 if (!args) SWIG_fail;
6704 swig_obj[0] = args;
6705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6706 if (!SWIG_IsOK(res1)) {
6707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6708 }
6709 arg1 = reinterpret_cast< wxRect * >(argp1);
6710 {
6711 result = ((wxRect const *)arg1)->GetSize();
6712 if (PyErr_Occurred()) SWIG_fail;
6713 }
6714 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6715 return resultobj;
6716 fail:
6717 return NULL;
6718 }
6719
6720
6721 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6722 PyObject *resultobj = 0;
6723 wxRect *arg1 = (wxRect *) 0 ;
6724 wxSize *arg2 = 0 ;
6725 void *argp1 = 0 ;
6726 int res1 = 0 ;
6727 wxSize temp2 ;
6728 PyObject * obj0 = 0 ;
6729 PyObject * obj1 = 0 ;
6730 char * kwnames[] = {
6731 (char *) "self",(char *) "s", NULL
6732 };
6733
6734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6736 if (!SWIG_IsOK(res1)) {
6737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6738 }
6739 arg1 = reinterpret_cast< wxRect * >(argp1);
6740 {
6741 arg2 = &temp2;
6742 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6743 }
6744 {
6745 (arg1)->SetSize((wxSize const &)*arg2);
6746 if (PyErr_Occurred()) SWIG_fail;
6747 }
6748 resultobj = SWIG_Py_Void();
6749 return resultobj;
6750 fail:
6751 return NULL;
6752 }
6753
6754
6755 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6756 PyObject *resultobj = 0;
6757 wxRect *arg1 = (wxRect *) 0 ;
6758 bool result;
6759 void *argp1 = 0 ;
6760 int res1 = 0 ;
6761 PyObject *swig_obj[1] ;
6762
6763 if (!args) SWIG_fail;
6764 swig_obj[0] = args;
6765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6766 if (!SWIG_IsOK(res1)) {
6767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6768 }
6769 arg1 = reinterpret_cast< wxRect * >(argp1);
6770 {
6771 result = (bool)((wxRect const *)arg1)->IsEmpty();
6772 if (PyErr_Occurred()) SWIG_fail;
6773 }
6774 {
6775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6776 }
6777 return resultobj;
6778 fail:
6779 return NULL;
6780 }
6781
6782
6783 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6784 PyObject *resultobj = 0;
6785 wxRect *arg1 = (wxRect *) 0 ;
6786 wxPoint result;
6787 void *argp1 = 0 ;
6788 int res1 = 0 ;
6789 PyObject *swig_obj[1] ;
6790
6791 if (!args) SWIG_fail;
6792 swig_obj[0] = args;
6793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6794 if (!SWIG_IsOK(res1)) {
6795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6796 }
6797 arg1 = reinterpret_cast< wxRect * >(argp1);
6798 {
6799 result = ((wxRect const *)arg1)->GetTopLeft();
6800 if (PyErr_Occurred()) SWIG_fail;
6801 }
6802 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6803 return resultobj;
6804 fail:
6805 return NULL;
6806 }
6807
6808
6809 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6810 PyObject *resultobj = 0;
6811 wxRect *arg1 = (wxRect *) 0 ;
6812 wxPoint *arg2 = 0 ;
6813 void *argp1 = 0 ;
6814 int res1 = 0 ;
6815 wxPoint temp2 ;
6816 PyObject * obj0 = 0 ;
6817 PyObject * obj1 = 0 ;
6818 char * kwnames[] = {
6819 (char *) "self",(char *) "p", NULL
6820 };
6821
6822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6824 if (!SWIG_IsOK(res1)) {
6825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6826 }
6827 arg1 = reinterpret_cast< wxRect * >(argp1);
6828 {
6829 arg2 = &temp2;
6830 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6831 }
6832 {
6833 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6834 if (PyErr_Occurred()) SWIG_fail;
6835 }
6836 resultobj = SWIG_Py_Void();
6837 return resultobj;
6838 fail:
6839 return NULL;
6840 }
6841
6842
6843 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6844 PyObject *resultobj = 0;
6845 wxRect *arg1 = (wxRect *) 0 ;
6846 wxPoint result;
6847 void *argp1 = 0 ;
6848 int res1 = 0 ;
6849 PyObject *swig_obj[1] ;
6850
6851 if (!args) SWIG_fail;
6852 swig_obj[0] = args;
6853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6854 if (!SWIG_IsOK(res1)) {
6855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6856 }
6857 arg1 = reinterpret_cast< wxRect * >(argp1);
6858 {
6859 result = ((wxRect const *)arg1)->GetBottomRight();
6860 if (PyErr_Occurred()) SWIG_fail;
6861 }
6862 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6863 return resultobj;
6864 fail:
6865 return NULL;
6866 }
6867
6868
6869 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6870 PyObject *resultobj = 0;
6871 wxRect *arg1 = (wxRect *) 0 ;
6872 wxPoint *arg2 = 0 ;
6873 void *argp1 = 0 ;
6874 int res1 = 0 ;
6875 wxPoint temp2 ;
6876 PyObject * obj0 = 0 ;
6877 PyObject * obj1 = 0 ;
6878 char * kwnames[] = {
6879 (char *) "self",(char *) "p", NULL
6880 };
6881
6882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6884 if (!SWIG_IsOK(res1)) {
6885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6886 }
6887 arg1 = reinterpret_cast< wxRect * >(argp1);
6888 {
6889 arg2 = &temp2;
6890 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6891 }
6892 {
6893 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6894 if (PyErr_Occurred()) SWIG_fail;
6895 }
6896 resultobj = SWIG_Py_Void();
6897 return resultobj;
6898 fail:
6899 return NULL;
6900 }
6901
6902
6903 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6904 PyObject *resultobj = 0;
6905 wxRect *arg1 = (wxRect *) 0 ;
6906 wxPoint result;
6907 void *argp1 = 0 ;
6908 int res1 = 0 ;
6909 PyObject *swig_obj[1] ;
6910
6911 if (!args) SWIG_fail;
6912 swig_obj[0] = args;
6913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6914 if (!SWIG_IsOK(res1)) {
6915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6916 }
6917 arg1 = reinterpret_cast< wxRect * >(argp1);
6918 {
6919 result = ((wxRect const *)arg1)->GetTopRight();
6920 if (PyErr_Occurred()) SWIG_fail;
6921 }
6922 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6923 return resultobj;
6924 fail:
6925 return NULL;
6926 }
6927
6928
6929 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6930 PyObject *resultobj = 0;
6931 wxRect *arg1 = (wxRect *) 0 ;
6932 wxPoint *arg2 = 0 ;
6933 void *argp1 = 0 ;
6934 int res1 = 0 ;
6935 wxPoint temp2 ;
6936 PyObject * obj0 = 0 ;
6937 PyObject * obj1 = 0 ;
6938 char * kwnames[] = {
6939 (char *) "self",(char *) "p", NULL
6940 };
6941
6942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6944 if (!SWIG_IsOK(res1)) {
6945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6946 }
6947 arg1 = reinterpret_cast< wxRect * >(argp1);
6948 {
6949 arg2 = &temp2;
6950 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6951 }
6952 {
6953 (arg1)->SetTopRight((wxPoint const &)*arg2);
6954 if (PyErr_Occurred()) SWIG_fail;
6955 }
6956 resultobj = SWIG_Py_Void();
6957 return resultobj;
6958 fail:
6959 return NULL;
6960 }
6961
6962
6963 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6964 PyObject *resultobj = 0;
6965 wxRect *arg1 = (wxRect *) 0 ;
6966 wxPoint result;
6967 void *argp1 = 0 ;
6968 int res1 = 0 ;
6969 PyObject *swig_obj[1] ;
6970
6971 if (!args) SWIG_fail;
6972 swig_obj[0] = args;
6973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6974 if (!SWIG_IsOK(res1)) {
6975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6976 }
6977 arg1 = reinterpret_cast< wxRect * >(argp1);
6978 {
6979 result = ((wxRect const *)arg1)->GetBottomLeft();
6980 if (PyErr_Occurred()) SWIG_fail;
6981 }
6982 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6983 return resultobj;
6984 fail:
6985 return NULL;
6986 }
6987
6988
6989 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6990 PyObject *resultobj = 0;
6991 wxRect *arg1 = (wxRect *) 0 ;
6992 wxPoint *arg2 = 0 ;
6993 void *argp1 = 0 ;
6994 int res1 = 0 ;
6995 wxPoint temp2 ;
6996 PyObject * obj0 = 0 ;
6997 PyObject * obj1 = 0 ;
6998 char * kwnames[] = {
6999 (char *) "self",(char *) "p", NULL
7000 };
7001
7002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7004 if (!SWIG_IsOK(res1)) {
7005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7006 }
7007 arg1 = reinterpret_cast< wxRect * >(argp1);
7008 {
7009 arg2 = &temp2;
7010 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7011 }
7012 {
7013 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7014 if (PyErr_Occurred()) SWIG_fail;
7015 }
7016 resultobj = SWIG_Py_Void();
7017 return resultobj;
7018 fail:
7019 return NULL;
7020 }
7021
7022
7023 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7024 PyObject *resultobj = 0;
7025 wxRect *arg1 = (wxRect *) 0 ;
7026 int result;
7027 void *argp1 = 0 ;
7028 int res1 = 0 ;
7029 PyObject *swig_obj[1] ;
7030
7031 if (!args) SWIG_fail;
7032 swig_obj[0] = args;
7033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7034 if (!SWIG_IsOK(res1)) {
7035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7036 }
7037 arg1 = reinterpret_cast< wxRect * >(argp1);
7038 {
7039 result = (int)((wxRect const *)arg1)->GetLeft();
7040 if (PyErr_Occurred()) SWIG_fail;
7041 }
7042 resultobj = SWIG_From_int(static_cast< int >(result));
7043 return resultobj;
7044 fail:
7045 return NULL;
7046 }
7047
7048
7049 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7050 PyObject *resultobj = 0;
7051 wxRect *arg1 = (wxRect *) 0 ;
7052 int result;
7053 void *argp1 = 0 ;
7054 int res1 = 0 ;
7055 PyObject *swig_obj[1] ;
7056
7057 if (!args) SWIG_fail;
7058 swig_obj[0] = args;
7059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7060 if (!SWIG_IsOK(res1)) {
7061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7062 }
7063 arg1 = reinterpret_cast< wxRect * >(argp1);
7064 {
7065 result = (int)((wxRect const *)arg1)->GetTop();
7066 if (PyErr_Occurred()) SWIG_fail;
7067 }
7068 resultobj = SWIG_From_int(static_cast< int >(result));
7069 return resultobj;
7070 fail:
7071 return NULL;
7072 }
7073
7074
7075 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7076 PyObject *resultobj = 0;
7077 wxRect *arg1 = (wxRect *) 0 ;
7078 int result;
7079 void *argp1 = 0 ;
7080 int res1 = 0 ;
7081 PyObject *swig_obj[1] ;
7082
7083 if (!args) SWIG_fail;
7084 swig_obj[0] = args;
7085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7086 if (!SWIG_IsOK(res1)) {
7087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7088 }
7089 arg1 = reinterpret_cast< wxRect * >(argp1);
7090 {
7091 result = (int)((wxRect const *)arg1)->GetBottom();
7092 if (PyErr_Occurred()) SWIG_fail;
7093 }
7094 resultobj = SWIG_From_int(static_cast< int >(result));
7095 return resultobj;
7096 fail:
7097 return NULL;
7098 }
7099
7100
7101 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7102 PyObject *resultobj = 0;
7103 wxRect *arg1 = (wxRect *) 0 ;
7104 int result;
7105 void *argp1 = 0 ;
7106 int res1 = 0 ;
7107 PyObject *swig_obj[1] ;
7108
7109 if (!args) SWIG_fail;
7110 swig_obj[0] = args;
7111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7112 if (!SWIG_IsOK(res1)) {
7113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7114 }
7115 arg1 = reinterpret_cast< wxRect * >(argp1);
7116 {
7117 result = (int)((wxRect const *)arg1)->GetRight();
7118 if (PyErr_Occurred()) SWIG_fail;
7119 }
7120 resultobj = SWIG_From_int(static_cast< int >(result));
7121 return resultobj;
7122 fail:
7123 return NULL;
7124 }
7125
7126
7127 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7128 PyObject *resultobj = 0;
7129 wxRect *arg1 = (wxRect *) 0 ;
7130 int arg2 ;
7131 void *argp1 = 0 ;
7132 int res1 = 0 ;
7133 int val2 ;
7134 int ecode2 = 0 ;
7135 PyObject * obj0 = 0 ;
7136 PyObject * obj1 = 0 ;
7137 char * kwnames[] = {
7138 (char *) "self",(char *) "left", NULL
7139 };
7140
7141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7143 if (!SWIG_IsOK(res1)) {
7144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7145 }
7146 arg1 = reinterpret_cast< wxRect * >(argp1);
7147 ecode2 = SWIG_AsVal_int(obj1, &val2);
7148 if (!SWIG_IsOK(ecode2)) {
7149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7150 }
7151 arg2 = static_cast< int >(val2);
7152 {
7153 (arg1)->SetLeft(arg2);
7154 if (PyErr_Occurred()) SWIG_fail;
7155 }
7156 resultobj = SWIG_Py_Void();
7157 return resultobj;
7158 fail:
7159 return NULL;
7160 }
7161
7162
7163 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7164 PyObject *resultobj = 0;
7165 wxRect *arg1 = (wxRect *) 0 ;
7166 int arg2 ;
7167 void *argp1 = 0 ;
7168 int res1 = 0 ;
7169 int val2 ;
7170 int ecode2 = 0 ;
7171 PyObject * obj0 = 0 ;
7172 PyObject * obj1 = 0 ;
7173 char * kwnames[] = {
7174 (char *) "self",(char *) "right", NULL
7175 };
7176
7177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7179 if (!SWIG_IsOK(res1)) {
7180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7181 }
7182 arg1 = reinterpret_cast< wxRect * >(argp1);
7183 ecode2 = SWIG_AsVal_int(obj1, &val2);
7184 if (!SWIG_IsOK(ecode2)) {
7185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7186 }
7187 arg2 = static_cast< int >(val2);
7188 {
7189 (arg1)->SetRight(arg2);
7190 if (PyErr_Occurred()) SWIG_fail;
7191 }
7192 resultobj = SWIG_Py_Void();
7193 return resultobj;
7194 fail:
7195 return NULL;
7196 }
7197
7198
7199 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7200 PyObject *resultobj = 0;
7201 wxRect *arg1 = (wxRect *) 0 ;
7202 int arg2 ;
7203 void *argp1 = 0 ;
7204 int res1 = 0 ;
7205 int val2 ;
7206 int ecode2 = 0 ;
7207 PyObject * obj0 = 0 ;
7208 PyObject * obj1 = 0 ;
7209 char * kwnames[] = {
7210 (char *) "self",(char *) "top", NULL
7211 };
7212
7213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7215 if (!SWIG_IsOK(res1)) {
7216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7217 }
7218 arg1 = reinterpret_cast< wxRect * >(argp1);
7219 ecode2 = SWIG_AsVal_int(obj1, &val2);
7220 if (!SWIG_IsOK(ecode2)) {
7221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7222 }
7223 arg2 = static_cast< int >(val2);
7224 {
7225 (arg1)->SetTop(arg2);
7226 if (PyErr_Occurred()) SWIG_fail;
7227 }
7228 resultobj = SWIG_Py_Void();
7229 return resultobj;
7230 fail:
7231 return NULL;
7232 }
7233
7234
7235 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7236 PyObject *resultobj = 0;
7237 wxRect *arg1 = (wxRect *) 0 ;
7238 int arg2 ;
7239 void *argp1 = 0 ;
7240 int res1 = 0 ;
7241 int val2 ;
7242 int ecode2 = 0 ;
7243 PyObject * obj0 = 0 ;
7244 PyObject * obj1 = 0 ;
7245 char * kwnames[] = {
7246 (char *) "self",(char *) "bottom", NULL
7247 };
7248
7249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7251 if (!SWIG_IsOK(res1)) {
7252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7253 }
7254 arg1 = reinterpret_cast< wxRect * >(argp1);
7255 ecode2 = SWIG_AsVal_int(obj1, &val2);
7256 if (!SWIG_IsOK(ecode2)) {
7257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7258 }
7259 arg2 = static_cast< int >(val2);
7260 {
7261 (arg1)->SetBottom(arg2);
7262 if (PyErr_Occurred()) SWIG_fail;
7263 }
7264 resultobj = SWIG_Py_Void();
7265 return resultobj;
7266 fail:
7267 return NULL;
7268 }
7269
7270
7271 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7272 PyObject *resultobj = 0;
7273 wxRect *arg1 = (wxRect *) 0 ;
7274 int arg2 ;
7275 int arg3 ;
7276 wxRect *result = 0 ;
7277 void *argp1 = 0 ;
7278 int res1 = 0 ;
7279 int val2 ;
7280 int ecode2 = 0 ;
7281 int val3 ;
7282 int ecode3 = 0 ;
7283 PyObject * obj0 = 0 ;
7284 PyObject * obj1 = 0 ;
7285 PyObject * obj2 = 0 ;
7286 char * kwnames[] = {
7287 (char *) "self",(char *) "dx",(char *) "dy", NULL
7288 };
7289
7290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7292 if (!SWIG_IsOK(res1)) {
7293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7294 }
7295 arg1 = reinterpret_cast< wxRect * >(argp1);
7296 ecode2 = SWIG_AsVal_int(obj1, &val2);
7297 if (!SWIG_IsOK(ecode2)) {
7298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7299 }
7300 arg2 = static_cast< int >(val2);
7301 ecode3 = SWIG_AsVal_int(obj2, &val3);
7302 if (!SWIG_IsOK(ecode3)) {
7303 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7304 }
7305 arg3 = static_cast< int >(val3);
7306 {
7307 {
7308 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7309 result = (wxRect *) &_result_ref;
7310 }
7311 if (PyErr_Occurred()) SWIG_fail;
7312 }
7313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7314 return resultobj;
7315 fail:
7316 return NULL;
7317 }
7318
7319
7320 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7321 PyObject *resultobj = 0;
7322 wxRect *arg1 = (wxRect *) 0 ;
7323 int arg2 ;
7324 int arg3 ;
7325 wxRect *result = 0 ;
7326 void *argp1 = 0 ;
7327 int res1 = 0 ;
7328 int val2 ;
7329 int ecode2 = 0 ;
7330 int val3 ;
7331 int ecode3 = 0 ;
7332 PyObject * obj0 = 0 ;
7333 PyObject * obj1 = 0 ;
7334 PyObject * obj2 = 0 ;
7335 char * kwnames[] = {
7336 (char *) "self",(char *) "dx",(char *) "dy", NULL
7337 };
7338
7339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7341 if (!SWIG_IsOK(res1)) {
7342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7343 }
7344 arg1 = reinterpret_cast< wxRect * >(argp1);
7345 ecode2 = SWIG_AsVal_int(obj1, &val2);
7346 if (!SWIG_IsOK(ecode2)) {
7347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7348 }
7349 arg2 = static_cast< int >(val2);
7350 ecode3 = SWIG_AsVal_int(obj2, &val3);
7351 if (!SWIG_IsOK(ecode3)) {
7352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7353 }
7354 arg3 = static_cast< int >(val3);
7355 {
7356 {
7357 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7358 result = (wxRect *) &_result_ref;
7359 }
7360 if (PyErr_Occurred()) SWIG_fail;
7361 }
7362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7363 return resultobj;
7364 fail:
7365 return NULL;
7366 }
7367
7368
7369 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7370 PyObject *resultobj = 0;
7371 wxRect *arg1 = (wxRect *) 0 ;
7372 int arg2 ;
7373 int arg3 ;
7374 void *argp1 = 0 ;
7375 int res1 = 0 ;
7376 int val2 ;
7377 int ecode2 = 0 ;
7378 int val3 ;
7379 int ecode3 = 0 ;
7380 PyObject * obj0 = 0 ;
7381 PyObject * obj1 = 0 ;
7382 PyObject * obj2 = 0 ;
7383 char * kwnames[] = {
7384 (char *) "self",(char *) "dx",(char *) "dy", NULL
7385 };
7386
7387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7389 if (!SWIG_IsOK(res1)) {
7390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7391 }
7392 arg1 = reinterpret_cast< wxRect * >(argp1);
7393 ecode2 = SWIG_AsVal_int(obj1, &val2);
7394 if (!SWIG_IsOK(ecode2)) {
7395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7396 }
7397 arg2 = static_cast< int >(val2);
7398 ecode3 = SWIG_AsVal_int(obj2, &val3);
7399 if (!SWIG_IsOK(ecode3)) {
7400 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7401 }
7402 arg3 = static_cast< int >(val3);
7403 {
7404 (arg1)->Offset(arg2,arg3);
7405 if (PyErr_Occurred()) SWIG_fail;
7406 }
7407 resultobj = SWIG_Py_Void();
7408 return resultobj;
7409 fail:
7410 return NULL;
7411 }
7412
7413
7414 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7415 PyObject *resultobj = 0;
7416 wxRect *arg1 = (wxRect *) 0 ;
7417 wxPoint *arg2 = 0 ;
7418 void *argp1 = 0 ;
7419 int res1 = 0 ;
7420 wxPoint temp2 ;
7421 PyObject * obj0 = 0 ;
7422 PyObject * obj1 = 0 ;
7423 char * kwnames[] = {
7424 (char *) "self",(char *) "pt", NULL
7425 };
7426
7427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7429 if (!SWIG_IsOK(res1)) {
7430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7431 }
7432 arg1 = reinterpret_cast< wxRect * >(argp1);
7433 {
7434 arg2 = &temp2;
7435 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7436 }
7437 {
7438 (arg1)->Offset((wxPoint const &)*arg2);
7439 if (PyErr_Occurred()) SWIG_fail;
7440 }
7441 resultobj = SWIG_Py_Void();
7442 return resultobj;
7443 fail:
7444 return NULL;
7445 }
7446
7447
7448 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7449 PyObject *resultobj = 0;
7450 wxRect *arg1 = (wxRect *) 0 ;
7451 wxRect *arg2 = 0 ;
7452 wxRect result;
7453 void *argp1 = 0 ;
7454 int res1 = 0 ;
7455 wxRect temp2 ;
7456 PyObject * obj0 = 0 ;
7457 PyObject * obj1 = 0 ;
7458 char * kwnames[] = {
7459 (char *) "self",(char *) "rect", NULL
7460 };
7461
7462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7464 if (!SWIG_IsOK(res1)) {
7465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7466 }
7467 arg1 = reinterpret_cast< wxRect * >(argp1);
7468 {
7469 arg2 = &temp2;
7470 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7471 }
7472 {
7473 result = (arg1)->Intersect((wxRect const &)*arg2);
7474 if (PyErr_Occurred()) SWIG_fail;
7475 }
7476 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7477 return resultobj;
7478 fail:
7479 return NULL;
7480 }
7481
7482
7483 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7484 PyObject *resultobj = 0;
7485 wxRect *arg1 = (wxRect *) 0 ;
7486 wxRect *arg2 = 0 ;
7487 wxRect result;
7488 void *argp1 = 0 ;
7489 int res1 = 0 ;
7490 wxRect temp2 ;
7491 PyObject * obj0 = 0 ;
7492 PyObject * obj1 = 0 ;
7493 char * kwnames[] = {
7494 (char *) "self",(char *) "rect", NULL
7495 };
7496
7497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7499 if (!SWIG_IsOK(res1)) {
7500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7501 }
7502 arg1 = reinterpret_cast< wxRect * >(argp1);
7503 {
7504 arg2 = &temp2;
7505 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7506 }
7507 {
7508 result = (arg1)->Union((wxRect const &)*arg2);
7509 if (PyErr_Occurred()) SWIG_fail;
7510 }
7511 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7512 return resultobj;
7513 fail:
7514 return NULL;
7515 }
7516
7517
7518 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7519 PyObject *resultobj = 0;
7520 wxRect *arg1 = (wxRect *) 0 ;
7521 wxRect *arg2 = 0 ;
7522 wxRect result;
7523 void *argp1 = 0 ;
7524 int res1 = 0 ;
7525 wxRect temp2 ;
7526 PyObject * obj0 = 0 ;
7527 PyObject * obj1 = 0 ;
7528 char * kwnames[] = {
7529 (char *) "self",(char *) "rect", NULL
7530 };
7531
7532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7534 if (!SWIG_IsOK(res1)) {
7535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7536 }
7537 arg1 = reinterpret_cast< wxRect * >(argp1);
7538 {
7539 arg2 = &temp2;
7540 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7541 }
7542 {
7543 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7544 if (PyErr_Occurred()) SWIG_fail;
7545 }
7546 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7547 return resultobj;
7548 fail:
7549 return NULL;
7550 }
7551
7552
7553 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7554 PyObject *resultobj = 0;
7555 wxRect *arg1 = (wxRect *) 0 ;
7556 wxRect *arg2 = 0 ;
7557 wxRect *result = 0 ;
7558 void *argp1 = 0 ;
7559 int res1 = 0 ;
7560 wxRect temp2 ;
7561 PyObject * obj0 = 0 ;
7562 PyObject * obj1 = 0 ;
7563 char * kwnames[] = {
7564 (char *) "self",(char *) "rect", NULL
7565 };
7566
7567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7569 if (!SWIG_IsOK(res1)) {
7570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7571 }
7572 arg1 = reinterpret_cast< wxRect * >(argp1);
7573 {
7574 arg2 = &temp2;
7575 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7576 }
7577 {
7578 {
7579 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7580 result = (wxRect *) &_result_ref;
7581 }
7582 if (PyErr_Occurred()) SWIG_fail;
7583 }
7584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7585 return resultobj;
7586 fail:
7587 return NULL;
7588 }
7589
7590
7591 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7592 PyObject *resultobj = 0;
7593 wxRect *arg1 = (wxRect *) 0 ;
7594 PyObject *arg2 = (PyObject *) 0 ;
7595 bool result;
7596 void *argp1 = 0 ;
7597 int res1 = 0 ;
7598 PyObject * obj0 = 0 ;
7599 PyObject * obj1 = 0 ;
7600 char * kwnames[] = {
7601 (char *) "self",(char *) "other", NULL
7602 };
7603
7604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7606 if (!SWIG_IsOK(res1)) {
7607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7608 }
7609 arg1 = reinterpret_cast< wxRect * >(argp1);
7610 arg2 = obj1;
7611 {
7612 result = (bool)wxRect___eq__(arg1,arg2);
7613 if (PyErr_Occurred()) SWIG_fail;
7614 }
7615 {
7616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7617 }
7618 return resultobj;
7619 fail:
7620 return NULL;
7621 }
7622
7623
7624 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7625 PyObject *resultobj = 0;
7626 wxRect *arg1 = (wxRect *) 0 ;
7627 PyObject *arg2 = (PyObject *) 0 ;
7628 bool result;
7629 void *argp1 = 0 ;
7630 int res1 = 0 ;
7631 PyObject * obj0 = 0 ;
7632 PyObject * obj1 = 0 ;
7633 char * kwnames[] = {
7634 (char *) "self",(char *) "other", NULL
7635 };
7636
7637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7639 if (!SWIG_IsOK(res1)) {
7640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7641 }
7642 arg1 = reinterpret_cast< wxRect * >(argp1);
7643 arg2 = obj1;
7644 {
7645 result = (bool)wxRect___ne__(arg1,arg2);
7646 if (PyErr_Occurred()) SWIG_fail;
7647 }
7648 {
7649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7650 }
7651 return resultobj;
7652 fail:
7653 return NULL;
7654 }
7655
7656
7657 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7658 PyObject *resultobj = 0;
7659 wxRect *arg1 = (wxRect *) 0 ;
7660 int arg2 ;
7661 int arg3 ;
7662 bool result;
7663 void *argp1 = 0 ;
7664 int res1 = 0 ;
7665 int val2 ;
7666 int ecode2 = 0 ;
7667 int val3 ;
7668 int ecode3 = 0 ;
7669 PyObject * obj0 = 0 ;
7670 PyObject * obj1 = 0 ;
7671 PyObject * obj2 = 0 ;
7672 char * kwnames[] = {
7673 (char *) "self",(char *) "x",(char *) "y", NULL
7674 };
7675
7676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7678 if (!SWIG_IsOK(res1)) {
7679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7680 }
7681 arg1 = reinterpret_cast< wxRect * >(argp1);
7682 ecode2 = SWIG_AsVal_int(obj1, &val2);
7683 if (!SWIG_IsOK(ecode2)) {
7684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7685 }
7686 arg2 = static_cast< int >(val2);
7687 ecode3 = SWIG_AsVal_int(obj2, &val3);
7688 if (!SWIG_IsOK(ecode3)) {
7689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7690 }
7691 arg3 = static_cast< int >(val3);
7692 {
7693 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7694 if (PyErr_Occurred()) SWIG_fail;
7695 }
7696 {
7697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7698 }
7699 return resultobj;
7700 fail:
7701 return NULL;
7702 }
7703
7704
7705 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7706 PyObject *resultobj = 0;
7707 wxRect *arg1 = (wxRect *) 0 ;
7708 wxPoint *arg2 = 0 ;
7709 bool result;
7710 void *argp1 = 0 ;
7711 int res1 = 0 ;
7712 wxPoint temp2 ;
7713 PyObject * obj0 = 0 ;
7714 PyObject * obj1 = 0 ;
7715 char * kwnames[] = {
7716 (char *) "self",(char *) "pt", NULL
7717 };
7718
7719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7721 if (!SWIG_IsOK(res1)) {
7722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7723 }
7724 arg1 = reinterpret_cast< wxRect * >(argp1);
7725 {
7726 arg2 = &temp2;
7727 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7728 }
7729 {
7730 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7731 if (PyErr_Occurred()) SWIG_fail;
7732 }
7733 {
7734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7735 }
7736 return resultobj;
7737 fail:
7738 return NULL;
7739 }
7740
7741
7742 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7743 PyObject *resultobj = 0;
7744 wxRect *arg1 = (wxRect *) 0 ;
7745 wxRect *arg2 = 0 ;
7746 bool result;
7747 void *argp1 = 0 ;
7748 int res1 = 0 ;
7749 wxRect temp2 ;
7750 PyObject * obj0 = 0 ;
7751 PyObject * obj1 = 0 ;
7752 char * kwnames[] = {
7753 (char *) "self",(char *) "rect", NULL
7754 };
7755
7756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7758 if (!SWIG_IsOK(res1)) {
7759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7760 }
7761 arg1 = reinterpret_cast< wxRect * >(argp1);
7762 {
7763 arg2 = &temp2;
7764 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7765 }
7766 {
7767 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7768 if (PyErr_Occurred()) SWIG_fail;
7769 }
7770 {
7771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7772 }
7773 return resultobj;
7774 fail:
7775 return NULL;
7776 }
7777
7778
7779 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7780 PyObject *resultobj = 0;
7781 wxRect *arg1 = (wxRect *) 0 ;
7782 wxRect *arg2 = 0 ;
7783 bool result;
7784 void *argp1 = 0 ;
7785 int res1 = 0 ;
7786 wxRect temp2 ;
7787 PyObject * obj0 = 0 ;
7788 PyObject * obj1 = 0 ;
7789 char * kwnames[] = {
7790 (char *) "self",(char *) "rect", NULL
7791 };
7792
7793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7795 if (!SWIG_IsOK(res1)) {
7796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7797 }
7798 arg1 = reinterpret_cast< wxRect * >(argp1);
7799 {
7800 arg2 = &temp2;
7801 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7802 }
7803 {
7804 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7805 if (PyErr_Occurred()) SWIG_fail;
7806 }
7807 {
7808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7809 }
7810 return resultobj;
7811 fail:
7812 return NULL;
7813 }
7814
7815
7816 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7817 PyObject *resultobj = 0;
7818 wxRect *arg1 = (wxRect *) 0 ;
7819 wxRect *arg2 = 0 ;
7820 int arg3 = (int) wxBOTH ;
7821 wxRect result;
7822 void *argp1 = 0 ;
7823 int res1 = 0 ;
7824 wxRect temp2 ;
7825 int val3 ;
7826 int ecode3 = 0 ;
7827 PyObject * obj0 = 0 ;
7828 PyObject * obj1 = 0 ;
7829 PyObject * obj2 = 0 ;
7830 char * kwnames[] = {
7831 (char *) "self",(char *) "r",(char *) "dir", NULL
7832 };
7833
7834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7836 if (!SWIG_IsOK(res1)) {
7837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7838 }
7839 arg1 = reinterpret_cast< wxRect * >(argp1);
7840 {
7841 arg2 = &temp2;
7842 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7843 }
7844 if (obj2) {
7845 ecode3 = SWIG_AsVal_int(obj2, &val3);
7846 if (!SWIG_IsOK(ecode3)) {
7847 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7848 }
7849 arg3 = static_cast< int >(val3);
7850 }
7851 {
7852 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7853 if (PyErr_Occurred()) SWIG_fail;
7854 }
7855 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7856 return resultobj;
7857 fail:
7858 return NULL;
7859 }
7860
7861
7862 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7863 PyObject *resultobj = 0;
7864 wxRect *arg1 = (wxRect *) 0 ;
7865 int arg2 ;
7866 void *argp1 = 0 ;
7867 int res1 = 0 ;
7868 int val2 ;
7869 int ecode2 = 0 ;
7870 PyObject *swig_obj[2] ;
7871
7872 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7874 if (!SWIG_IsOK(res1)) {
7875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7876 }
7877 arg1 = reinterpret_cast< wxRect * >(argp1);
7878 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7879 if (!SWIG_IsOK(ecode2)) {
7880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7881 }
7882 arg2 = static_cast< int >(val2);
7883 if (arg1) (arg1)->x = arg2;
7884
7885 resultobj = SWIG_Py_Void();
7886 return resultobj;
7887 fail:
7888 return NULL;
7889 }
7890
7891
7892 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7893 PyObject *resultobj = 0;
7894 wxRect *arg1 = (wxRect *) 0 ;
7895 int result;
7896 void *argp1 = 0 ;
7897 int res1 = 0 ;
7898 PyObject *swig_obj[1] ;
7899
7900 if (!args) SWIG_fail;
7901 swig_obj[0] = args;
7902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7903 if (!SWIG_IsOK(res1)) {
7904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7905 }
7906 arg1 = reinterpret_cast< wxRect * >(argp1);
7907 result = (int) ((arg1)->x);
7908 resultobj = SWIG_From_int(static_cast< int >(result));
7909 return resultobj;
7910 fail:
7911 return NULL;
7912 }
7913
7914
7915 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7916 PyObject *resultobj = 0;
7917 wxRect *arg1 = (wxRect *) 0 ;
7918 int arg2 ;
7919 void *argp1 = 0 ;
7920 int res1 = 0 ;
7921 int val2 ;
7922 int ecode2 = 0 ;
7923 PyObject *swig_obj[2] ;
7924
7925 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7927 if (!SWIG_IsOK(res1)) {
7928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7929 }
7930 arg1 = reinterpret_cast< wxRect * >(argp1);
7931 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7932 if (!SWIG_IsOK(ecode2)) {
7933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7934 }
7935 arg2 = static_cast< int >(val2);
7936 if (arg1) (arg1)->y = arg2;
7937
7938 resultobj = SWIG_Py_Void();
7939 return resultobj;
7940 fail:
7941 return NULL;
7942 }
7943
7944
7945 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7946 PyObject *resultobj = 0;
7947 wxRect *arg1 = (wxRect *) 0 ;
7948 int result;
7949 void *argp1 = 0 ;
7950 int res1 = 0 ;
7951 PyObject *swig_obj[1] ;
7952
7953 if (!args) SWIG_fail;
7954 swig_obj[0] = args;
7955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7956 if (!SWIG_IsOK(res1)) {
7957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7958 }
7959 arg1 = reinterpret_cast< wxRect * >(argp1);
7960 result = (int) ((arg1)->y);
7961 resultobj = SWIG_From_int(static_cast< int >(result));
7962 return resultobj;
7963 fail:
7964 return NULL;
7965 }
7966
7967
7968 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7969 PyObject *resultobj = 0;
7970 wxRect *arg1 = (wxRect *) 0 ;
7971 int arg2 ;
7972 void *argp1 = 0 ;
7973 int res1 = 0 ;
7974 int val2 ;
7975 int ecode2 = 0 ;
7976 PyObject *swig_obj[2] ;
7977
7978 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7980 if (!SWIG_IsOK(res1)) {
7981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7982 }
7983 arg1 = reinterpret_cast< wxRect * >(argp1);
7984 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7985 if (!SWIG_IsOK(ecode2)) {
7986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7987 }
7988 arg2 = static_cast< int >(val2);
7989 if (arg1) (arg1)->width = arg2;
7990
7991 resultobj = SWIG_Py_Void();
7992 return resultobj;
7993 fail:
7994 return NULL;
7995 }
7996
7997
7998 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7999 PyObject *resultobj = 0;
8000 wxRect *arg1 = (wxRect *) 0 ;
8001 int result;
8002 void *argp1 = 0 ;
8003 int res1 = 0 ;
8004 PyObject *swig_obj[1] ;
8005
8006 if (!args) SWIG_fail;
8007 swig_obj[0] = args;
8008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8009 if (!SWIG_IsOK(res1)) {
8010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8011 }
8012 arg1 = reinterpret_cast< wxRect * >(argp1);
8013 result = (int) ((arg1)->width);
8014 resultobj = SWIG_From_int(static_cast< int >(result));
8015 return resultobj;
8016 fail:
8017 return NULL;
8018 }
8019
8020
8021 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8022 PyObject *resultobj = 0;
8023 wxRect *arg1 = (wxRect *) 0 ;
8024 int arg2 ;
8025 void *argp1 = 0 ;
8026 int res1 = 0 ;
8027 int val2 ;
8028 int ecode2 = 0 ;
8029 PyObject *swig_obj[2] ;
8030
8031 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8033 if (!SWIG_IsOK(res1)) {
8034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8035 }
8036 arg1 = reinterpret_cast< wxRect * >(argp1);
8037 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8038 if (!SWIG_IsOK(ecode2)) {
8039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8040 }
8041 arg2 = static_cast< int >(val2);
8042 if (arg1) (arg1)->height = arg2;
8043
8044 resultobj = SWIG_Py_Void();
8045 return resultobj;
8046 fail:
8047 return NULL;
8048 }
8049
8050
8051 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8052 PyObject *resultobj = 0;
8053 wxRect *arg1 = (wxRect *) 0 ;
8054 int result;
8055 void *argp1 = 0 ;
8056 int res1 = 0 ;
8057 PyObject *swig_obj[1] ;
8058
8059 if (!args) SWIG_fail;
8060 swig_obj[0] = args;
8061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8062 if (!SWIG_IsOK(res1)) {
8063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8064 }
8065 arg1 = reinterpret_cast< wxRect * >(argp1);
8066 result = (int) ((arg1)->height);
8067 resultobj = SWIG_From_int(static_cast< int >(result));
8068 return resultobj;
8069 fail:
8070 return NULL;
8071 }
8072
8073
8074 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8075 PyObject *resultobj = 0;
8076 wxRect *arg1 = (wxRect *) 0 ;
8077 int arg2 = (int) 0 ;
8078 int arg3 = (int) 0 ;
8079 int arg4 = (int) 0 ;
8080 int arg5 = (int) 0 ;
8081 void *argp1 = 0 ;
8082 int res1 = 0 ;
8083 int val2 ;
8084 int ecode2 = 0 ;
8085 int val3 ;
8086 int ecode3 = 0 ;
8087 int val4 ;
8088 int ecode4 = 0 ;
8089 int val5 ;
8090 int ecode5 = 0 ;
8091 PyObject * obj0 = 0 ;
8092 PyObject * obj1 = 0 ;
8093 PyObject * obj2 = 0 ;
8094 PyObject * obj3 = 0 ;
8095 PyObject * obj4 = 0 ;
8096 char * kwnames[] = {
8097 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8098 };
8099
8100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8102 if (!SWIG_IsOK(res1)) {
8103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8104 }
8105 arg1 = reinterpret_cast< wxRect * >(argp1);
8106 if (obj1) {
8107 ecode2 = SWIG_AsVal_int(obj1, &val2);
8108 if (!SWIG_IsOK(ecode2)) {
8109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8110 }
8111 arg2 = static_cast< int >(val2);
8112 }
8113 if (obj2) {
8114 ecode3 = SWIG_AsVal_int(obj2, &val3);
8115 if (!SWIG_IsOK(ecode3)) {
8116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8117 }
8118 arg3 = static_cast< int >(val3);
8119 }
8120 if (obj3) {
8121 ecode4 = SWIG_AsVal_int(obj3, &val4);
8122 if (!SWIG_IsOK(ecode4)) {
8123 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8124 }
8125 arg4 = static_cast< int >(val4);
8126 }
8127 if (obj4) {
8128 ecode5 = SWIG_AsVal_int(obj4, &val5);
8129 if (!SWIG_IsOK(ecode5)) {
8130 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8131 }
8132 arg5 = static_cast< int >(val5);
8133 }
8134 {
8135 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8136 if (PyErr_Occurred()) SWIG_fail;
8137 }
8138 resultobj = SWIG_Py_Void();
8139 return resultobj;
8140 fail:
8141 return NULL;
8142 }
8143
8144
8145 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8146 PyObject *resultobj = 0;
8147 wxRect *arg1 = (wxRect *) 0 ;
8148 PyObject *result = 0 ;
8149 void *argp1 = 0 ;
8150 int res1 = 0 ;
8151 PyObject *swig_obj[1] ;
8152
8153 if (!args) SWIG_fail;
8154 swig_obj[0] = args;
8155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8156 if (!SWIG_IsOK(res1)) {
8157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8158 }
8159 arg1 = reinterpret_cast< wxRect * >(argp1);
8160 {
8161 result = (PyObject *)wxRect_Get(arg1);
8162 if (PyErr_Occurred()) SWIG_fail;
8163 }
8164 resultobj = result;
8165 return resultobj;
8166 fail:
8167 return NULL;
8168 }
8169
8170
8171 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8172 PyObject *obj;
8173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8174 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8175 return SWIG_Py_Void();
8176 }
8177
8178 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8179 return SWIG_Python_InitShadowInstance(args);
8180 }
8181
8182 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8183 PyObject *resultobj = 0;
8184 wxRect *arg1 = (wxRect *) 0 ;
8185 wxRect *arg2 = (wxRect *) 0 ;
8186 PyObject *result = 0 ;
8187 void *argp1 = 0 ;
8188 int res1 = 0 ;
8189 void *argp2 = 0 ;
8190 int res2 = 0 ;
8191 PyObject * obj0 = 0 ;
8192 PyObject * obj1 = 0 ;
8193 char * kwnames[] = {
8194 (char *) "r1",(char *) "r2", NULL
8195 };
8196
8197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8199 if (!SWIG_IsOK(res1)) {
8200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8201 }
8202 arg1 = reinterpret_cast< wxRect * >(argp1);
8203 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8204 if (!SWIG_IsOK(res2)) {
8205 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8206 }
8207 arg2 = reinterpret_cast< wxRect * >(argp2);
8208 {
8209 if (!wxPyCheckForApp()) SWIG_fail;
8210 PyThreadState* __tstate = wxPyBeginAllowThreads();
8211 result = (PyObject *)wxIntersectRect(arg1,arg2);
8212 wxPyEndAllowThreads(__tstate);
8213 if (PyErr_Occurred()) SWIG_fail;
8214 }
8215 resultobj = result;
8216 return resultobj;
8217 fail:
8218 return NULL;
8219 }
8220
8221
8222 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8223 PyObject *resultobj = 0;
8224 double arg1 = (double) 0.0 ;
8225 double arg2 = (double) 0.0 ;
8226 wxPoint2D *result = 0 ;
8227 double val1 ;
8228 int ecode1 = 0 ;
8229 double val2 ;
8230 int ecode2 = 0 ;
8231 PyObject * obj0 = 0 ;
8232 PyObject * obj1 = 0 ;
8233 char * kwnames[] = {
8234 (char *) "x",(char *) "y", NULL
8235 };
8236
8237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8238 if (obj0) {
8239 ecode1 = SWIG_AsVal_double(obj0, &val1);
8240 if (!SWIG_IsOK(ecode1)) {
8241 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8242 }
8243 arg1 = static_cast< double >(val1);
8244 }
8245 if (obj1) {
8246 ecode2 = SWIG_AsVal_double(obj1, &val2);
8247 if (!SWIG_IsOK(ecode2)) {
8248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8249 }
8250 arg2 = static_cast< double >(val2);
8251 }
8252 {
8253 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8254 if (PyErr_Occurred()) SWIG_fail;
8255 }
8256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8257 return resultobj;
8258 fail:
8259 return NULL;
8260 }
8261
8262
8263 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8264 PyObject *resultobj = 0;
8265 wxPoint2D *arg1 = 0 ;
8266 wxPoint2D *result = 0 ;
8267 wxPoint2D temp1 ;
8268 PyObject * obj0 = 0 ;
8269 char * kwnames[] = {
8270 (char *) "pt", NULL
8271 };
8272
8273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8274 {
8275 arg1 = &temp1;
8276 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8277 }
8278 {
8279 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8280 if (PyErr_Occurred()) SWIG_fail;
8281 }
8282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8283 return resultobj;
8284 fail:
8285 return NULL;
8286 }
8287
8288
8289 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8290 PyObject *resultobj = 0;
8291 wxPoint *arg1 = 0 ;
8292 wxPoint2D *result = 0 ;
8293 wxPoint temp1 ;
8294 PyObject * obj0 = 0 ;
8295 char * kwnames[] = {
8296 (char *) "pt", NULL
8297 };
8298
8299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8300 {
8301 arg1 = &temp1;
8302 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8303 }
8304 {
8305 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8306 if (PyErr_Occurred()) SWIG_fail;
8307 }
8308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8309 return resultobj;
8310 fail:
8311 return NULL;
8312 }
8313
8314
8315 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8316 PyObject *resultobj = 0;
8317 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8318 void *argp1 = 0 ;
8319 int res1 = 0 ;
8320 PyObject *swig_obj[1] ;
8321
8322 if (!args) SWIG_fail;
8323 swig_obj[0] = args;
8324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8325 if (!SWIG_IsOK(res1)) {
8326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8327 }
8328 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8329 {
8330 delete arg1;
8331
8332 if (PyErr_Occurred()) SWIG_fail;
8333 }
8334 resultobj = SWIG_Py_Void();
8335 return resultobj;
8336 fail:
8337 return NULL;
8338 }
8339
8340
8341 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8342 PyObject *resultobj = 0;
8343 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8344 int *arg2 = (int *) 0 ;
8345 int *arg3 = (int *) 0 ;
8346 void *argp1 = 0 ;
8347 int res1 = 0 ;
8348 int temp2 ;
8349 int res2 = SWIG_TMPOBJ ;
8350 int temp3 ;
8351 int res3 = SWIG_TMPOBJ ;
8352 PyObject *swig_obj[1] ;
8353
8354 arg2 = &temp2;
8355 arg3 = &temp3;
8356 if (!args) SWIG_fail;
8357 swig_obj[0] = args;
8358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8359 if (!SWIG_IsOK(res1)) {
8360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8361 }
8362 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8363 {
8364 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8365 if (PyErr_Occurred()) SWIG_fail;
8366 }
8367 resultobj = SWIG_Py_Void();
8368 if (SWIG_IsTmpObj(res2)) {
8369 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8370 } else {
8371 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8372 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8373 }
8374 if (SWIG_IsTmpObj(res3)) {
8375 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8376 } else {
8377 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8378 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8379 }
8380 return resultobj;
8381 fail:
8382 return NULL;
8383 }
8384
8385
8386 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8387 PyObject *resultobj = 0;
8388 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8389 int *arg2 = (int *) 0 ;
8390 int *arg3 = (int *) 0 ;
8391 void *argp1 = 0 ;
8392 int res1 = 0 ;
8393 int temp2 ;
8394 int res2 = SWIG_TMPOBJ ;
8395 int temp3 ;
8396 int res3 = SWIG_TMPOBJ ;
8397 PyObject *swig_obj[1] ;
8398
8399 arg2 = &temp2;
8400 arg3 = &temp3;
8401 if (!args) SWIG_fail;
8402 swig_obj[0] = args;
8403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8404 if (!SWIG_IsOK(res1)) {
8405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8406 }
8407 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8408 {
8409 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8410 if (PyErr_Occurred()) SWIG_fail;
8411 }
8412 resultobj = SWIG_Py_Void();
8413 if (SWIG_IsTmpObj(res2)) {
8414 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8415 } else {
8416 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8417 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8418 }
8419 if (SWIG_IsTmpObj(res3)) {
8420 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8421 } else {
8422 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8423 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8424 }
8425 return resultobj;
8426 fail:
8427 return NULL;
8428 }
8429
8430
8431 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8432 PyObject *resultobj = 0;
8433 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8434 double result;
8435 void *argp1 = 0 ;
8436 int res1 = 0 ;
8437 PyObject *swig_obj[1] ;
8438
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_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8444 }
8445 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8446 {
8447 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8448 if (PyErr_Occurred()) SWIG_fail;
8449 }
8450 resultobj = SWIG_From_double(static_cast< double >(result));
8451 return resultobj;
8452 fail:
8453 return NULL;
8454 }
8455
8456
8457 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8458 PyObject *resultobj = 0;
8459 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8460 double result;
8461 void *argp1 = 0 ;
8462 int res1 = 0 ;
8463 PyObject *swig_obj[1] ;
8464
8465 if (!args) SWIG_fail;
8466 swig_obj[0] = args;
8467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8468 if (!SWIG_IsOK(res1)) {
8469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8470 }
8471 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8472 {
8473 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8474 if (PyErr_Occurred()) SWIG_fail;
8475 }
8476 resultobj = SWIG_From_double(static_cast< double >(result));
8477 return resultobj;
8478 fail:
8479 return NULL;
8480 }
8481
8482
8483 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8484 PyObject *resultobj = 0;
8485 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8486 double arg2 ;
8487 void *argp1 = 0 ;
8488 int res1 = 0 ;
8489 double val2 ;
8490 int ecode2 = 0 ;
8491 PyObject * obj0 = 0 ;
8492 PyObject * obj1 = 0 ;
8493 char * kwnames[] = {
8494 (char *) "self",(char *) "length", NULL
8495 };
8496
8497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8499 if (!SWIG_IsOK(res1)) {
8500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8501 }
8502 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8503 ecode2 = SWIG_AsVal_double(obj1, &val2);
8504 if (!SWIG_IsOK(ecode2)) {
8505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8506 }
8507 arg2 = static_cast< double >(val2);
8508 {
8509 (arg1)->SetVectorLength(arg2);
8510 if (PyErr_Occurred()) SWIG_fail;
8511 }
8512 resultobj = SWIG_Py_Void();
8513 return resultobj;
8514 fail:
8515 return NULL;
8516 }
8517
8518
8519 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8520 PyObject *resultobj = 0;
8521 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8522 double arg2 ;
8523 void *argp1 = 0 ;
8524 int res1 = 0 ;
8525 double val2 ;
8526 int ecode2 = 0 ;
8527 PyObject * obj0 = 0 ;
8528 PyObject * obj1 = 0 ;
8529 char * kwnames[] = {
8530 (char *) "self",(char *) "degrees", NULL
8531 };
8532
8533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8535 if (!SWIG_IsOK(res1)) {
8536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8537 }
8538 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8539 ecode2 = SWIG_AsVal_double(obj1, &val2);
8540 if (!SWIG_IsOK(ecode2)) {
8541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8542 }
8543 arg2 = static_cast< double >(val2);
8544 {
8545 (arg1)->SetVectorAngle(arg2);
8546 if (PyErr_Occurred()) SWIG_fail;
8547 }
8548 resultobj = SWIG_Py_Void();
8549 return resultobj;
8550 fail:
8551 return NULL;
8552 }
8553
8554
8555 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8556 PyObject *resultobj = 0;
8557 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8558 wxPoint2D *arg2 = 0 ;
8559 double result;
8560 void *argp1 = 0 ;
8561 int res1 = 0 ;
8562 wxPoint2D temp2 ;
8563 PyObject * obj0 = 0 ;
8564 PyObject * obj1 = 0 ;
8565 char * kwnames[] = {
8566 (char *) "self",(char *) "pt", NULL
8567 };
8568
8569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8571 if (!SWIG_IsOK(res1)) {
8572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8573 }
8574 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8575 {
8576 arg2 = &temp2;
8577 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8578 }
8579 {
8580 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8581 if (PyErr_Occurred()) SWIG_fail;
8582 }
8583 resultobj = SWIG_From_double(static_cast< double >(result));
8584 return resultobj;
8585 fail:
8586 return NULL;
8587 }
8588
8589
8590 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8591 PyObject *resultobj = 0;
8592 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8593 wxPoint2D *arg2 = 0 ;
8594 double result;
8595 void *argp1 = 0 ;
8596 int res1 = 0 ;
8597 wxPoint2D temp2 ;
8598 PyObject * obj0 = 0 ;
8599 PyObject * obj1 = 0 ;
8600 char * kwnames[] = {
8601 (char *) "self",(char *) "pt", NULL
8602 };
8603
8604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8606 if (!SWIG_IsOK(res1)) {
8607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8608 }
8609 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8610 {
8611 arg2 = &temp2;
8612 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8613 }
8614 {
8615 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8616 if (PyErr_Occurred()) SWIG_fail;
8617 }
8618 resultobj = SWIG_From_double(static_cast< double >(result));
8619 return resultobj;
8620 fail:
8621 return NULL;
8622 }
8623
8624
8625 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8626 PyObject *resultobj = 0;
8627 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8628 wxPoint2D *arg2 = 0 ;
8629 double result;
8630 void *argp1 = 0 ;
8631 int res1 = 0 ;
8632 wxPoint2D temp2 ;
8633 PyObject * obj0 = 0 ;
8634 PyObject * obj1 = 0 ;
8635 char * kwnames[] = {
8636 (char *) "self",(char *) "vec", NULL
8637 };
8638
8639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8641 if (!SWIG_IsOK(res1)) {
8642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8643 }
8644 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8645 {
8646 arg2 = &temp2;
8647 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8648 }
8649 {
8650 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8651 if (PyErr_Occurred()) SWIG_fail;
8652 }
8653 resultobj = SWIG_From_double(static_cast< double >(result));
8654 return resultobj;
8655 fail:
8656 return NULL;
8657 }
8658
8659
8660 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8661 PyObject *resultobj = 0;
8662 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8663 wxPoint2D *arg2 = 0 ;
8664 double result;
8665 void *argp1 = 0 ;
8666 int res1 = 0 ;
8667 wxPoint2D temp2 ;
8668 PyObject * obj0 = 0 ;
8669 PyObject * obj1 = 0 ;
8670 char * kwnames[] = {
8671 (char *) "self",(char *) "vec", NULL
8672 };
8673
8674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8676 if (!SWIG_IsOK(res1)) {
8677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8678 }
8679 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8680 {
8681 arg2 = &temp2;
8682 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8683 }
8684 {
8685 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8686 if (PyErr_Occurred()) SWIG_fail;
8687 }
8688 resultobj = SWIG_From_double(static_cast< double >(result));
8689 return resultobj;
8690 fail:
8691 return NULL;
8692 }
8693
8694
8695 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8696 PyObject *resultobj = 0;
8697 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8698 wxPoint2D result;
8699 void *argp1 = 0 ;
8700 int res1 = 0 ;
8701 PyObject *swig_obj[1] ;
8702
8703 if (!args) SWIG_fail;
8704 swig_obj[0] = args;
8705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8706 if (!SWIG_IsOK(res1)) {
8707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8708 }
8709 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8710 {
8711 result = (arg1)->operator -();
8712 if (PyErr_Occurred()) SWIG_fail;
8713 }
8714 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8715 return resultobj;
8716 fail:
8717 return NULL;
8718 }
8719
8720
8721 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8722 PyObject *resultobj = 0;
8723 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8724 wxPoint2D *arg2 = 0 ;
8725 wxPoint2D *result = 0 ;
8726 void *argp1 = 0 ;
8727 int res1 = 0 ;
8728 wxPoint2D temp2 ;
8729 PyObject * obj0 = 0 ;
8730 PyObject * obj1 = 0 ;
8731 char * kwnames[] = {
8732 (char *) "self",(char *) "pt", NULL
8733 };
8734
8735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8737 if (!SWIG_IsOK(res1)) {
8738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8739 }
8740 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8741 {
8742 arg2 = &temp2;
8743 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8744 }
8745 {
8746 {
8747 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8748 result = (wxPoint2D *) &_result_ref;
8749 }
8750 if (PyErr_Occurred()) SWIG_fail;
8751 }
8752 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8753 return resultobj;
8754 fail:
8755 return NULL;
8756 }
8757
8758
8759 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8760 PyObject *resultobj = 0;
8761 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8762 wxPoint2D *arg2 = 0 ;
8763 wxPoint2D *result = 0 ;
8764 void *argp1 = 0 ;
8765 int res1 = 0 ;
8766 wxPoint2D temp2 ;
8767 PyObject * obj0 = 0 ;
8768 PyObject * obj1 = 0 ;
8769 char * kwnames[] = {
8770 (char *) "self",(char *) "pt", NULL
8771 };
8772
8773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8775 if (!SWIG_IsOK(res1)) {
8776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8777 }
8778 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8779 {
8780 arg2 = &temp2;
8781 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8782 }
8783 {
8784 {
8785 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8786 result = (wxPoint2D *) &_result_ref;
8787 }
8788 if (PyErr_Occurred()) SWIG_fail;
8789 }
8790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8791 return resultobj;
8792 fail:
8793 return NULL;
8794 }
8795
8796
8797 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8798 PyObject *resultobj = 0;
8799 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8800 wxPoint2D *arg2 = 0 ;
8801 wxPoint2D *result = 0 ;
8802 void *argp1 = 0 ;
8803 int res1 = 0 ;
8804 wxPoint2D temp2 ;
8805 PyObject * obj0 = 0 ;
8806 PyObject * obj1 = 0 ;
8807 char * kwnames[] = {
8808 (char *) "self",(char *) "pt", NULL
8809 };
8810
8811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8813 if (!SWIG_IsOK(res1)) {
8814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8815 }
8816 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8817 {
8818 arg2 = &temp2;
8819 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8820 }
8821 {
8822 {
8823 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8824 result = (wxPoint2D *) &_result_ref;
8825 }
8826 if (PyErr_Occurred()) SWIG_fail;
8827 }
8828 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8829 return resultobj;
8830 fail:
8831 return NULL;
8832 }
8833
8834
8835 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8836 PyObject *resultobj = 0;
8837 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8838 wxPoint2D *arg2 = 0 ;
8839 wxPoint2D *result = 0 ;
8840 void *argp1 = 0 ;
8841 int res1 = 0 ;
8842 wxPoint2D temp2 ;
8843 PyObject * obj0 = 0 ;
8844 PyObject * obj1 = 0 ;
8845 char * kwnames[] = {
8846 (char *) "self",(char *) "pt", NULL
8847 };
8848
8849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8851 if (!SWIG_IsOK(res1)) {
8852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8853 }
8854 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8855 {
8856 arg2 = &temp2;
8857 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8858 }
8859 {
8860 {
8861 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8862 result = (wxPoint2D *) &_result_ref;
8863 }
8864 if (PyErr_Occurred()) SWIG_fail;
8865 }
8866 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8867 return resultobj;
8868 fail:
8869 return NULL;
8870 }
8871
8872
8873 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8874 PyObject *resultobj = 0;
8875 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8876 PyObject *arg2 = (PyObject *) 0 ;
8877 bool result;
8878 void *argp1 = 0 ;
8879 int res1 = 0 ;
8880 PyObject * obj0 = 0 ;
8881 PyObject * obj1 = 0 ;
8882 char * kwnames[] = {
8883 (char *) "self",(char *) "other", NULL
8884 };
8885
8886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8888 if (!SWIG_IsOK(res1)) {
8889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8890 }
8891 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8892 arg2 = obj1;
8893 {
8894 result = (bool)wxPoint2D___eq__(arg1,arg2);
8895 if (PyErr_Occurred()) SWIG_fail;
8896 }
8897 {
8898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8899 }
8900 return resultobj;
8901 fail:
8902 return NULL;
8903 }
8904
8905
8906 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj = 0;
8908 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8909 PyObject *arg2 = (PyObject *) 0 ;
8910 bool result;
8911 void *argp1 = 0 ;
8912 int res1 = 0 ;
8913 PyObject * obj0 = 0 ;
8914 PyObject * obj1 = 0 ;
8915 char * kwnames[] = {
8916 (char *) "self",(char *) "other", NULL
8917 };
8918
8919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8921 if (!SWIG_IsOK(res1)) {
8922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8923 }
8924 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8925 arg2 = obj1;
8926 {
8927 result = (bool)wxPoint2D___ne__(arg1,arg2);
8928 if (PyErr_Occurred()) SWIG_fail;
8929 }
8930 {
8931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8932 }
8933 return resultobj;
8934 fail:
8935 return NULL;
8936 }
8937
8938
8939 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8940 PyObject *resultobj = 0;
8941 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8942 double arg2 ;
8943 void *argp1 = 0 ;
8944 int res1 = 0 ;
8945 double val2 ;
8946 int ecode2 = 0 ;
8947 PyObject *swig_obj[2] ;
8948
8949 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8951 if (!SWIG_IsOK(res1)) {
8952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8953 }
8954 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8955 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8956 if (!SWIG_IsOK(ecode2)) {
8957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8958 }
8959 arg2 = static_cast< double >(val2);
8960 if (arg1) (arg1)->m_x = arg2;
8961
8962 resultobj = SWIG_Py_Void();
8963 return resultobj;
8964 fail:
8965 return NULL;
8966 }
8967
8968
8969 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8970 PyObject *resultobj = 0;
8971 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8972 double result;
8973 void *argp1 = 0 ;
8974 int res1 = 0 ;
8975 PyObject *swig_obj[1] ;
8976
8977 if (!args) SWIG_fail;
8978 swig_obj[0] = args;
8979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8980 if (!SWIG_IsOK(res1)) {
8981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8982 }
8983 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8984 result = (double) ((arg1)->m_x);
8985 resultobj = SWIG_From_double(static_cast< double >(result));
8986 return resultobj;
8987 fail:
8988 return NULL;
8989 }
8990
8991
8992 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8993 PyObject *resultobj = 0;
8994 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8995 double arg2 ;
8996 void *argp1 = 0 ;
8997 int res1 = 0 ;
8998 double val2 ;
8999 int ecode2 = 0 ;
9000 PyObject *swig_obj[2] ;
9001
9002 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9004 if (!SWIG_IsOK(res1)) {
9005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9006 }
9007 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9008 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9009 if (!SWIG_IsOK(ecode2)) {
9010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9011 }
9012 arg2 = static_cast< double >(val2);
9013 if (arg1) (arg1)->m_y = arg2;
9014
9015 resultobj = SWIG_Py_Void();
9016 return resultobj;
9017 fail:
9018 return NULL;
9019 }
9020
9021
9022 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9023 PyObject *resultobj = 0;
9024 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9025 double result;
9026 void *argp1 = 0 ;
9027 int res1 = 0 ;
9028 PyObject *swig_obj[1] ;
9029
9030 if (!args) SWIG_fail;
9031 swig_obj[0] = args;
9032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9033 if (!SWIG_IsOK(res1)) {
9034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9035 }
9036 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9037 result = (double) ((arg1)->m_y);
9038 resultobj = SWIG_From_double(static_cast< double >(result));
9039 return resultobj;
9040 fail:
9041 return NULL;
9042 }
9043
9044
9045 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9046 PyObject *resultobj = 0;
9047 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9048 double arg2 = (double) 0 ;
9049 double arg3 = (double) 0 ;
9050 void *argp1 = 0 ;
9051 int res1 = 0 ;
9052 double val2 ;
9053 int ecode2 = 0 ;
9054 double val3 ;
9055 int ecode3 = 0 ;
9056 PyObject * obj0 = 0 ;
9057 PyObject * obj1 = 0 ;
9058 PyObject * obj2 = 0 ;
9059 char * kwnames[] = {
9060 (char *) "self",(char *) "x",(char *) "y", NULL
9061 };
9062
9063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9065 if (!SWIG_IsOK(res1)) {
9066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9067 }
9068 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9069 if (obj1) {
9070 ecode2 = SWIG_AsVal_double(obj1, &val2);
9071 if (!SWIG_IsOK(ecode2)) {
9072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9073 }
9074 arg2 = static_cast< double >(val2);
9075 }
9076 if (obj2) {
9077 ecode3 = SWIG_AsVal_double(obj2, &val3);
9078 if (!SWIG_IsOK(ecode3)) {
9079 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9080 }
9081 arg3 = static_cast< double >(val3);
9082 }
9083 {
9084 wxPoint2D_Set(arg1,arg2,arg3);
9085 if (PyErr_Occurred()) SWIG_fail;
9086 }
9087 resultobj = SWIG_Py_Void();
9088 return resultobj;
9089 fail:
9090 return NULL;
9091 }
9092
9093
9094 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9095 PyObject *resultobj = 0;
9096 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9097 PyObject *result = 0 ;
9098 void *argp1 = 0 ;
9099 int res1 = 0 ;
9100 PyObject *swig_obj[1] ;
9101
9102 if (!args) SWIG_fail;
9103 swig_obj[0] = args;
9104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9105 if (!SWIG_IsOK(res1)) {
9106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9107 }
9108 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9109 {
9110 result = (PyObject *)wxPoint2D_Get(arg1);
9111 if (PyErr_Occurred()) SWIG_fail;
9112 }
9113 resultobj = result;
9114 return resultobj;
9115 fail:
9116 return NULL;
9117 }
9118
9119
9120 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9121 PyObject *obj;
9122 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9123 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9124 return SWIG_Py_Void();
9125 }
9126
9127 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9128 return SWIG_Python_InitShadowInstance(args);
9129 }
9130
9131 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9132 PyObject *resultobj = 0;
9133 wxDouble arg1 = (wxDouble) 0.0 ;
9134 wxDouble arg2 = (wxDouble) 0.0 ;
9135 wxDouble arg3 = (wxDouble) 0.0 ;
9136 wxDouble arg4 = (wxDouble) 0.0 ;
9137 wxRect2D *result = 0 ;
9138 void *argp1 ;
9139 int res1 = 0 ;
9140 void *argp2 ;
9141 int res2 = 0 ;
9142 void *argp3 ;
9143 int res3 = 0 ;
9144 void *argp4 ;
9145 int res4 = 0 ;
9146 PyObject * obj0 = 0 ;
9147 PyObject * obj1 = 0 ;
9148 PyObject * obj2 = 0 ;
9149 PyObject * obj3 = 0 ;
9150 char * kwnames[] = {
9151 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9152 };
9153
9154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9155 if (obj0) {
9156 {
9157 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9158 if (!SWIG_IsOK(res1)) {
9159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9160 }
9161 if (!argp1) {
9162 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9163 } else {
9164 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9165 arg1 = *temp;
9166 if (SWIG_IsNewObj(res1)) delete temp;
9167 }
9168 }
9169 }
9170 if (obj1) {
9171 {
9172 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9173 if (!SWIG_IsOK(res2)) {
9174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9175 }
9176 if (!argp2) {
9177 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9178 } else {
9179 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9180 arg2 = *temp;
9181 if (SWIG_IsNewObj(res2)) delete temp;
9182 }
9183 }
9184 }
9185 if (obj2) {
9186 {
9187 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9188 if (!SWIG_IsOK(res3)) {
9189 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9190 }
9191 if (!argp3) {
9192 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9193 } else {
9194 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9195 arg3 = *temp;
9196 if (SWIG_IsNewObj(res3)) delete temp;
9197 }
9198 }
9199 }
9200 if (obj3) {
9201 {
9202 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9203 if (!SWIG_IsOK(res4)) {
9204 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9205 }
9206 if (!argp4) {
9207 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9208 } else {
9209 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9210 arg4 = *temp;
9211 if (SWIG_IsNewObj(res4)) delete temp;
9212 }
9213 }
9214 }
9215 {
9216 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9217 if (PyErr_Occurred()) SWIG_fail;
9218 }
9219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9220 return resultobj;
9221 fail:
9222 return NULL;
9223 }
9224
9225
9226 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9227 PyObject *resultobj = 0;
9228 wxRect2D *arg1 = (wxRect2D *) 0 ;
9229 void *argp1 = 0 ;
9230 int res1 = 0 ;
9231 PyObject *swig_obj[1] ;
9232
9233 if (!args) SWIG_fail;
9234 swig_obj[0] = args;
9235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9236 if (!SWIG_IsOK(res1)) {
9237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9238 }
9239 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9240 {
9241 delete arg1;
9242
9243 if (PyErr_Occurred()) SWIG_fail;
9244 }
9245 resultobj = SWIG_Py_Void();
9246 return resultobj;
9247 fail:
9248 return NULL;
9249 }
9250
9251
9252 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9253 PyObject *resultobj = 0;
9254 wxRect2D *arg1 = (wxRect2D *) 0 ;
9255 wxPoint2D result;
9256 void *argp1 = 0 ;
9257 int res1 = 0 ;
9258 PyObject *swig_obj[1] ;
9259
9260 if (!args) SWIG_fail;
9261 swig_obj[0] = args;
9262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9263 if (!SWIG_IsOK(res1)) {
9264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9265 }
9266 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9267 {
9268 result = (arg1)->GetPosition();
9269 if (PyErr_Occurred()) SWIG_fail;
9270 }
9271 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9272 return resultobj;
9273 fail:
9274 return NULL;
9275 }
9276
9277
9278 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9279 PyObject *resultobj = 0;
9280 wxRect2D *arg1 = (wxRect2D *) 0 ;
9281 wxSize result;
9282 void *argp1 = 0 ;
9283 int res1 = 0 ;
9284 PyObject *swig_obj[1] ;
9285
9286 if (!args) SWIG_fail;
9287 swig_obj[0] = args;
9288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9289 if (!SWIG_IsOK(res1)) {
9290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9291 }
9292 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9293 {
9294 result = (arg1)->GetSize();
9295 if (PyErr_Occurred()) SWIG_fail;
9296 }
9297 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9298 return resultobj;
9299 fail:
9300 return NULL;
9301 }
9302
9303
9304 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9305 PyObject *resultobj = 0;
9306 wxRect2D *arg1 = (wxRect2D *) 0 ;
9307 wxDouble result;
9308 void *argp1 = 0 ;
9309 int res1 = 0 ;
9310 PyObject *swig_obj[1] ;
9311
9312 if (!args) SWIG_fail;
9313 swig_obj[0] = args;
9314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9315 if (!SWIG_IsOK(res1)) {
9316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9317 }
9318 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9319 {
9320 result = ((wxRect2D const *)arg1)->GetLeft();
9321 if (PyErr_Occurred()) SWIG_fail;
9322 }
9323 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9324 return resultobj;
9325 fail:
9326 return NULL;
9327 }
9328
9329
9330 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9331 PyObject *resultobj = 0;
9332 wxRect2D *arg1 = (wxRect2D *) 0 ;
9333 wxDouble arg2 ;
9334 void *argp1 = 0 ;
9335 int res1 = 0 ;
9336 void *argp2 ;
9337 int res2 = 0 ;
9338 PyObject * obj0 = 0 ;
9339 PyObject * obj1 = 0 ;
9340 char * kwnames[] = {
9341 (char *) "self",(char *) "n", NULL
9342 };
9343
9344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9346 if (!SWIG_IsOK(res1)) {
9347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9348 }
9349 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9350 {
9351 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9352 if (!SWIG_IsOK(res2)) {
9353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9354 }
9355 if (!argp2) {
9356 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9357 } else {
9358 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9359 arg2 = *temp;
9360 if (SWIG_IsNewObj(res2)) delete temp;
9361 }
9362 }
9363 {
9364 (arg1)->SetLeft(arg2);
9365 if (PyErr_Occurred()) SWIG_fail;
9366 }
9367 resultobj = SWIG_Py_Void();
9368 return resultobj;
9369 fail:
9370 return NULL;
9371 }
9372
9373
9374 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9375 PyObject *resultobj = 0;
9376 wxRect2D *arg1 = (wxRect2D *) 0 ;
9377 wxDouble arg2 ;
9378 void *argp1 = 0 ;
9379 int res1 = 0 ;
9380 void *argp2 ;
9381 int res2 = 0 ;
9382 PyObject * obj0 = 0 ;
9383 PyObject * obj1 = 0 ;
9384 char * kwnames[] = {
9385 (char *) "self",(char *) "n", NULL
9386 };
9387
9388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9390 if (!SWIG_IsOK(res1)) {
9391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9392 }
9393 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9394 {
9395 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9396 if (!SWIG_IsOK(res2)) {
9397 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9398 }
9399 if (!argp2) {
9400 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9401 } else {
9402 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9403 arg2 = *temp;
9404 if (SWIG_IsNewObj(res2)) delete temp;
9405 }
9406 }
9407 {
9408 (arg1)->MoveLeftTo(arg2);
9409 if (PyErr_Occurred()) SWIG_fail;
9410 }
9411 resultobj = SWIG_Py_Void();
9412 return resultobj;
9413 fail:
9414 return NULL;
9415 }
9416
9417
9418 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9419 PyObject *resultobj = 0;
9420 wxRect2D *arg1 = (wxRect2D *) 0 ;
9421 wxDouble result;
9422 void *argp1 = 0 ;
9423 int res1 = 0 ;
9424 PyObject *swig_obj[1] ;
9425
9426 if (!args) SWIG_fail;
9427 swig_obj[0] = args;
9428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9429 if (!SWIG_IsOK(res1)) {
9430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9431 }
9432 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9433 {
9434 result = ((wxRect2D const *)arg1)->GetTop();
9435 if (PyErr_Occurred()) SWIG_fail;
9436 }
9437 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9438 return resultobj;
9439 fail:
9440 return NULL;
9441 }
9442
9443
9444 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9445 PyObject *resultobj = 0;
9446 wxRect2D *arg1 = (wxRect2D *) 0 ;
9447 wxDouble arg2 ;
9448 void *argp1 = 0 ;
9449 int res1 = 0 ;
9450 void *argp2 ;
9451 int res2 = 0 ;
9452 PyObject * obj0 = 0 ;
9453 PyObject * obj1 = 0 ;
9454 char * kwnames[] = {
9455 (char *) "self",(char *) "n", NULL
9456 };
9457
9458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9460 if (!SWIG_IsOK(res1)) {
9461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9462 }
9463 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9464 {
9465 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9466 if (!SWIG_IsOK(res2)) {
9467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9468 }
9469 if (!argp2) {
9470 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9471 } else {
9472 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9473 arg2 = *temp;
9474 if (SWIG_IsNewObj(res2)) delete temp;
9475 }
9476 }
9477 {
9478 (arg1)->SetTop(arg2);
9479 if (PyErr_Occurred()) SWIG_fail;
9480 }
9481 resultobj = SWIG_Py_Void();
9482 return resultobj;
9483 fail:
9484 return NULL;
9485 }
9486
9487
9488 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9489 PyObject *resultobj = 0;
9490 wxRect2D *arg1 = (wxRect2D *) 0 ;
9491 wxDouble arg2 ;
9492 void *argp1 = 0 ;
9493 int res1 = 0 ;
9494 void *argp2 ;
9495 int res2 = 0 ;
9496 PyObject * obj0 = 0 ;
9497 PyObject * obj1 = 0 ;
9498 char * kwnames[] = {
9499 (char *) "self",(char *) "n", NULL
9500 };
9501
9502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9504 if (!SWIG_IsOK(res1)) {
9505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9506 }
9507 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9508 {
9509 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9510 if (!SWIG_IsOK(res2)) {
9511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9512 }
9513 if (!argp2) {
9514 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9515 } else {
9516 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9517 arg2 = *temp;
9518 if (SWIG_IsNewObj(res2)) delete temp;
9519 }
9520 }
9521 {
9522 (arg1)->MoveTopTo(arg2);
9523 if (PyErr_Occurred()) SWIG_fail;
9524 }
9525 resultobj = SWIG_Py_Void();
9526 return resultobj;
9527 fail:
9528 return NULL;
9529 }
9530
9531
9532 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9533 PyObject *resultobj = 0;
9534 wxRect2D *arg1 = (wxRect2D *) 0 ;
9535 wxDouble result;
9536 void *argp1 = 0 ;
9537 int res1 = 0 ;
9538 PyObject *swig_obj[1] ;
9539
9540 if (!args) SWIG_fail;
9541 swig_obj[0] = args;
9542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9543 if (!SWIG_IsOK(res1)) {
9544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9545 }
9546 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9547 {
9548 result = ((wxRect2D const *)arg1)->GetBottom();
9549 if (PyErr_Occurred()) SWIG_fail;
9550 }
9551 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9552 return resultobj;
9553 fail:
9554 return NULL;
9555 }
9556
9557
9558 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9559 PyObject *resultobj = 0;
9560 wxRect2D *arg1 = (wxRect2D *) 0 ;
9561 wxDouble arg2 ;
9562 void *argp1 = 0 ;
9563 int res1 = 0 ;
9564 void *argp2 ;
9565 int res2 = 0 ;
9566 PyObject * obj0 = 0 ;
9567 PyObject * obj1 = 0 ;
9568 char * kwnames[] = {
9569 (char *) "self",(char *) "n", NULL
9570 };
9571
9572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9574 if (!SWIG_IsOK(res1)) {
9575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9576 }
9577 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9578 {
9579 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9580 if (!SWIG_IsOK(res2)) {
9581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9582 }
9583 if (!argp2) {
9584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9585 } else {
9586 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9587 arg2 = *temp;
9588 if (SWIG_IsNewObj(res2)) delete temp;
9589 }
9590 }
9591 {
9592 (arg1)->SetBottom(arg2);
9593 if (PyErr_Occurred()) SWIG_fail;
9594 }
9595 resultobj = SWIG_Py_Void();
9596 return resultobj;
9597 fail:
9598 return NULL;
9599 }
9600
9601
9602 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9603 PyObject *resultobj = 0;
9604 wxRect2D *arg1 = (wxRect2D *) 0 ;
9605 wxDouble arg2 ;
9606 void *argp1 = 0 ;
9607 int res1 = 0 ;
9608 void *argp2 ;
9609 int res2 = 0 ;
9610 PyObject * obj0 = 0 ;
9611 PyObject * obj1 = 0 ;
9612 char * kwnames[] = {
9613 (char *) "self",(char *) "n", NULL
9614 };
9615
9616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9618 if (!SWIG_IsOK(res1)) {
9619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9620 }
9621 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9622 {
9623 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9624 if (!SWIG_IsOK(res2)) {
9625 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9626 }
9627 if (!argp2) {
9628 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9629 } else {
9630 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9631 arg2 = *temp;
9632 if (SWIG_IsNewObj(res2)) delete temp;
9633 }
9634 }
9635 {
9636 (arg1)->MoveBottomTo(arg2);
9637 if (PyErr_Occurred()) SWIG_fail;
9638 }
9639 resultobj = SWIG_Py_Void();
9640 return resultobj;
9641 fail:
9642 return NULL;
9643 }
9644
9645
9646 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9647 PyObject *resultobj = 0;
9648 wxRect2D *arg1 = (wxRect2D *) 0 ;
9649 wxDouble result;
9650 void *argp1 = 0 ;
9651 int res1 = 0 ;
9652 PyObject *swig_obj[1] ;
9653
9654 if (!args) SWIG_fail;
9655 swig_obj[0] = args;
9656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9657 if (!SWIG_IsOK(res1)) {
9658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9659 }
9660 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9661 {
9662 result = ((wxRect2D const *)arg1)->GetRight();
9663 if (PyErr_Occurred()) SWIG_fail;
9664 }
9665 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9666 return resultobj;
9667 fail:
9668 return NULL;
9669 }
9670
9671
9672 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9673 PyObject *resultobj = 0;
9674 wxRect2D *arg1 = (wxRect2D *) 0 ;
9675 wxDouble arg2 ;
9676 void *argp1 = 0 ;
9677 int res1 = 0 ;
9678 void *argp2 ;
9679 int res2 = 0 ;
9680 PyObject * obj0 = 0 ;
9681 PyObject * obj1 = 0 ;
9682 char * kwnames[] = {
9683 (char *) "self",(char *) "n", NULL
9684 };
9685
9686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9688 if (!SWIG_IsOK(res1)) {
9689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9690 }
9691 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9692 {
9693 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9694 if (!SWIG_IsOK(res2)) {
9695 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9696 }
9697 if (!argp2) {
9698 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9699 } else {
9700 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9701 arg2 = *temp;
9702 if (SWIG_IsNewObj(res2)) delete temp;
9703 }
9704 }
9705 {
9706 (arg1)->SetRight(arg2);
9707 if (PyErr_Occurred()) SWIG_fail;
9708 }
9709 resultobj = SWIG_Py_Void();
9710 return resultobj;
9711 fail:
9712 return NULL;
9713 }
9714
9715
9716 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9717 PyObject *resultobj = 0;
9718 wxRect2D *arg1 = (wxRect2D *) 0 ;
9719 wxDouble arg2 ;
9720 void *argp1 = 0 ;
9721 int res1 = 0 ;
9722 void *argp2 ;
9723 int res2 = 0 ;
9724 PyObject * obj0 = 0 ;
9725 PyObject * obj1 = 0 ;
9726 char * kwnames[] = {
9727 (char *) "self",(char *) "n", NULL
9728 };
9729
9730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9732 if (!SWIG_IsOK(res1)) {
9733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9734 }
9735 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9736 {
9737 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9738 if (!SWIG_IsOK(res2)) {
9739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9740 }
9741 if (!argp2) {
9742 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9743 } else {
9744 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9745 arg2 = *temp;
9746 if (SWIG_IsNewObj(res2)) delete temp;
9747 }
9748 }
9749 {
9750 (arg1)->MoveRightTo(arg2);
9751 if (PyErr_Occurred()) SWIG_fail;
9752 }
9753 resultobj = SWIG_Py_Void();
9754 return resultobj;
9755 fail:
9756 return NULL;
9757 }
9758
9759
9760 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9761 PyObject *resultobj = 0;
9762 wxRect2D *arg1 = (wxRect2D *) 0 ;
9763 wxPoint2D result;
9764 void *argp1 = 0 ;
9765 int res1 = 0 ;
9766 PyObject *swig_obj[1] ;
9767
9768 if (!args) SWIG_fail;
9769 swig_obj[0] = args;
9770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9771 if (!SWIG_IsOK(res1)) {
9772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9773 }
9774 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9775 {
9776 result = ((wxRect2D const *)arg1)->GetLeftTop();
9777 if (PyErr_Occurred()) SWIG_fail;
9778 }
9779 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9780 return resultobj;
9781 fail:
9782 return NULL;
9783 }
9784
9785
9786 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9787 PyObject *resultobj = 0;
9788 wxRect2D *arg1 = (wxRect2D *) 0 ;
9789 wxPoint2D *arg2 = 0 ;
9790 void *argp1 = 0 ;
9791 int res1 = 0 ;
9792 wxPoint2D temp2 ;
9793 PyObject * obj0 = 0 ;
9794 PyObject * obj1 = 0 ;
9795 char * kwnames[] = {
9796 (char *) "self",(char *) "pt", NULL
9797 };
9798
9799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9801 if (!SWIG_IsOK(res1)) {
9802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9803 }
9804 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9805 {
9806 arg2 = &temp2;
9807 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9808 }
9809 {
9810 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9811 if (PyErr_Occurred()) SWIG_fail;
9812 }
9813 resultobj = SWIG_Py_Void();
9814 return resultobj;
9815 fail:
9816 return NULL;
9817 }
9818
9819
9820 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9821 PyObject *resultobj = 0;
9822 wxRect2D *arg1 = (wxRect2D *) 0 ;
9823 wxPoint2D *arg2 = 0 ;
9824 void *argp1 = 0 ;
9825 int res1 = 0 ;
9826 wxPoint2D temp2 ;
9827 PyObject * obj0 = 0 ;
9828 PyObject * obj1 = 0 ;
9829 char * kwnames[] = {
9830 (char *) "self",(char *) "pt", NULL
9831 };
9832
9833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9835 if (!SWIG_IsOK(res1)) {
9836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9837 }
9838 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9839 {
9840 arg2 = &temp2;
9841 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9842 }
9843 {
9844 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9845 if (PyErr_Occurred()) SWIG_fail;
9846 }
9847 resultobj = SWIG_Py_Void();
9848 return resultobj;
9849 fail:
9850 return NULL;
9851 }
9852
9853
9854 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9855 PyObject *resultobj = 0;
9856 wxRect2D *arg1 = (wxRect2D *) 0 ;
9857 wxPoint2D result;
9858 void *argp1 = 0 ;
9859 int res1 = 0 ;
9860 PyObject *swig_obj[1] ;
9861
9862 if (!args) SWIG_fail;
9863 swig_obj[0] = args;
9864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9865 if (!SWIG_IsOK(res1)) {
9866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9867 }
9868 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9869 {
9870 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9871 if (PyErr_Occurred()) SWIG_fail;
9872 }
9873 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9874 return resultobj;
9875 fail:
9876 return NULL;
9877 }
9878
9879
9880 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9881 PyObject *resultobj = 0;
9882 wxRect2D *arg1 = (wxRect2D *) 0 ;
9883 wxPoint2D *arg2 = 0 ;
9884 void *argp1 = 0 ;
9885 int res1 = 0 ;
9886 wxPoint2D temp2 ;
9887 PyObject * obj0 = 0 ;
9888 PyObject * obj1 = 0 ;
9889 char * kwnames[] = {
9890 (char *) "self",(char *) "pt", NULL
9891 };
9892
9893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9895 if (!SWIG_IsOK(res1)) {
9896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9897 }
9898 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9899 {
9900 arg2 = &temp2;
9901 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9902 }
9903 {
9904 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9905 if (PyErr_Occurred()) SWIG_fail;
9906 }
9907 resultobj = SWIG_Py_Void();
9908 return resultobj;
9909 fail:
9910 return NULL;
9911 }
9912
9913
9914 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9915 PyObject *resultobj = 0;
9916 wxRect2D *arg1 = (wxRect2D *) 0 ;
9917 wxPoint2D *arg2 = 0 ;
9918 void *argp1 = 0 ;
9919 int res1 = 0 ;
9920 wxPoint2D temp2 ;
9921 PyObject * obj0 = 0 ;
9922 PyObject * obj1 = 0 ;
9923 char * kwnames[] = {
9924 (char *) "self",(char *) "pt", NULL
9925 };
9926
9927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9929 if (!SWIG_IsOK(res1)) {
9930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9931 }
9932 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9933 {
9934 arg2 = &temp2;
9935 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9936 }
9937 {
9938 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
9939 if (PyErr_Occurred()) SWIG_fail;
9940 }
9941 resultobj = SWIG_Py_Void();
9942 return resultobj;
9943 fail:
9944 return NULL;
9945 }
9946
9947
9948 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9949 PyObject *resultobj = 0;
9950 wxRect2D *arg1 = (wxRect2D *) 0 ;
9951 wxPoint2D result;
9952 void *argp1 = 0 ;
9953 int res1 = 0 ;
9954 PyObject *swig_obj[1] ;
9955
9956 if (!args) SWIG_fail;
9957 swig_obj[0] = args;
9958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9959 if (!SWIG_IsOK(res1)) {
9960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9961 }
9962 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9963 {
9964 result = ((wxRect2D const *)arg1)->GetRightTop();
9965 if (PyErr_Occurred()) SWIG_fail;
9966 }
9967 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9968 return resultobj;
9969 fail:
9970 return NULL;
9971 }
9972
9973
9974 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9975 PyObject *resultobj = 0;
9976 wxRect2D *arg1 = (wxRect2D *) 0 ;
9977 wxPoint2D *arg2 = 0 ;
9978 void *argp1 = 0 ;
9979 int res1 = 0 ;
9980 wxPoint2D temp2 ;
9981 PyObject * obj0 = 0 ;
9982 PyObject * obj1 = 0 ;
9983 char * kwnames[] = {
9984 (char *) "self",(char *) "pt", NULL
9985 };
9986
9987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
9988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9989 if (!SWIG_IsOK(res1)) {
9990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9991 }
9992 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9993 {
9994 arg2 = &temp2;
9995 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9996 }
9997 {
9998 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
9999 if (PyErr_Occurred()) SWIG_fail;
10000 }
10001 resultobj = SWIG_Py_Void();
10002 return resultobj;
10003 fail:
10004 return NULL;
10005 }
10006
10007
10008 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10009 PyObject *resultobj = 0;
10010 wxRect2D *arg1 = (wxRect2D *) 0 ;
10011 wxPoint2D *arg2 = 0 ;
10012 void *argp1 = 0 ;
10013 int res1 = 0 ;
10014 wxPoint2D temp2 ;
10015 PyObject * obj0 = 0 ;
10016 PyObject * obj1 = 0 ;
10017 char * kwnames[] = {
10018 (char *) "self",(char *) "pt", NULL
10019 };
10020
10021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10023 if (!SWIG_IsOK(res1)) {
10024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10025 }
10026 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10027 {
10028 arg2 = &temp2;
10029 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10030 }
10031 {
10032 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10033 if (PyErr_Occurred()) SWIG_fail;
10034 }
10035 resultobj = SWIG_Py_Void();
10036 return resultobj;
10037 fail:
10038 return NULL;
10039 }
10040
10041
10042 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10043 PyObject *resultobj = 0;
10044 wxRect2D *arg1 = (wxRect2D *) 0 ;
10045 wxPoint2D result;
10046 void *argp1 = 0 ;
10047 int res1 = 0 ;
10048 PyObject *swig_obj[1] ;
10049
10050 if (!args) SWIG_fail;
10051 swig_obj[0] = args;
10052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10053 if (!SWIG_IsOK(res1)) {
10054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10055 }
10056 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10057 {
10058 result = ((wxRect2D const *)arg1)->GetRightBottom();
10059 if (PyErr_Occurred()) SWIG_fail;
10060 }
10061 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10062 return resultobj;
10063 fail:
10064 return NULL;
10065 }
10066
10067
10068 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10069 PyObject *resultobj = 0;
10070 wxRect2D *arg1 = (wxRect2D *) 0 ;
10071 wxPoint2D *arg2 = 0 ;
10072 void *argp1 = 0 ;
10073 int res1 = 0 ;
10074 wxPoint2D temp2 ;
10075 PyObject * obj0 = 0 ;
10076 PyObject * obj1 = 0 ;
10077 char * kwnames[] = {
10078 (char *) "self",(char *) "pt", NULL
10079 };
10080
10081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10083 if (!SWIG_IsOK(res1)) {
10084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10085 }
10086 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10087 {
10088 arg2 = &temp2;
10089 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10090 }
10091 {
10092 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10093 if (PyErr_Occurred()) SWIG_fail;
10094 }
10095 resultobj = SWIG_Py_Void();
10096 return resultobj;
10097 fail:
10098 return NULL;
10099 }
10100
10101
10102 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10103 PyObject *resultobj = 0;
10104 wxRect2D *arg1 = (wxRect2D *) 0 ;
10105 wxPoint2D *arg2 = 0 ;
10106 void *argp1 = 0 ;
10107 int res1 = 0 ;
10108 wxPoint2D temp2 ;
10109 PyObject * obj0 = 0 ;
10110 PyObject * obj1 = 0 ;
10111 char * kwnames[] = {
10112 (char *) "self",(char *) "pt", NULL
10113 };
10114
10115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10117 if (!SWIG_IsOK(res1)) {
10118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10119 }
10120 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10121 {
10122 arg2 = &temp2;
10123 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10124 }
10125 {
10126 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10127 if (PyErr_Occurred()) SWIG_fail;
10128 }
10129 resultobj = SWIG_Py_Void();
10130 return resultobj;
10131 fail:
10132 return NULL;
10133 }
10134
10135
10136 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10137 PyObject *resultobj = 0;
10138 wxRect2D *arg1 = (wxRect2D *) 0 ;
10139 wxPoint2D result;
10140 void *argp1 = 0 ;
10141 int res1 = 0 ;
10142 PyObject *swig_obj[1] ;
10143
10144 if (!args) SWIG_fail;
10145 swig_obj[0] = args;
10146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10147 if (!SWIG_IsOK(res1)) {
10148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10149 }
10150 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10151 {
10152 result = ((wxRect2D const *)arg1)->GetCentre();
10153 if (PyErr_Occurred()) SWIG_fail;
10154 }
10155 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10156 return resultobj;
10157 fail:
10158 return NULL;
10159 }
10160
10161
10162 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10163 PyObject *resultobj = 0;
10164 wxRect2D *arg1 = (wxRect2D *) 0 ;
10165 wxPoint2D *arg2 = 0 ;
10166 void *argp1 = 0 ;
10167 int res1 = 0 ;
10168 wxPoint2D temp2 ;
10169 PyObject * obj0 = 0 ;
10170 PyObject * obj1 = 0 ;
10171 char * kwnames[] = {
10172 (char *) "self",(char *) "pt", NULL
10173 };
10174
10175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10177 if (!SWIG_IsOK(res1)) {
10178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10179 }
10180 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10181 {
10182 arg2 = &temp2;
10183 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10184 }
10185 {
10186 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10187 if (PyErr_Occurred()) SWIG_fail;
10188 }
10189 resultobj = SWIG_Py_Void();
10190 return resultobj;
10191 fail:
10192 return NULL;
10193 }
10194
10195
10196 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10197 PyObject *resultobj = 0;
10198 wxRect2D *arg1 = (wxRect2D *) 0 ;
10199 wxPoint2D *arg2 = 0 ;
10200 void *argp1 = 0 ;
10201 int res1 = 0 ;
10202 wxPoint2D temp2 ;
10203 PyObject * obj0 = 0 ;
10204 PyObject * obj1 = 0 ;
10205 char * kwnames[] = {
10206 (char *) "self",(char *) "pt", NULL
10207 };
10208
10209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10211 if (!SWIG_IsOK(res1)) {
10212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10213 }
10214 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10215 {
10216 arg2 = &temp2;
10217 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10218 }
10219 {
10220 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10221 if (PyErr_Occurred()) SWIG_fail;
10222 }
10223 resultobj = SWIG_Py_Void();
10224 return resultobj;
10225 fail:
10226 return NULL;
10227 }
10228
10229
10230 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10231 PyObject *resultobj = 0;
10232 wxRect2D *arg1 = (wxRect2D *) 0 ;
10233 wxPoint2D *arg2 = 0 ;
10234 wxOutCode result;
10235 void *argp1 = 0 ;
10236 int res1 = 0 ;
10237 wxPoint2D temp2 ;
10238 PyObject * obj0 = 0 ;
10239 PyObject * obj1 = 0 ;
10240 char * kwnames[] = {
10241 (char *) "self",(char *) "pt", NULL
10242 };
10243
10244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10246 if (!SWIG_IsOK(res1)) {
10247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10248 }
10249 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10250 {
10251 arg2 = &temp2;
10252 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10253 }
10254 {
10255 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10256 if (PyErr_Occurred()) SWIG_fail;
10257 }
10258 resultobj = SWIG_From_int(static_cast< int >(result));
10259 return resultobj;
10260 fail:
10261 return NULL;
10262 }
10263
10264
10265 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10266 PyObject *resultobj = 0;
10267 wxRect2D *arg1 = (wxRect2D *) 0 ;
10268 wxPoint2D *arg2 = 0 ;
10269 bool result;
10270 void *argp1 = 0 ;
10271 int res1 = 0 ;
10272 wxPoint2D temp2 ;
10273 PyObject * obj0 = 0 ;
10274 PyObject * obj1 = 0 ;
10275 char * kwnames[] = {
10276 (char *) "self",(char *) "pt", NULL
10277 };
10278
10279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10281 if (!SWIG_IsOK(res1)) {
10282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10283 }
10284 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10285 {
10286 arg2 = &temp2;
10287 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10288 }
10289 {
10290 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10291 if (PyErr_Occurred()) SWIG_fail;
10292 }
10293 {
10294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10295 }
10296 return resultobj;
10297 fail:
10298 return NULL;
10299 }
10300
10301
10302 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10303 PyObject *resultobj = 0;
10304 wxRect2D *arg1 = (wxRect2D *) 0 ;
10305 wxRect2D *arg2 = 0 ;
10306 bool result;
10307 void *argp1 = 0 ;
10308 int res1 = 0 ;
10309 wxRect2D temp2 ;
10310 PyObject * obj0 = 0 ;
10311 PyObject * obj1 = 0 ;
10312 char * kwnames[] = {
10313 (char *) "self",(char *) "rect", NULL
10314 };
10315
10316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10318 if (!SWIG_IsOK(res1)) {
10319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10320 }
10321 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10322 {
10323 arg2 = &temp2;
10324 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10325 }
10326 {
10327 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10328 if (PyErr_Occurred()) SWIG_fail;
10329 }
10330 {
10331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10332 }
10333 return resultobj;
10334 fail:
10335 return NULL;
10336 }
10337
10338
10339 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10340 PyObject *resultobj = 0;
10341 wxRect2D *arg1 = (wxRect2D *) 0 ;
10342 bool result;
10343 void *argp1 = 0 ;
10344 int res1 = 0 ;
10345 PyObject *swig_obj[1] ;
10346
10347 if (!args) SWIG_fail;
10348 swig_obj[0] = args;
10349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10350 if (!SWIG_IsOK(res1)) {
10351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10352 }
10353 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10354 {
10355 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10356 if (PyErr_Occurred()) SWIG_fail;
10357 }
10358 {
10359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10360 }
10361 return resultobj;
10362 fail:
10363 return NULL;
10364 }
10365
10366
10367 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10368 PyObject *resultobj = 0;
10369 wxRect2D *arg1 = (wxRect2D *) 0 ;
10370 wxRect2D *arg2 = 0 ;
10371 bool result;
10372 void *argp1 = 0 ;
10373 int res1 = 0 ;
10374 wxRect2D temp2 ;
10375 PyObject * obj0 = 0 ;
10376 PyObject * obj1 = 0 ;
10377 char * kwnames[] = {
10378 (char *) "self",(char *) "rect", NULL
10379 };
10380
10381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10383 if (!SWIG_IsOK(res1)) {
10384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10385 }
10386 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10387 {
10388 arg2 = &temp2;
10389 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10390 }
10391 {
10392 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10393 if (PyErr_Occurred()) SWIG_fail;
10394 }
10395 {
10396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10397 }
10398 return resultobj;
10399 fail:
10400 return NULL;
10401 }
10402
10403
10404 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10405 PyObject *resultobj = 0;
10406 wxRect2D *arg1 = (wxRect2D *) 0 ;
10407 wxDouble arg2 ;
10408 wxDouble arg3 ;
10409 void *argp1 = 0 ;
10410 int res1 = 0 ;
10411 void *argp2 ;
10412 int res2 = 0 ;
10413 void *argp3 ;
10414 int res3 = 0 ;
10415
10416 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10418 if (!SWIG_IsOK(res1)) {
10419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10420 }
10421 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10422 {
10423 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10424 if (!SWIG_IsOK(res2)) {
10425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10426 }
10427 if (!argp2) {
10428 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10429 } else {
10430 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10431 arg2 = *temp;
10432 if (SWIG_IsNewObj(res2)) delete temp;
10433 }
10434 }
10435 {
10436 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10437 if (!SWIG_IsOK(res3)) {
10438 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10439 }
10440 if (!argp3) {
10441 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10442 } else {
10443 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10444 arg3 = *temp;
10445 if (SWIG_IsNewObj(res3)) delete temp;
10446 }
10447 }
10448 {
10449 (arg1)->Inset(arg2,arg3);
10450 if (PyErr_Occurred()) SWIG_fail;
10451 }
10452 resultobj = SWIG_Py_Void();
10453 return resultobj;
10454 fail:
10455 return NULL;
10456 }
10457
10458
10459 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10460 PyObject *resultobj = 0;
10461 wxRect2D *arg1 = (wxRect2D *) 0 ;
10462 wxDouble arg2 ;
10463 wxDouble arg3 ;
10464 wxDouble arg4 ;
10465 wxDouble arg5 ;
10466 void *argp1 = 0 ;
10467 int res1 = 0 ;
10468 void *argp2 ;
10469 int res2 = 0 ;
10470 void *argp3 ;
10471 int res3 = 0 ;
10472 void *argp4 ;
10473 int res4 = 0 ;
10474 void *argp5 ;
10475 int res5 = 0 ;
10476
10477 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10479 if (!SWIG_IsOK(res1)) {
10480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10481 }
10482 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10483 {
10484 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10485 if (!SWIG_IsOK(res2)) {
10486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10487 }
10488 if (!argp2) {
10489 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10490 } else {
10491 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10492 arg2 = *temp;
10493 if (SWIG_IsNewObj(res2)) delete temp;
10494 }
10495 }
10496 {
10497 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10498 if (!SWIG_IsOK(res3)) {
10499 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10500 }
10501 if (!argp3) {
10502 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10503 } else {
10504 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10505 arg3 = *temp;
10506 if (SWIG_IsNewObj(res3)) delete temp;
10507 }
10508 }
10509 {
10510 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10511 if (!SWIG_IsOK(res4)) {
10512 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10513 }
10514 if (!argp4) {
10515 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10516 } else {
10517 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10518 arg4 = *temp;
10519 if (SWIG_IsNewObj(res4)) delete temp;
10520 }
10521 }
10522 {
10523 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10524 if (!SWIG_IsOK(res5)) {
10525 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10526 }
10527 if (!argp5) {
10528 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10529 } else {
10530 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10531 arg5 = *temp;
10532 if (SWIG_IsNewObj(res5)) delete temp;
10533 }
10534 }
10535 {
10536 (arg1)->Inset(arg2,arg3,arg4,arg5);
10537 if (PyErr_Occurred()) SWIG_fail;
10538 }
10539 resultobj = SWIG_Py_Void();
10540 return resultobj;
10541 fail:
10542 return NULL;
10543 }
10544
10545
10546 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10547 int argc;
10548 PyObject *argv[6];
10549
10550 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10551 --argc;
10552 if (argc == 3) {
10553 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10554 }
10555 if (argc == 5) {
10556 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10557 }
10558
10559 fail:
10560 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10561 return NULL;
10562 }
10563
10564
10565 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10566 PyObject *resultobj = 0;
10567 wxRect2D *arg1 = (wxRect2D *) 0 ;
10568 wxPoint2D *arg2 = 0 ;
10569 void *argp1 = 0 ;
10570 int res1 = 0 ;
10571 wxPoint2D temp2 ;
10572 PyObject * obj0 = 0 ;
10573 PyObject * obj1 = 0 ;
10574 char * kwnames[] = {
10575 (char *) "self",(char *) "pt", NULL
10576 };
10577
10578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10580 if (!SWIG_IsOK(res1)) {
10581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10582 }
10583 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10584 {
10585 arg2 = &temp2;
10586 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10587 }
10588 {
10589 (arg1)->Offset((wxPoint2D const &)*arg2);
10590 if (PyErr_Occurred()) SWIG_fail;
10591 }
10592 resultobj = SWIG_Py_Void();
10593 return resultobj;
10594 fail:
10595 return NULL;
10596 }
10597
10598
10599 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10600 PyObject *resultobj = 0;
10601 wxRect2D *arg1 = (wxRect2D *) 0 ;
10602 wxRect2D *arg2 = 0 ;
10603 void *argp1 = 0 ;
10604 int res1 = 0 ;
10605 wxRect2D temp2 ;
10606 PyObject * obj0 = 0 ;
10607 PyObject * obj1 = 0 ;
10608 char * kwnames[] = {
10609 (char *) "self",(char *) "rect", NULL
10610 };
10611
10612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10614 if (!SWIG_IsOK(res1)) {
10615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10616 }
10617 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10618 {
10619 arg2 = &temp2;
10620 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10621 }
10622 {
10623 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10624 if (PyErr_Occurred()) SWIG_fail;
10625 }
10626 resultobj = SWIG_Py_Void();
10627 return resultobj;
10628 fail:
10629 return NULL;
10630 }
10631
10632
10633 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10634 PyObject *resultobj = 0;
10635 wxRect2D *arg1 = (wxRect2D *) 0 ;
10636 int arg2 ;
10637 int arg3 ;
10638 wxPoint2D result;
10639 void *argp1 = 0 ;
10640 int res1 = 0 ;
10641 int val2 ;
10642 int ecode2 = 0 ;
10643 int val3 ;
10644 int ecode3 = 0 ;
10645 PyObject * obj0 = 0 ;
10646 PyObject * obj1 = 0 ;
10647 PyObject * obj2 = 0 ;
10648 char * kwnames[] = {
10649 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10650 };
10651
10652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10654 if (!SWIG_IsOK(res1)) {
10655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10656 }
10657 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10658 ecode2 = SWIG_AsVal_int(obj1, &val2);
10659 if (!SWIG_IsOK(ecode2)) {
10660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10661 }
10662 arg2 = static_cast< int >(val2);
10663 ecode3 = SWIG_AsVal_int(obj2, &val3);
10664 if (!SWIG_IsOK(ecode3)) {
10665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10666 }
10667 arg3 = static_cast< int >(val3);
10668 {
10669 result = (arg1)->Interpolate(arg2,arg3);
10670 if (PyErr_Occurred()) SWIG_fail;
10671 }
10672 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10673 return resultobj;
10674 fail:
10675 return NULL;
10676 }
10677
10678
10679 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10680 PyObject *resultobj = 0;
10681 wxRect2D *arg1 = (wxRect2D *) 0 ;
10682 wxRect2D *arg2 = 0 ;
10683 void *argp1 = 0 ;
10684 int res1 = 0 ;
10685 wxRect2D temp2 ;
10686 PyObject * obj0 = 0 ;
10687 PyObject * obj1 = 0 ;
10688 char * kwnames[] = {
10689 (char *) "self",(char *) "otherRect", NULL
10690 };
10691
10692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10694 if (!SWIG_IsOK(res1)) {
10695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10696 }
10697 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10698 {
10699 arg2 = &temp2;
10700 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10701 }
10702 {
10703 (arg1)->Intersect((wxRect2D const &)*arg2);
10704 if (PyErr_Occurred()) SWIG_fail;
10705 }
10706 resultobj = SWIG_Py_Void();
10707 return resultobj;
10708 fail:
10709 return NULL;
10710 }
10711
10712
10713 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10714 PyObject *resultobj = 0;
10715 wxRect2D *arg1 = (wxRect2D *) 0 ;
10716 wxRect2D *arg2 = 0 ;
10717 wxRect2D result;
10718 void *argp1 = 0 ;
10719 int res1 = 0 ;
10720 wxRect2D temp2 ;
10721 PyObject * obj0 = 0 ;
10722 PyObject * obj1 = 0 ;
10723 char * kwnames[] = {
10724 (char *) "self",(char *) "otherRect", NULL
10725 };
10726
10727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10729 if (!SWIG_IsOK(res1)) {
10730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10731 }
10732 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10733 {
10734 arg2 = &temp2;
10735 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10736 }
10737 {
10738 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10739 if (PyErr_Occurred()) SWIG_fail;
10740 }
10741 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10742 return resultobj;
10743 fail:
10744 return NULL;
10745 }
10746
10747
10748 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10749 PyObject *resultobj = 0;
10750 wxRect2D *arg1 = (wxRect2D *) 0 ;
10751 wxRect2D *arg2 = 0 ;
10752 bool result;
10753 void *argp1 = 0 ;
10754 int res1 = 0 ;
10755 wxRect2D temp2 ;
10756 PyObject * obj0 = 0 ;
10757 PyObject * obj1 = 0 ;
10758 char * kwnames[] = {
10759 (char *) "self",(char *) "rect", NULL
10760 };
10761
10762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10764 if (!SWIG_IsOK(res1)) {
10765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10766 }
10767 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10768 {
10769 arg2 = &temp2;
10770 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10771 }
10772 {
10773 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10774 if (PyErr_Occurred()) SWIG_fail;
10775 }
10776 {
10777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10778 }
10779 return resultobj;
10780 fail:
10781 return NULL;
10782 }
10783
10784
10785 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10786 PyObject *resultobj = 0;
10787 wxRect2D *arg1 = (wxRect2D *) 0 ;
10788 wxRect2D *arg2 = 0 ;
10789 void *argp1 = 0 ;
10790 int res1 = 0 ;
10791 wxRect2D temp2 ;
10792 PyObject * obj0 = 0 ;
10793 PyObject * obj1 = 0 ;
10794 char * kwnames[] = {
10795 (char *) "self",(char *) "otherRect", NULL
10796 };
10797
10798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10800 if (!SWIG_IsOK(res1)) {
10801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10802 }
10803 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10804 {
10805 arg2 = &temp2;
10806 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10807 }
10808 {
10809 (arg1)->Union((wxRect2D const &)*arg2);
10810 if (PyErr_Occurred()) SWIG_fail;
10811 }
10812 resultobj = SWIG_Py_Void();
10813 return resultobj;
10814 fail:
10815 return NULL;
10816 }
10817
10818
10819 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10820 PyObject *resultobj = 0;
10821 wxRect2D *arg1 = (wxRect2D *) 0 ;
10822 wxRect2D *arg2 = 0 ;
10823 wxRect2D result;
10824 void *argp1 = 0 ;
10825 int res1 = 0 ;
10826 wxRect2D temp2 ;
10827 PyObject * obj0 = 0 ;
10828 PyObject * obj1 = 0 ;
10829 char * kwnames[] = {
10830 (char *) "self",(char *) "otherRect", NULL
10831 };
10832
10833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10835 if (!SWIG_IsOK(res1)) {
10836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10837 }
10838 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10839 {
10840 arg2 = &temp2;
10841 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10842 }
10843 {
10844 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10845 if (PyErr_Occurred()) SWIG_fail;
10846 }
10847 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10848 return resultobj;
10849 fail:
10850 return NULL;
10851 }
10852
10853
10854 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10855 PyObject *resultobj = 0;
10856 wxRect2D *arg1 = (wxRect2D *) 0 ;
10857 wxDouble arg2 ;
10858 void *argp1 = 0 ;
10859 int res1 = 0 ;
10860 void *argp2 ;
10861 int res2 = 0 ;
10862
10863 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10865 if (!SWIG_IsOK(res1)) {
10866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10867 }
10868 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10869 {
10870 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10871 if (!SWIG_IsOK(res2)) {
10872 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10873 }
10874 if (!argp2) {
10875 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10876 } else {
10877 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10878 arg2 = *temp;
10879 if (SWIG_IsNewObj(res2)) delete temp;
10880 }
10881 }
10882 {
10883 (arg1)->Scale(arg2);
10884 if (PyErr_Occurred()) SWIG_fail;
10885 }
10886 resultobj = SWIG_Py_Void();
10887 return resultobj;
10888 fail:
10889 return NULL;
10890 }
10891
10892
10893 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10894 PyObject *resultobj = 0;
10895 wxRect2D *arg1 = (wxRect2D *) 0 ;
10896 int arg2 ;
10897 int arg3 ;
10898 void *argp1 = 0 ;
10899 int res1 = 0 ;
10900 int val2 ;
10901 int ecode2 = 0 ;
10902 int val3 ;
10903 int ecode3 = 0 ;
10904
10905 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10907 if (!SWIG_IsOK(res1)) {
10908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10909 }
10910 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10911 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10912 if (!SWIG_IsOK(ecode2)) {
10913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10914 }
10915 arg2 = static_cast< int >(val2);
10916 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10917 if (!SWIG_IsOK(ecode3)) {
10918 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10919 }
10920 arg3 = static_cast< int >(val3);
10921 {
10922 (arg1)->Scale(arg2,arg3);
10923 if (PyErr_Occurred()) SWIG_fail;
10924 }
10925 resultobj = SWIG_Py_Void();
10926 return resultobj;
10927 fail:
10928 return NULL;
10929 }
10930
10931
10932 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
10933 int argc;
10934 PyObject *argv[4];
10935
10936 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
10937 --argc;
10938 if (argc == 2) {
10939 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
10940 }
10941 if (argc == 3) {
10942 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
10943 }
10944
10945 fail:
10946 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
10947 return NULL;
10948 }
10949
10950
10951 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10952 PyObject *resultobj = 0;
10953 wxRect2D *arg1 = (wxRect2D *) 0 ;
10954 PyObject *arg2 = (PyObject *) 0 ;
10955 bool result;
10956 void *argp1 = 0 ;
10957 int res1 = 0 ;
10958 PyObject * obj0 = 0 ;
10959 PyObject * obj1 = 0 ;
10960 char * kwnames[] = {
10961 (char *) "self",(char *) "other", NULL
10962 };
10963
10964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10966 if (!SWIG_IsOK(res1)) {
10967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10968 }
10969 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10970 arg2 = obj1;
10971 {
10972 result = (bool)wxRect2D___eq__(arg1,arg2);
10973 if (PyErr_Occurred()) SWIG_fail;
10974 }
10975 {
10976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10977 }
10978 return resultobj;
10979 fail:
10980 return NULL;
10981 }
10982
10983
10984 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10985 PyObject *resultobj = 0;
10986 wxRect2D *arg1 = (wxRect2D *) 0 ;
10987 PyObject *arg2 = (PyObject *) 0 ;
10988 bool result;
10989 void *argp1 = 0 ;
10990 int res1 = 0 ;
10991 PyObject * obj0 = 0 ;
10992 PyObject * obj1 = 0 ;
10993 char * kwnames[] = {
10994 (char *) "self",(char *) "other", NULL
10995 };
10996
10997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10999 if (!SWIG_IsOK(res1)) {
11000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11001 }
11002 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11003 arg2 = obj1;
11004 {
11005 result = (bool)wxRect2D___ne__(arg1,arg2);
11006 if (PyErr_Occurred()) SWIG_fail;
11007 }
11008 {
11009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11010 }
11011 return resultobj;
11012 fail:
11013 return NULL;
11014 }
11015
11016
11017 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11018 PyObject *resultobj = 0;
11019 wxRect2D *arg1 = (wxRect2D *) 0 ;
11020 wxDouble arg2 ;
11021 void *argp1 = 0 ;
11022 int res1 = 0 ;
11023 void *argp2 ;
11024 int res2 = 0 ;
11025 PyObject *swig_obj[2] ;
11026
11027 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11029 if (!SWIG_IsOK(res1)) {
11030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11031 }
11032 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11033 {
11034 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11035 if (!SWIG_IsOK(res2)) {
11036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11037 }
11038 if (!argp2) {
11039 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11040 } else {
11041 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11042 arg2 = *temp;
11043 if (SWIG_IsNewObj(res2)) delete temp;
11044 }
11045 }
11046 if (arg1) (arg1)->m_x = arg2;
11047
11048 resultobj = SWIG_Py_Void();
11049 return resultobj;
11050 fail:
11051 return NULL;
11052 }
11053
11054
11055 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11056 PyObject *resultobj = 0;
11057 wxRect2D *arg1 = (wxRect2D *) 0 ;
11058 wxDouble result;
11059 void *argp1 = 0 ;
11060 int res1 = 0 ;
11061 PyObject *swig_obj[1] ;
11062
11063 if (!args) SWIG_fail;
11064 swig_obj[0] = args;
11065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11066 if (!SWIG_IsOK(res1)) {
11067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11068 }
11069 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11070 result = ((arg1)->m_x);
11071 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11072 return resultobj;
11073 fail:
11074 return NULL;
11075 }
11076
11077
11078 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11079 PyObject *resultobj = 0;
11080 wxRect2D *arg1 = (wxRect2D *) 0 ;
11081 wxDouble arg2 ;
11082 void *argp1 = 0 ;
11083 int res1 = 0 ;
11084 void *argp2 ;
11085 int res2 = 0 ;
11086 PyObject *swig_obj[2] ;
11087
11088 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11090 if (!SWIG_IsOK(res1)) {
11091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11092 }
11093 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11094 {
11095 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11096 if (!SWIG_IsOK(res2)) {
11097 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11098 }
11099 if (!argp2) {
11100 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11101 } else {
11102 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11103 arg2 = *temp;
11104 if (SWIG_IsNewObj(res2)) delete temp;
11105 }
11106 }
11107 if (arg1) (arg1)->m_y = arg2;
11108
11109 resultobj = SWIG_Py_Void();
11110 return resultobj;
11111 fail:
11112 return NULL;
11113 }
11114
11115
11116 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11117 PyObject *resultobj = 0;
11118 wxRect2D *arg1 = (wxRect2D *) 0 ;
11119 wxDouble result;
11120 void *argp1 = 0 ;
11121 int res1 = 0 ;
11122 PyObject *swig_obj[1] ;
11123
11124 if (!args) SWIG_fail;
11125 swig_obj[0] = args;
11126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11127 if (!SWIG_IsOK(res1)) {
11128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11129 }
11130 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11131 result = ((arg1)->m_y);
11132 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11133 return resultobj;
11134 fail:
11135 return NULL;
11136 }
11137
11138
11139 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11140 PyObject *resultobj = 0;
11141 wxRect2D *arg1 = (wxRect2D *) 0 ;
11142 wxDouble arg2 ;
11143 void *argp1 = 0 ;
11144 int res1 = 0 ;
11145 void *argp2 ;
11146 int res2 = 0 ;
11147 PyObject *swig_obj[2] ;
11148
11149 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11151 if (!SWIG_IsOK(res1)) {
11152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11153 }
11154 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11155 {
11156 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11157 if (!SWIG_IsOK(res2)) {
11158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11159 }
11160 if (!argp2) {
11161 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11162 } else {
11163 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11164 arg2 = *temp;
11165 if (SWIG_IsNewObj(res2)) delete temp;
11166 }
11167 }
11168 if (arg1) (arg1)->m_width = arg2;
11169
11170 resultobj = SWIG_Py_Void();
11171 return resultobj;
11172 fail:
11173 return NULL;
11174 }
11175
11176
11177 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11178 PyObject *resultobj = 0;
11179 wxRect2D *arg1 = (wxRect2D *) 0 ;
11180 wxDouble result;
11181 void *argp1 = 0 ;
11182 int res1 = 0 ;
11183 PyObject *swig_obj[1] ;
11184
11185 if (!args) SWIG_fail;
11186 swig_obj[0] = args;
11187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11188 if (!SWIG_IsOK(res1)) {
11189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11190 }
11191 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11192 result = ((arg1)->m_width);
11193 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11194 return resultobj;
11195 fail:
11196 return NULL;
11197 }
11198
11199
11200 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11201 PyObject *resultobj = 0;
11202 wxRect2D *arg1 = (wxRect2D *) 0 ;
11203 wxDouble arg2 ;
11204 void *argp1 = 0 ;
11205 int res1 = 0 ;
11206 void *argp2 ;
11207 int res2 = 0 ;
11208 PyObject *swig_obj[2] ;
11209
11210 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11212 if (!SWIG_IsOK(res1)) {
11213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11214 }
11215 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11216 {
11217 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11218 if (!SWIG_IsOK(res2)) {
11219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11220 }
11221 if (!argp2) {
11222 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11223 } else {
11224 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11225 arg2 = *temp;
11226 if (SWIG_IsNewObj(res2)) delete temp;
11227 }
11228 }
11229 if (arg1) (arg1)->m_height = arg2;
11230
11231 resultobj = SWIG_Py_Void();
11232 return resultobj;
11233 fail:
11234 return NULL;
11235 }
11236
11237
11238 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11239 PyObject *resultobj = 0;
11240 wxRect2D *arg1 = (wxRect2D *) 0 ;
11241 wxDouble result;
11242 void *argp1 = 0 ;
11243 int res1 = 0 ;
11244 PyObject *swig_obj[1] ;
11245
11246 if (!args) SWIG_fail;
11247 swig_obj[0] = args;
11248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11249 if (!SWIG_IsOK(res1)) {
11250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11251 }
11252 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11253 result = ((arg1)->m_height);
11254 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11255 return resultobj;
11256 fail:
11257 return NULL;
11258 }
11259
11260
11261 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11262 PyObject *resultobj = 0;
11263 wxRect2D *arg1 = (wxRect2D *) 0 ;
11264 wxDouble arg2 = (wxDouble) 0 ;
11265 wxDouble arg3 = (wxDouble) 0 ;
11266 wxDouble arg4 = (wxDouble) 0 ;
11267 wxDouble arg5 = (wxDouble) 0 ;
11268 void *argp1 = 0 ;
11269 int res1 = 0 ;
11270 void *argp2 ;
11271 int res2 = 0 ;
11272 void *argp3 ;
11273 int res3 = 0 ;
11274 void *argp4 ;
11275 int res4 = 0 ;
11276 void *argp5 ;
11277 int res5 = 0 ;
11278 PyObject * obj0 = 0 ;
11279 PyObject * obj1 = 0 ;
11280 PyObject * obj2 = 0 ;
11281 PyObject * obj3 = 0 ;
11282 PyObject * obj4 = 0 ;
11283 char * kwnames[] = {
11284 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11285 };
11286
11287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11289 if (!SWIG_IsOK(res1)) {
11290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11291 }
11292 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11293 if (obj1) {
11294 {
11295 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11296 if (!SWIG_IsOK(res2)) {
11297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11298 }
11299 if (!argp2) {
11300 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11301 } else {
11302 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11303 arg2 = *temp;
11304 if (SWIG_IsNewObj(res2)) delete temp;
11305 }
11306 }
11307 }
11308 if (obj2) {
11309 {
11310 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11311 if (!SWIG_IsOK(res3)) {
11312 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11313 }
11314 if (!argp3) {
11315 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11316 } else {
11317 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11318 arg3 = *temp;
11319 if (SWIG_IsNewObj(res3)) delete temp;
11320 }
11321 }
11322 }
11323 if (obj3) {
11324 {
11325 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11326 if (!SWIG_IsOK(res4)) {
11327 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11328 }
11329 if (!argp4) {
11330 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11331 } else {
11332 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11333 arg4 = *temp;
11334 if (SWIG_IsNewObj(res4)) delete temp;
11335 }
11336 }
11337 }
11338 if (obj4) {
11339 {
11340 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11341 if (!SWIG_IsOK(res5)) {
11342 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11343 }
11344 if (!argp5) {
11345 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11346 } else {
11347 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11348 arg5 = *temp;
11349 if (SWIG_IsNewObj(res5)) delete temp;
11350 }
11351 }
11352 }
11353 {
11354 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11355 if (PyErr_Occurred()) SWIG_fail;
11356 }
11357 resultobj = SWIG_Py_Void();
11358 return resultobj;
11359 fail:
11360 return NULL;
11361 }
11362
11363
11364 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11365 PyObject *resultobj = 0;
11366 wxRect2D *arg1 = (wxRect2D *) 0 ;
11367 PyObject *result = 0 ;
11368 void *argp1 = 0 ;
11369 int res1 = 0 ;
11370 PyObject *swig_obj[1] ;
11371
11372 if (!args) SWIG_fail;
11373 swig_obj[0] = args;
11374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11375 if (!SWIG_IsOK(res1)) {
11376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11377 }
11378 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11379 {
11380 result = (PyObject *)wxRect2D_Get(arg1);
11381 if (PyErr_Occurred()) SWIG_fail;
11382 }
11383 resultobj = result;
11384 return resultobj;
11385 fail:
11386 return NULL;
11387 }
11388
11389
11390 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11391 PyObject *obj;
11392 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11393 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11394 return SWIG_Py_Void();
11395 }
11396
11397 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11398 return SWIG_Python_InitShadowInstance(args);
11399 }
11400
11401 SWIGINTERN int DefaultPosition_set(PyObject *) {
11402 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11403 return 1;
11404 }
11405
11406
11407 SWIGINTERN PyObject *DefaultPosition_get(void) {
11408 PyObject *pyobj = 0;
11409
11410 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11411 return pyobj;
11412 }
11413
11414
11415 SWIGINTERN int DefaultSize_set(PyObject *) {
11416 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11417 return 1;
11418 }
11419
11420
11421 SWIGINTERN PyObject *DefaultSize_get(void) {
11422 PyObject *pyobj = 0;
11423
11424 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11425 return pyobj;
11426 }
11427
11428
11429 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11430 PyObject *resultobj = 0;
11431 PyObject *arg1 = (PyObject *) 0 ;
11432 wxPyInputStream *result = 0 ;
11433 PyObject * obj0 = 0 ;
11434 char * kwnames[] = {
11435 (char *) "p", NULL
11436 };
11437
11438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11439 arg1 = obj0;
11440 {
11441 PyThreadState* __tstate = wxPyBeginAllowThreads();
11442 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11443 wxPyEndAllowThreads(__tstate);
11444 if (PyErr_Occurred()) SWIG_fail;
11445 }
11446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11447 return resultobj;
11448 fail:
11449 return NULL;
11450 }
11451
11452
11453 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11454 PyObject *resultobj = 0;
11455 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11456 void *argp1 = 0 ;
11457 int res1 = 0 ;
11458 PyObject *swig_obj[1] ;
11459
11460 if (!args) SWIG_fail;
11461 swig_obj[0] = args;
11462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
11463 if (!SWIG_IsOK(res1)) {
11464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11465 }
11466 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11467 {
11468 PyThreadState* __tstate = wxPyBeginAllowThreads();
11469 delete arg1;
11470
11471 wxPyEndAllowThreads(__tstate);
11472 if (PyErr_Occurred()) SWIG_fail;
11473 }
11474 resultobj = SWIG_Py_Void();
11475 return resultobj;
11476 fail:
11477 return NULL;
11478 }
11479
11480
11481 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11482 PyObject *resultobj = 0;
11483 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11484 void *argp1 = 0 ;
11485 int res1 = 0 ;
11486 PyObject *swig_obj[1] ;
11487
11488 if (!args) SWIG_fail;
11489 swig_obj[0] = args;
11490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11491 if (!SWIG_IsOK(res1)) {
11492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11493 }
11494 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11495 {
11496 PyThreadState* __tstate = wxPyBeginAllowThreads();
11497 (arg1)->close();
11498 wxPyEndAllowThreads(__tstate);
11499 if (PyErr_Occurred()) SWIG_fail;
11500 }
11501 resultobj = SWIG_Py_Void();
11502 return resultobj;
11503 fail:
11504 return NULL;
11505 }
11506
11507
11508 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11509 PyObject *resultobj = 0;
11510 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11511 void *argp1 = 0 ;
11512 int res1 = 0 ;
11513 PyObject *swig_obj[1] ;
11514
11515 if (!args) SWIG_fail;
11516 swig_obj[0] = args;
11517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11518 if (!SWIG_IsOK(res1)) {
11519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11520 }
11521 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11522 {
11523 PyThreadState* __tstate = wxPyBeginAllowThreads();
11524 (arg1)->flush();
11525 wxPyEndAllowThreads(__tstate);
11526 if (PyErr_Occurred()) SWIG_fail;
11527 }
11528 resultobj = SWIG_Py_Void();
11529 return resultobj;
11530 fail:
11531 return NULL;
11532 }
11533
11534
11535 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11536 PyObject *resultobj = 0;
11537 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11538 bool result;
11539 void *argp1 = 0 ;
11540 int res1 = 0 ;
11541 PyObject *swig_obj[1] ;
11542
11543 if (!args) SWIG_fail;
11544 swig_obj[0] = args;
11545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11546 if (!SWIG_IsOK(res1)) {
11547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11548 }
11549 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11550 {
11551 PyThreadState* __tstate = wxPyBeginAllowThreads();
11552 result = (bool)(arg1)->eof();
11553 wxPyEndAllowThreads(__tstate);
11554 if (PyErr_Occurred()) SWIG_fail;
11555 }
11556 {
11557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11558 }
11559 return resultobj;
11560 fail:
11561 return NULL;
11562 }
11563
11564
11565 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11566 PyObject *resultobj = 0;
11567 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11568 int arg2 = (int) -1 ;
11569 PyObject *result = 0 ;
11570 void *argp1 = 0 ;
11571 int res1 = 0 ;
11572 int val2 ;
11573 int ecode2 = 0 ;
11574 PyObject * obj0 = 0 ;
11575 PyObject * obj1 = 0 ;
11576 char * kwnames[] = {
11577 (char *) "self",(char *) "size", NULL
11578 };
11579
11580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11582 if (!SWIG_IsOK(res1)) {
11583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11584 }
11585 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11586 if (obj1) {
11587 ecode2 = SWIG_AsVal_int(obj1, &val2);
11588 if (!SWIG_IsOK(ecode2)) {
11589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11590 }
11591 arg2 = static_cast< int >(val2);
11592 }
11593 {
11594 PyThreadState* __tstate = wxPyBeginAllowThreads();
11595 result = (PyObject *)(arg1)->read(arg2);
11596 wxPyEndAllowThreads(__tstate);
11597 if (PyErr_Occurred()) SWIG_fail;
11598 }
11599 resultobj = result;
11600 return resultobj;
11601 fail:
11602 return NULL;
11603 }
11604
11605
11606 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11607 PyObject *resultobj = 0;
11608 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11609 int arg2 = (int) -1 ;
11610 PyObject *result = 0 ;
11611 void *argp1 = 0 ;
11612 int res1 = 0 ;
11613 int val2 ;
11614 int ecode2 = 0 ;
11615 PyObject * obj0 = 0 ;
11616 PyObject * obj1 = 0 ;
11617 char * kwnames[] = {
11618 (char *) "self",(char *) "size", NULL
11619 };
11620
11621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11623 if (!SWIG_IsOK(res1)) {
11624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11625 }
11626 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11627 if (obj1) {
11628 ecode2 = SWIG_AsVal_int(obj1, &val2);
11629 if (!SWIG_IsOK(ecode2)) {
11630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11631 }
11632 arg2 = static_cast< int >(val2);
11633 }
11634 {
11635 PyThreadState* __tstate = wxPyBeginAllowThreads();
11636 result = (PyObject *)(arg1)->readline(arg2);
11637 wxPyEndAllowThreads(__tstate);
11638 if (PyErr_Occurred()) SWIG_fail;
11639 }
11640 resultobj = result;
11641 return resultobj;
11642 fail:
11643 return NULL;
11644 }
11645
11646
11647 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11648 PyObject *resultobj = 0;
11649 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11650 int arg2 = (int) -1 ;
11651 PyObject *result = 0 ;
11652 void *argp1 = 0 ;
11653 int res1 = 0 ;
11654 int val2 ;
11655 int ecode2 = 0 ;
11656 PyObject * obj0 = 0 ;
11657 PyObject * obj1 = 0 ;
11658 char * kwnames[] = {
11659 (char *) "self",(char *) "sizehint", NULL
11660 };
11661
11662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11664 if (!SWIG_IsOK(res1)) {
11665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11666 }
11667 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11668 if (obj1) {
11669 ecode2 = SWIG_AsVal_int(obj1, &val2);
11670 if (!SWIG_IsOK(ecode2)) {
11671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11672 }
11673 arg2 = static_cast< int >(val2);
11674 }
11675 {
11676 PyThreadState* __tstate = wxPyBeginAllowThreads();
11677 result = (PyObject *)(arg1)->readlines(arg2);
11678 wxPyEndAllowThreads(__tstate);
11679 if (PyErr_Occurred()) SWIG_fail;
11680 }
11681 resultobj = result;
11682 return resultobj;
11683 fail:
11684 return NULL;
11685 }
11686
11687
11688 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11689 PyObject *resultobj = 0;
11690 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11691 int arg2 ;
11692 int arg3 = (int) 0 ;
11693 void *argp1 = 0 ;
11694 int res1 = 0 ;
11695 int val2 ;
11696 int ecode2 = 0 ;
11697 int val3 ;
11698 int ecode3 = 0 ;
11699 PyObject * obj0 = 0 ;
11700 PyObject * obj1 = 0 ;
11701 PyObject * obj2 = 0 ;
11702 char * kwnames[] = {
11703 (char *) "self",(char *) "offset",(char *) "whence", NULL
11704 };
11705
11706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11708 if (!SWIG_IsOK(res1)) {
11709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11710 }
11711 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11712 ecode2 = SWIG_AsVal_int(obj1, &val2);
11713 if (!SWIG_IsOK(ecode2)) {
11714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11715 }
11716 arg2 = static_cast< int >(val2);
11717 if (obj2) {
11718 ecode3 = SWIG_AsVal_int(obj2, &val3);
11719 if (!SWIG_IsOK(ecode3)) {
11720 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11721 }
11722 arg3 = static_cast< int >(val3);
11723 }
11724 {
11725 PyThreadState* __tstate = wxPyBeginAllowThreads();
11726 (arg1)->seek(arg2,arg3);
11727 wxPyEndAllowThreads(__tstate);
11728 if (PyErr_Occurred()) SWIG_fail;
11729 }
11730 resultobj = SWIG_Py_Void();
11731 return resultobj;
11732 fail:
11733 return NULL;
11734 }
11735
11736
11737 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11738 PyObject *resultobj = 0;
11739 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11740 int result;
11741 void *argp1 = 0 ;
11742 int res1 = 0 ;
11743 PyObject *swig_obj[1] ;
11744
11745 if (!args) SWIG_fail;
11746 swig_obj[0] = args;
11747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11748 if (!SWIG_IsOK(res1)) {
11749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11750 }
11751 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11752 {
11753 PyThreadState* __tstate = wxPyBeginAllowThreads();
11754 result = (int)(arg1)->tell();
11755 wxPyEndAllowThreads(__tstate);
11756 if (PyErr_Occurred()) SWIG_fail;
11757 }
11758 resultobj = SWIG_From_int(static_cast< int >(result));
11759 return resultobj;
11760 fail:
11761 return NULL;
11762 }
11763
11764
11765 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11766 PyObject *resultobj = 0;
11767 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11768 char result;
11769 void *argp1 = 0 ;
11770 int res1 = 0 ;
11771 PyObject *swig_obj[1] ;
11772
11773 if (!args) SWIG_fail;
11774 swig_obj[0] = args;
11775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11776 if (!SWIG_IsOK(res1)) {
11777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11778 }
11779 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11780 {
11781 PyThreadState* __tstate = wxPyBeginAllowThreads();
11782 result = (char)(arg1)->Peek();
11783 wxPyEndAllowThreads(__tstate);
11784 if (PyErr_Occurred()) SWIG_fail;
11785 }
11786 resultobj = SWIG_From_char(static_cast< char >(result));
11787 return resultobj;
11788 fail:
11789 return NULL;
11790 }
11791
11792
11793 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11794 PyObject *resultobj = 0;
11795 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11796 char result;
11797 void *argp1 = 0 ;
11798 int res1 = 0 ;
11799 PyObject *swig_obj[1] ;
11800
11801 if (!args) SWIG_fail;
11802 swig_obj[0] = args;
11803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11804 if (!SWIG_IsOK(res1)) {
11805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11806 }
11807 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11808 {
11809 PyThreadState* __tstate = wxPyBeginAllowThreads();
11810 result = (char)(arg1)->GetC();
11811 wxPyEndAllowThreads(__tstate);
11812 if (PyErr_Occurred()) SWIG_fail;
11813 }
11814 resultobj = SWIG_From_char(static_cast< char >(result));
11815 return resultobj;
11816 fail:
11817 return NULL;
11818 }
11819
11820
11821 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11822 PyObject *resultobj = 0;
11823 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11824 size_t result;
11825 void *argp1 = 0 ;
11826 int res1 = 0 ;
11827 PyObject *swig_obj[1] ;
11828
11829 if (!args) SWIG_fail;
11830 swig_obj[0] = args;
11831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11832 if (!SWIG_IsOK(res1)) {
11833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11834 }
11835 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11836 {
11837 PyThreadState* __tstate = wxPyBeginAllowThreads();
11838 result = (size_t)(arg1)->LastRead();
11839 wxPyEndAllowThreads(__tstate);
11840 if (PyErr_Occurred()) SWIG_fail;
11841 }
11842 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11843 return resultobj;
11844 fail:
11845 return NULL;
11846 }
11847
11848
11849 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11850 PyObject *resultobj = 0;
11851 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11852 bool result;
11853 void *argp1 = 0 ;
11854 int res1 = 0 ;
11855 PyObject *swig_obj[1] ;
11856
11857 if (!args) SWIG_fail;
11858 swig_obj[0] = args;
11859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11860 if (!SWIG_IsOK(res1)) {
11861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11862 }
11863 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11864 {
11865 PyThreadState* __tstate = wxPyBeginAllowThreads();
11866 result = (bool)(arg1)->CanRead();
11867 wxPyEndAllowThreads(__tstate);
11868 if (PyErr_Occurred()) SWIG_fail;
11869 }
11870 {
11871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11872 }
11873 return resultobj;
11874 fail:
11875 return NULL;
11876 }
11877
11878
11879 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11880 PyObject *resultobj = 0;
11881 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11882 bool result;
11883 void *argp1 = 0 ;
11884 int res1 = 0 ;
11885 PyObject *swig_obj[1] ;
11886
11887 if (!args) SWIG_fail;
11888 swig_obj[0] = args;
11889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11890 if (!SWIG_IsOK(res1)) {
11891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11892 }
11893 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11894 {
11895 PyThreadState* __tstate = wxPyBeginAllowThreads();
11896 result = (bool)(arg1)->Eof();
11897 wxPyEndAllowThreads(__tstate);
11898 if (PyErr_Occurred()) SWIG_fail;
11899 }
11900 {
11901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11902 }
11903 return resultobj;
11904 fail:
11905 return NULL;
11906 }
11907
11908
11909 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11910 PyObject *resultobj = 0;
11911 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11912 char arg2 ;
11913 bool result;
11914 void *argp1 = 0 ;
11915 int res1 = 0 ;
11916 char val2 ;
11917 int ecode2 = 0 ;
11918 PyObject * obj0 = 0 ;
11919 PyObject * obj1 = 0 ;
11920 char * kwnames[] = {
11921 (char *) "self",(char *) "c", NULL
11922 };
11923
11924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11926 if (!SWIG_IsOK(res1)) {
11927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11928 }
11929 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11930 ecode2 = SWIG_AsVal_char(obj1, &val2);
11931 if (!SWIG_IsOK(ecode2)) {
11932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
11933 }
11934 arg2 = static_cast< char >(val2);
11935 {
11936 PyThreadState* __tstate = wxPyBeginAllowThreads();
11937 result = (bool)(arg1)->Ungetch(arg2);
11938 wxPyEndAllowThreads(__tstate);
11939 if (PyErr_Occurred()) SWIG_fail;
11940 }
11941 {
11942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11943 }
11944 return resultobj;
11945 fail:
11946 return NULL;
11947 }
11948
11949
11950 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11951 PyObject *resultobj = 0;
11952 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11953 long arg2 ;
11954 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
11955 long result;
11956 void *argp1 = 0 ;
11957 int res1 = 0 ;
11958 long val2 ;
11959 int ecode2 = 0 ;
11960 int val3 ;
11961 int ecode3 = 0 ;
11962 PyObject * obj0 = 0 ;
11963 PyObject * obj1 = 0 ;
11964 PyObject * obj2 = 0 ;
11965 char * kwnames[] = {
11966 (char *) "self",(char *) "pos",(char *) "mode", NULL
11967 };
11968
11969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11971 if (!SWIG_IsOK(res1)) {
11972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11973 }
11974 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11975 ecode2 = SWIG_AsVal_long(obj1, &val2);
11976 if (!SWIG_IsOK(ecode2)) {
11977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
11978 }
11979 arg2 = static_cast< long >(val2);
11980 if (obj2) {
11981 ecode3 = SWIG_AsVal_int(obj2, &val3);
11982 if (!SWIG_IsOK(ecode3)) {
11983 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
11984 }
11985 arg3 = static_cast< wxSeekMode >(val3);
11986 }
11987 {
11988 PyThreadState* __tstate = wxPyBeginAllowThreads();
11989 result = (long)(arg1)->SeekI(arg2,arg3);
11990 wxPyEndAllowThreads(__tstate);
11991 if (PyErr_Occurred()) SWIG_fail;
11992 }
11993 resultobj = SWIG_From_long(static_cast< long >(result));
11994 return resultobj;
11995 fail:
11996 return NULL;
11997 }
11998
11999
12000 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12001 PyObject *resultobj = 0;
12002 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12003 long result;
12004 void *argp1 = 0 ;
12005 int res1 = 0 ;
12006 PyObject *swig_obj[1] ;
12007
12008 if (!args) SWIG_fail;
12009 swig_obj[0] = args;
12010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12011 if (!SWIG_IsOK(res1)) {
12012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12013 }
12014 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12015 {
12016 PyThreadState* __tstate = wxPyBeginAllowThreads();
12017 result = (long)(arg1)->TellI();
12018 wxPyEndAllowThreads(__tstate);
12019 if (PyErr_Occurred()) SWIG_fail;
12020 }
12021 resultobj = SWIG_From_long(static_cast< long >(result));
12022 return resultobj;
12023 fail:
12024 return NULL;
12025 }
12026
12027
12028 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12029 PyObject *obj;
12030 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12031 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12032 return SWIG_Py_Void();
12033 }
12034
12035 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12036 return SWIG_Python_InitShadowInstance(args);
12037 }
12038
12039 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12040 PyObject *resultobj = 0;
12041 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12042 PyObject *arg2 = (PyObject *) 0 ;
12043 void *argp1 = 0 ;
12044 int res1 = 0 ;
12045 PyObject * obj0 = 0 ;
12046 PyObject * obj1 = 0 ;
12047 char * kwnames[] = {
12048 (char *) "self",(char *) "obj", NULL
12049 };
12050
12051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12053 if (!SWIG_IsOK(res1)) {
12054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12055 }
12056 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12057 arg2 = obj1;
12058 {
12059 PyThreadState* __tstate = wxPyBeginAllowThreads();
12060 wxOutputStream_write(arg1,arg2);
12061 wxPyEndAllowThreads(__tstate);
12062 if (PyErr_Occurred()) SWIG_fail;
12063 }
12064 resultobj = SWIG_Py_Void();
12065 return resultobj;
12066 fail:
12067 return NULL;
12068 }
12069
12070
12071 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12072 PyObject *resultobj = 0;
12073 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12074 size_t result;
12075 void *argp1 = 0 ;
12076 int res1 = 0 ;
12077 PyObject *swig_obj[1] ;
12078
12079 if (!args) SWIG_fail;
12080 swig_obj[0] = args;
12081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12082 if (!SWIG_IsOK(res1)) {
12083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12084 }
12085 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12086 {
12087 PyThreadState* __tstate = wxPyBeginAllowThreads();
12088 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12089 wxPyEndAllowThreads(__tstate);
12090 if (PyErr_Occurred()) SWIG_fail;
12091 }
12092 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12093 return resultobj;
12094 fail:
12095 return NULL;
12096 }
12097
12098
12099 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12100 PyObject *obj;
12101 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12102 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12103 return SWIG_Py_Void();
12104 }
12105
12106 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12107 PyObject *resultobj = 0;
12108 wxInputStream *arg1 = (wxInputStream *) 0 ;
12109 wxString *arg2 = 0 ;
12110 wxString *arg3 = 0 ;
12111 wxString *arg4 = 0 ;
12112 wxDateTime arg5 ;
12113 wxFSFile *result = 0 ;
12114 wxPyInputStream *temp1 ;
12115 bool temp2 = false ;
12116 bool temp3 = false ;
12117 bool temp4 = false ;
12118 void *argp5 ;
12119 int res5 = 0 ;
12120 PyObject * obj0 = 0 ;
12121 PyObject * obj1 = 0 ;
12122 PyObject * obj2 = 0 ;
12123 PyObject * obj3 = 0 ;
12124 PyObject * obj4 = 0 ;
12125 char * kwnames[] = {
12126 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12127 };
12128
12129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12130 {
12131 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12132 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12133 } else {
12134 PyErr_Clear(); // clear the failure of the wxPyConvert above
12135 arg1 = wxPyCBInputStream_create(obj0, true);
12136 if (arg1 == NULL) {
12137 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12138 SWIG_fail;
12139 }
12140 }
12141 }
12142 {
12143 arg2 = wxString_in_helper(obj1);
12144 if (arg2 == NULL) SWIG_fail;
12145 temp2 = true;
12146 }
12147 {
12148 arg3 = wxString_in_helper(obj2);
12149 if (arg3 == NULL) SWIG_fail;
12150 temp3 = true;
12151 }
12152 {
12153 arg4 = wxString_in_helper(obj3);
12154 if (arg4 == NULL) SWIG_fail;
12155 temp4 = true;
12156 }
12157 {
12158 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12159 if (!SWIG_IsOK(res5)) {
12160 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12161 }
12162 if (!argp5) {
12163 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12164 } else {
12165 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12166 arg5 = *temp;
12167 if (SWIG_IsNewObj(res5)) delete temp;
12168 }
12169 }
12170 {
12171 PyThreadState* __tstate = wxPyBeginAllowThreads();
12172 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12173 wxPyEndAllowThreads(__tstate);
12174 if (PyErr_Occurred()) SWIG_fail;
12175 }
12176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12177 {
12178 if (temp2)
12179 delete arg2;
12180 }
12181 {
12182 if (temp3)
12183 delete arg3;
12184 }
12185 {
12186 if (temp4)
12187 delete arg4;
12188 }
12189 return resultobj;
12190 fail:
12191 {
12192 if (temp2)
12193 delete arg2;
12194 }
12195 {
12196 if (temp3)
12197 delete arg3;
12198 }
12199 {
12200 if (temp4)
12201 delete arg4;
12202 }
12203 return NULL;
12204 }
12205
12206
12207 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12208 PyObject *resultobj = 0;
12209 wxFSFile *arg1 = (wxFSFile *) 0 ;
12210 void *argp1 = 0 ;
12211 int res1 = 0 ;
12212 PyObject *swig_obj[1] ;
12213
12214 if (!args) SWIG_fail;
12215 swig_obj[0] = args;
12216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12217 if (!SWIG_IsOK(res1)) {
12218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12219 }
12220 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12221 {
12222 PyThreadState* __tstate = wxPyBeginAllowThreads();
12223 delete arg1;
12224
12225 wxPyEndAllowThreads(__tstate);
12226 if (PyErr_Occurred()) SWIG_fail;
12227 }
12228 resultobj = SWIG_Py_Void();
12229 return resultobj;
12230 fail:
12231 return NULL;
12232 }
12233
12234
12235 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12236 PyObject *resultobj = 0;
12237 wxFSFile *arg1 = (wxFSFile *) 0 ;
12238 wxInputStream *result = 0 ;
12239 void *argp1 = 0 ;
12240 int res1 = 0 ;
12241 PyObject *swig_obj[1] ;
12242
12243 if (!args) SWIG_fail;
12244 swig_obj[0] = args;
12245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12246 if (!SWIG_IsOK(res1)) {
12247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12248 }
12249 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12250 {
12251 PyThreadState* __tstate = wxPyBeginAllowThreads();
12252 result = (wxInputStream *)(arg1)->GetStream();
12253 wxPyEndAllowThreads(__tstate);
12254 if (PyErr_Occurred()) SWIG_fail;
12255 }
12256 {
12257 wxPyInputStream * _ptr = NULL;
12258
12259 if (result) {
12260 _ptr = new wxPyInputStream(result);
12261 }
12262 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12263 }
12264 return resultobj;
12265 fail:
12266 return NULL;
12267 }
12268
12269
12270 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12271 PyObject *resultobj = 0;
12272 wxFSFile *arg1 = (wxFSFile *) 0 ;
12273 void *argp1 = 0 ;
12274 int res1 = 0 ;
12275 PyObject *swig_obj[1] ;
12276
12277 if (!args) SWIG_fail;
12278 swig_obj[0] = args;
12279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12280 if (!SWIG_IsOK(res1)) {
12281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12282 }
12283 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12284 {
12285 PyThreadState* __tstate = wxPyBeginAllowThreads();
12286 (arg1)->DetachStream();
12287 wxPyEndAllowThreads(__tstate);
12288 if (PyErr_Occurred()) SWIG_fail;
12289 }
12290 resultobj = SWIG_Py_Void();
12291 return resultobj;
12292 fail:
12293 return NULL;
12294 }
12295
12296
12297 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12298 PyObject *resultobj = 0;
12299 wxFSFile *arg1 = (wxFSFile *) 0 ;
12300 wxString *result = 0 ;
12301 void *argp1 = 0 ;
12302 int res1 = 0 ;
12303 PyObject *swig_obj[1] ;
12304
12305 if (!args) SWIG_fail;
12306 swig_obj[0] = args;
12307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12308 if (!SWIG_IsOK(res1)) {
12309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12310 }
12311 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12312 {
12313 PyThreadState* __tstate = wxPyBeginAllowThreads();
12314 {
12315 wxString const &_result_ref = (arg1)->GetMimeType();
12316 result = (wxString *) &_result_ref;
12317 }
12318 wxPyEndAllowThreads(__tstate);
12319 if (PyErr_Occurred()) SWIG_fail;
12320 }
12321 {
12322 #if wxUSE_UNICODE
12323 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12324 #else
12325 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12326 #endif
12327 }
12328 return resultobj;
12329 fail:
12330 return NULL;
12331 }
12332
12333
12334 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12335 PyObject *resultobj = 0;
12336 wxFSFile *arg1 = (wxFSFile *) 0 ;
12337 wxString *result = 0 ;
12338 void *argp1 = 0 ;
12339 int res1 = 0 ;
12340 PyObject *swig_obj[1] ;
12341
12342 if (!args) SWIG_fail;
12343 swig_obj[0] = args;
12344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12345 if (!SWIG_IsOK(res1)) {
12346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12347 }
12348 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12349 {
12350 PyThreadState* __tstate = wxPyBeginAllowThreads();
12351 {
12352 wxString const &_result_ref = (arg1)->GetLocation();
12353 result = (wxString *) &_result_ref;
12354 }
12355 wxPyEndAllowThreads(__tstate);
12356 if (PyErr_Occurred()) SWIG_fail;
12357 }
12358 {
12359 #if wxUSE_UNICODE
12360 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12361 #else
12362 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12363 #endif
12364 }
12365 return resultobj;
12366 fail:
12367 return NULL;
12368 }
12369
12370
12371 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12372 PyObject *resultobj = 0;
12373 wxFSFile *arg1 = (wxFSFile *) 0 ;
12374 wxString *result = 0 ;
12375 void *argp1 = 0 ;
12376 int res1 = 0 ;
12377 PyObject *swig_obj[1] ;
12378
12379 if (!args) SWIG_fail;
12380 swig_obj[0] = args;
12381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12382 if (!SWIG_IsOK(res1)) {
12383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12384 }
12385 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12386 {
12387 PyThreadState* __tstate = wxPyBeginAllowThreads();
12388 {
12389 wxString const &_result_ref = (arg1)->GetAnchor();
12390 result = (wxString *) &_result_ref;
12391 }
12392 wxPyEndAllowThreads(__tstate);
12393 if (PyErr_Occurred()) SWIG_fail;
12394 }
12395 {
12396 #if wxUSE_UNICODE
12397 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12398 #else
12399 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12400 #endif
12401 }
12402 return resultobj;
12403 fail:
12404 return NULL;
12405 }
12406
12407
12408 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12409 PyObject *resultobj = 0;
12410 wxFSFile *arg1 = (wxFSFile *) 0 ;
12411 wxDateTime result;
12412 void *argp1 = 0 ;
12413 int res1 = 0 ;
12414 PyObject *swig_obj[1] ;
12415
12416 if (!args) SWIG_fail;
12417 swig_obj[0] = args;
12418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12419 if (!SWIG_IsOK(res1)) {
12420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12421 }
12422 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12423 {
12424 PyThreadState* __tstate = wxPyBeginAllowThreads();
12425 result = (arg1)->GetModificationTime();
12426 wxPyEndAllowThreads(__tstate);
12427 if (PyErr_Occurred()) SWIG_fail;
12428 }
12429 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12430 return resultobj;
12431 fail:
12432 return NULL;
12433 }
12434
12435
12436 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12437 PyObject *obj;
12438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12439 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12440 return SWIG_Py_Void();
12441 }
12442
12443 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12444 return SWIG_Python_InitShadowInstance(args);
12445 }
12446
12447 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12448 PyObject *resultobj = 0;
12449 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12450 void *argp1 = 0 ;
12451 int res1 = 0 ;
12452 PyObject *swig_obj[1] ;
12453
12454 if (!args) SWIG_fail;
12455 swig_obj[0] = args;
12456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12457 if (!SWIG_IsOK(res1)) {
12458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12459 }
12460 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12461 {
12462 PyThreadState* __tstate = wxPyBeginAllowThreads();
12463 delete arg1;
12464
12465 wxPyEndAllowThreads(__tstate);
12466 if (PyErr_Occurred()) SWIG_fail;
12467 }
12468 resultobj = SWIG_Py_Void();
12469 return resultobj;
12470 fail:
12471 return NULL;
12472 }
12473
12474
12475 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12476 PyObject *obj;
12477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12478 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12479 return SWIG_Py_Void();
12480 }
12481
12482 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12483 PyObject *resultobj = 0;
12484 wxPyFileSystemHandler *result = 0 ;
12485
12486 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12487 {
12488 PyThreadState* __tstate = wxPyBeginAllowThreads();
12489 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12490 wxPyEndAllowThreads(__tstate);
12491 if (PyErr_Occurred()) SWIG_fail;
12492 }
12493 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12494 return resultobj;
12495 fail:
12496 return NULL;
12497 }
12498
12499
12500 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12501 PyObject *resultobj = 0;
12502 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12503 PyObject *arg2 = (PyObject *) 0 ;
12504 PyObject *arg3 = (PyObject *) 0 ;
12505 void *argp1 = 0 ;
12506 int res1 = 0 ;
12507 PyObject * obj0 = 0 ;
12508 PyObject * obj1 = 0 ;
12509 PyObject * obj2 = 0 ;
12510 char * kwnames[] = {
12511 (char *) "self",(char *) "self",(char *) "_class", NULL
12512 };
12513
12514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12516 if (!SWIG_IsOK(res1)) {
12517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12518 }
12519 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12520 arg2 = obj1;
12521 arg3 = obj2;
12522 {
12523 PyThreadState* __tstate = wxPyBeginAllowThreads();
12524 (arg1)->_setCallbackInfo(arg2,arg3);
12525 wxPyEndAllowThreads(__tstate);
12526 if (PyErr_Occurred()) SWIG_fail;
12527 }
12528 resultobj = SWIG_Py_Void();
12529 return resultobj;
12530 fail:
12531 return NULL;
12532 }
12533
12534
12535 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12536 PyObject *resultobj = 0;
12537 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12538 wxString *arg2 = 0 ;
12539 bool result;
12540 void *argp1 = 0 ;
12541 int res1 = 0 ;
12542 bool temp2 = false ;
12543 PyObject * obj0 = 0 ;
12544 PyObject * obj1 = 0 ;
12545 char * kwnames[] = {
12546 (char *) "self",(char *) "location", NULL
12547 };
12548
12549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12551 if (!SWIG_IsOK(res1)) {
12552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12553 }
12554 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12555 {
12556 arg2 = wxString_in_helper(obj1);
12557 if (arg2 == NULL) SWIG_fail;
12558 temp2 = true;
12559 }
12560 {
12561 PyThreadState* __tstate = wxPyBeginAllowThreads();
12562 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12563 wxPyEndAllowThreads(__tstate);
12564 if (PyErr_Occurred()) SWIG_fail;
12565 }
12566 {
12567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12568 }
12569 {
12570 if (temp2)
12571 delete arg2;
12572 }
12573 return resultobj;
12574 fail:
12575 {
12576 if (temp2)
12577 delete arg2;
12578 }
12579 return NULL;
12580 }
12581
12582
12583 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12584 PyObject *resultobj = 0;
12585 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12586 wxFileSystem *arg2 = 0 ;
12587 wxString *arg3 = 0 ;
12588 wxFSFile *result = 0 ;
12589 void *argp1 = 0 ;
12590 int res1 = 0 ;
12591 void *argp2 = 0 ;
12592 int res2 = 0 ;
12593 bool temp3 = false ;
12594 PyObject * obj0 = 0 ;
12595 PyObject * obj1 = 0 ;
12596 PyObject * obj2 = 0 ;
12597 char * kwnames[] = {
12598 (char *) "self",(char *) "fs",(char *) "location", NULL
12599 };
12600
12601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12603 if (!SWIG_IsOK(res1)) {
12604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12605 }
12606 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12607 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12608 if (!SWIG_IsOK(res2)) {
12609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12610 }
12611 if (!argp2) {
12612 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12613 }
12614 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12615 {
12616 arg3 = wxString_in_helper(obj2);
12617 if (arg3 == NULL) SWIG_fail;
12618 temp3 = true;
12619 }
12620 {
12621 PyThreadState* __tstate = wxPyBeginAllowThreads();
12622 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12623 wxPyEndAllowThreads(__tstate);
12624 if (PyErr_Occurred()) SWIG_fail;
12625 }
12626 {
12627 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
12628 }
12629 {
12630 if (temp3)
12631 delete arg3;
12632 }
12633 return resultobj;
12634 fail:
12635 {
12636 if (temp3)
12637 delete arg3;
12638 }
12639 return NULL;
12640 }
12641
12642
12643 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12644 PyObject *resultobj = 0;
12645 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12646 wxString *arg2 = 0 ;
12647 int arg3 = (int) 0 ;
12648 wxString result;
12649 void *argp1 = 0 ;
12650 int res1 = 0 ;
12651 bool temp2 = false ;
12652 int val3 ;
12653 int ecode3 = 0 ;
12654 PyObject * obj0 = 0 ;
12655 PyObject * obj1 = 0 ;
12656 PyObject * obj2 = 0 ;
12657 char * kwnames[] = {
12658 (char *) "self",(char *) "spec",(char *) "flags", NULL
12659 };
12660
12661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12663 if (!SWIG_IsOK(res1)) {
12664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12665 }
12666 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12667 {
12668 arg2 = wxString_in_helper(obj1);
12669 if (arg2 == NULL) SWIG_fail;
12670 temp2 = true;
12671 }
12672 if (obj2) {
12673 ecode3 = SWIG_AsVal_int(obj2, &val3);
12674 if (!SWIG_IsOK(ecode3)) {
12675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12676 }
12677 arg3 = static_cast< int >(val3);
12678 }
12679 {
12680 PyThreadState* __tstate = wxPyBeginAllowThreads();
12681 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12682 wxPyEndAllowThreads(__tstate);
12683 if (PyErr_Occurred()) SWIG_fail;
12684 }
12685 {
12686 #if wxUSE_UNICODE
12687 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12688 #else
12689 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12690 #endif
12691 }
12692 {
12693 if (temp2)
12694 delete arg2;
12695 }
12696 return resultobj;
12697 fail:
12698 {
12699 if (temp2)
12700 delete arg2;
12701 }
12702 return NULL;
12703 }
12704
12705
12706 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12707 PyObject *resultobj = 0;
12708 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12709 wxString result;
12710 void *argp1 = 0 ;
12711 int res1 = 0 ;
12712 PyObject *swig_obj[1] ;
12713
12714 if (!args) SWIG_fail;
12715 swig_obj[0] = args;
12716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12717 if (!SWIG_IsOK(res1)) {
12718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12719 }
12720 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12721 {
12722 PyThreadState* __tstate = wxPyBeginAllowThreads();
12723 result = (arg1)->FindNext();
12724 wxPyEndAllowThreads(__tstate);
12725 if (PyErr_Occurred()) SWIG_fail;
12726 }
12727 {
12728 #if wxUSE_UNICODE
12729 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12730 #else
12731 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12732 #endif
12733 }
12734 return resultobj;
12735 fail:
12736 return NULL;
12737 }
12738
12739
12740 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12741 PyObject *resultobj = 0;
12742 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12743 wxString *arg2 = 0 ;
12744 wxString result;
12745 void *argp1 = 0 ;
12746 int res1 = 0 ;
12747 bool temp2 = false ;
12748 PyObject * obj0 = 0 ;
12749 PyObject * obj1 = 0 ;
12750 char * kwnames[] = {
12751 (char *) "self",(char *) "location", NULL
12752 };
12753
12754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12756 if (!SWIG_IsOK(res1)) {
12757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12758 }
12759 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12760 {
12761 arg2 = wxString_in_helper(obj1);
12762 if (arg2 == NULL) SWIG_fail;
12763 temp2 = true;
12764 }
12765 {
12766 PyThreadState* __tstate = wxPyBeginAllowThreads();
12767 result = (arg1)->GetProtocol((wxString const &)*arg2);
12768 wxPyEndAllowThreads(__tstate);
12769 if (PyErr_Occurred()) SWIG_fail;
12770 }
12771 {
12772 #if wxUSE_UNICODE
12773 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12774 #else
12775 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12776 #endif
12777 }
12778 {
12779 if (temp2)
12780 delete arg2;
12781 }
12782 return resultobj;
12783 fail:
12784 {
12785 if (temp2)
12786 delete arg2;
12787 }
12788 return NULL;
12789 }
12790
12791
12792 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12793 PyObject *resultobj = 0;
12794 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12795 wxString *arg2 = 0 ;
12796 wxString result;
12797 void *argp1 = 0 ;
12798 int res1 = 0 ;
12799 bool temp2 = false ;
12800 PyObject * obj0 = 0 ;
12801 PyObject * obj1 = 0 ;
12802 char * kwnames[] = {
12803 (char *) "self",(char *) "location", NULL
12804 };
12805
12806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12808 if (!SWIG_IsOK(res1)) {
12809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12810 }
12811 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12812 {
12813 arg2 = wxString_in_helper(obj1);
12814 if (arg2 == NULL) SWIG_fail;
12815 temp2 = true;
12816 }
12817 {
12818 PyThreadState* __tstate = wxPyBeginAllowThreads();
12819 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12820 wxPyEndAllowThreads(__tstate);
12821 if (PyErr_Occurred()) SWIG_fail;
12822 }
12823 {
12824 #if wxUSE_UNICODE
12825 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12826 #else
12827 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12828 #endif
12829 }
12830 {
12831 if (temp2)
12832 delete arg2;
12833 }
12834 return resultobj;
12835 fail:
12836 {
12837 if (temp2)
12838 delete arg2;
12839 }
12840 return NULL;
12841 }
12842
12843
12844 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12845 PyObject *resultobj = 0;
12846 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12847 wxString *arg2 = 0 ;
12848 wxString result;
12849 void *argp1 = 0 ;
12850 int res1 = 0 ;
12851 bool temp2 = false ;
12852 PyObject * obj0 = 0 ;
12853 PyObject * obj1 = 0 ;
12854 char * kwnames[] = {
12855 (char *) "self",(char *) "location", NULL
12856 };
12857
12858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12860 if (!SWIG_IsOK(res1)) {
12861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12862 }
12863 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12864 {
12865 arg2 = wxString_in_helper(obj1);
12866 if (arg2 == NULL) SWIG_fail;
12867 temp2 = true;
12868 }
12869 {
12870 PyThreadState* __tstate = wxPyBeginAllowThreads();
12871 result = (arg1)->GetAnchor((wxString const &)*arg2);
12872 wxPyEndAllowThreads(__tstate);
12873 if (PyErr_Occurred()) SWIG_fail;
12874 }
12875 {
12876 #if wxUSE_UNICODE
12877 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12878 #else
12879 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12880 #endif
12881 }
12882 {
12883 if (temp2)
12884 delete arg2;
12885 }
12886 return resultobj;
12887 fail:
12888 {
12889 if (temp2)
12890 delete arg2;
12891 }
12892 return NULL;
12893 }
12894
12895
12896 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12897 PyObject *resultobj = 0;
12898 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12899 wxString *arg2 = 0 ;
12900 wxString result;
12901 void *argp1 = 0 ;
12902 int res1 = 0 ;
12903 bool temp2 = false ;
12904 PyObject * obj0 = 0 ;
12905 PyObject * obj1 = 0 ;
12906 char * kwnames[] = {
12907 (char *) "self",(char *) "location", NULL
12908 };
12909
12910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12912 if (!SWIG_IsOK(res1)) {
12913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12914 }
12915 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12916 {
12917 arg2 = wxString_in_helper(obj1);
12918 if (arg2 == NULL) SWIG_fail;
12919 temp2 = true;
12920 }
12921 {
12922 PyThreadState* __tstate = wxPyBeginAllowThreads();
12923 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12924 wxPyEndAllowThreads(__tstate);
12925 if (PyErr_Occurred()) SWIG_fail;
12926 }
12927 {
12928 #if wxUSE_UNICODE
12929 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12930 #else
12931 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12932 #endif
12933 }
12934 {
12935 if (temp2)
12936 delete arg2;
12937 }
12938 return resultobj;
12939 fail:
12940 {
12941 if (temp2)
12942 delete arg2;
12943 }
12944 return NULL;
12945 }
12946
12947
12948 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12949 PyObject *resultobj = 0;
12950 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12951 wxString *arg2 = 0 ;
12952 wxString result;
12953 void *argp1 = 0 ;
12954 int res1 = 0 ;
12955 bool temp2 = false ;
12956 PyObject * obj0 = 0 ;
12957 PyObject * obj1 = 0 ;
12958 char * kwnames[] = {
12959 (char *) "self",(char *) "location", NULL
12960 };
12961
12962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
12963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12964 if (!SWIG_IsOK(res1)) {
12965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12966 }
12967 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12968 {
12969 arg2 = wxString_in_helper(obj1);
12970 if (arg2 == NULL) SWIG_fail;
12971 temp2 = true;
12972 }
12973 {
12974 PyThreadState* __tstate = wxPyBeginAllowThreads();
12975 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
12976 wxPyEndAllowThreads(__tstate);
12977 if (PyErr_Occurred()) SWIG_fail;
12978 }
12979 {
12980 #if wxUSE_UNICODE
12981 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12982 #else
12983 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12984 #endif
12985 }
12986 {
12987 if (temp2)
12988 delete arg2;
12989 }
12990 return resultobj;
12991 fail:
12992 {
12993 if (temp2)
12994 delete arg2;
12995 }
12996 return NULL;
12997 }
12998
12999
13000 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13001 PyObject *obj;
13002 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13003 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
13004 return SWIG_Py_Void();
13005 }
13006
13007 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13008 return SWIG_Python_InitShadowInstance(args);
13009 }
13010
13011 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13012 PyObject *resultobj = 0;
13013 wxFileSystem *result = 0 ;
13014
13015 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13016 {
13017 PyThreadState* __tstate = wxPyBeginAllowThreads();
13018 result = (wxFileSystem *)new wxFileSystem();
13019 wxPyEndAllowThreads(__tstate);
13020 if (PyErr_Occurred()) SWIG_fail;
13021 }
13022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13023 return resultobj;
13024 fail:
13025 return NULL;
13026 }
13027
13028
13029 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13030 PyObject *resultobj = 0;
13031 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13032 void *argp1 = 0 ;
13033 int res1 = 0 ;
13034 PyObject *swig_obj[1] ;
13035
13036 if (!args) SWIG_fail;
13037 swig_obj[0] = args;
13038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13039 if (!SWIG_IsOK(res1)) {
13040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13041 }
13042 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13043 {
13044 PyThreadState* __tstate = wxPyBeginAllowThreads();
13045 delete arg1;
13046
13047 wxPyEndAllowThreads(__tstate);
13048 if (PyErr_Occurred()) SWIG_fail;
13049 }
13050 resultobj = SWIG_Py_Void();
13051 return resultobj;
13052 fail:
13053 return NULL;
13054 }
13055
13056
13057 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13058 PyObject *resultobj = 0;
13059 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13060 wxString *arg2 = 0 ;
13061 bool arg3 = (bool) false ;
13062 void *argp1 = 0 ;
13063 int res1 = 0 ;
13064 bool temp2 = false ;
13065 bool val3 ;
13066 int ecode3 = 0 ;
13067 PyObject * obj0 = 0 ;
13068 PyObject * obj1 = 0 ;
13069 PyObject * obj2 = 0 ;
13070 char * kwnames[] = {
13071 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13072 };
13073
13074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13076 if (!SWIG_IsOK(res1)) {
13077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13078 }
13079 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13080 {
13081 arg2 = wxString_in_helper(obj1);
13082 if (arg2 == NULL) SWIG_fail;
13083 temp2 = true;
13084 }
13085 if (obj2) {
13086 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13087 if (!SWIG_IsOK(ecode3)) {
13088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13089 }
13090 arg3 = static_cast< bool >(val3);
13091 }
13092 {
13093 PyThreadState* __tstate = wxPyBeginAllowThreads();
13094 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13095 wxPyEndAllowThreads(__tstate);
13096 if (PyErr_Occurred()) SWIG_fail;
13097 }
13098 resultobj = SWIG_Py_Void();
13099 {
13100 if (temp2)
13101 delete arg2;
13102 }
13103 return resultobj;
13104 fail:
13105 {
13106 if (temp2)
13107 delete arg2;
13108 }
13109 return NULL;
13110 }
13111
13112
13113 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13114 PyObject *resultobj = 0;
13115 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13116 wxString result;
13117 void *argp1 = 0 ;
13118 int res1 = 0 ;
13119 PyObject *swig_obj[1] ;
13120
13121 if (!args) SWIG_fail;
13122 swig_obj[0] = args;
13123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13124 if (!SWIG_IsOK(res1)) {
13125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13126 }
13127 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13128 {
13129 PyThreadState* __tstate = wxPyBeginAllowThreads();
13130 result = (arg1)->GetPath();
13131 wxPyEndAllowThreads(__tstate);
13132 if (PyErr_Occurred()) SWIG_fail;
13133 }
13134 {
13135 #if wxUSE_UNICODE
13136 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13137 #else
13138 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13139 #endif
13140 }
13141 return resultobj;
13142 fail:
13143 return NULL;
13144 }
13145
13146
13147 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13148 PyObject *resultobj = 0;
13149 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13150 wxString *arg2 = 0 ;
13151 wxFSFile *result = 0 ;
13152 void *argp1 = 0 ;
13153 int res1 = 0 ;
13154 bool temp2 = false ;
13155 PyObject * obj0 = 0 ;
13156 PyObject * obj1 = 0 ;
13157 char * kwnames[] = {
13158 (char *) "self",(char *) "location", NULL
13159 };
13160
13161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13163 if (!SWIG_IsOK(res1)) {
13164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13165 }
13166 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13167 {
13168 arg2 = wxString_in_helper(obj1);
13169 if (arg2 == NULL) SWIG_fail;
13170 temp2 = true;
13171 }
13172 {
13173 PyThreadState* __tstate = wxPyBeginAllowThreads();
13174 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13175 wxPyEndAllowThreads(__tstate);
13176 if (PyErr_Occurred()) SWIG_fail;
13177 }
13178 {
13179 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13180 }
13181 {
13182 if (temp2)
13183 delete arg2;
13184 }
13185 return resultobj;
13186 fail:
13187 {
13188 if (temp2)
13189 delete arg2;
13190 }
13191 return NULL;
13192 }
13193
13194
13195 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13196 PyObject *resultobj = 0;
13197 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13198 wxString *arg2 = 0 ;
13199 int arg3 = (int) 0 ;
13200 wxString result;
13201 void *argp1 = 0 ;
13202 int res1 = 0 ;
13203 bool temp2 = false ;
13204 int val3 ;
13205 int ecode3 = 0 ;
13206 PyObject * obj0 = 0 ;
13207 PyObject * obj1 = 0 ;
13208 PyObject * obj2 = 0 ;
13209 char * kwnames[] = {
13210 (char *) "self",(char *) "spec",(char *) "flags", NULL
13211 };
13212
13213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13215 if (!SWIG_IsOK(res1)) {
13216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13217 }
13218 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13219 {
13220 arg2 = wxString_in_helper(obj1);
13221 if (arg2 == NULL) SWIG_fail;
13222 temp2 = true;
13223 }
13224 if (obj2) {
13225 ecode3 = SWIG_AsVal_int(obj2, &val3);
13226 if (!SWIG_IsOK(ecode3)) {
13227 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13228 }
13229 arg3 = static_cast< int >(val3);
13230 }
13231 {
13232 PyThreadState* __tstate = wxPyBeginAllowThreads();
13233 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13234 wxPyEndAllowThreads(__tstate);
13235 if (PyErr_Occurred()) SWIG_fail;
13236 }
13237 {
13238 #if wxUSE_UNICODE
13239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13240 #else
13241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13242 #endif
13243 }
13244 {
13245 if (temp2)
13246 delete arg2;
13247 }
13248 return resultobj;
13249 fail:
13250 {
13251 if (temp2)
13252 delete arg2;
13253 }
13254 return NULL;
13255 }
13256
13257
13258 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13259 PyObject *resultobj = 0;
13260 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13261 wxString result;
13262 void *argp1 = 0 ;
13263 int res1 = 0 ;
13264 PyObject *swig_obj[1] ;
13265
13266 if (!args) SWIG_fail;
13267 swig_obj[0] = args;
13268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13269 if (!SWIG_IsOK(res1)) {
13270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13271 }
13272 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13273 {
13274 PyThreadState* __tstate = wxPyBeginAllowThreads();
13275 result = (arg1)->FindNext();
13276 wxPyEndAllowThreads(__tstate);
13277 if (PyErr_Occurred()) SWIG_fail;
13278 }
13279 {
13280 #if wxUSE_UNICODE
13281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13282 #else
13283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13284 #endif
13285 }
13286 return resultobj;
13287 fail:
13288 return NULL;
13289 }
13290
13291
13292 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13293 PyObject *resultobj = 0;
13294 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13295 int res1 = 0 ;
13296 PyObject * obj0 = 0 ;
13297 char * kwnames[] = {
13298 (char *) "handler", NULL
13299 };
13300
13301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13302 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13303 if (!SWIG_IsOK(res1)) {
13304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13305 }
13306 {
13307 PyThreadState* __tstate = wxPyBeginAllowThreads();
13308 wxFileSystem::AddHandler(arg1);
13309 wxPyEndAllowThreads(__tstate);
13310 if (PyErr_Occurred()) SWIG_fail;
13311 }
13312 resultobj = SWIG_Py_Void();
13313 return resultobj;
13314 fail:
13315 return NULL;
13316 }
13317
13318
13319 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13320 PyObject *resultobj = 0;
13321 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13322 wxFileSystemHandler *result = 0 ;
13323 void *argp1 = 0 ;
13324 int res1 = 0 ;
13325 PyObject * obj0 = 0 ;
13326 char * kwnames[] = {
13327 (char *) "handler", NULL
13328 };
13329
13330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13332 if (!SWIG_IsOK(res1)) {
13333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13334 }
13335 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13336 {
13337 PyThreadState* __tstate = wxPyBeginAllowThreads();
13338 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13339 wxPyEndAllowThreads(__tstate);
13340 if (PyErr_Occurred()) SWIG_fail;
13341 }
13342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13343 return resultobj;
13344 fail:
13345 return NULL;
13346 }
13347
13348
13349 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13350 PyObject *resultobj = 0;
13351
13352 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13353 {
13354 PyThreadState* __tstate = wxPyBeginAllowThreads();
13355 wxFileSystem::CleanUpHandlers();
13356 wxPyEndAllowThreads(__tstate);
13357 if (PyErr_Occurred()) SWIG_fail;
13358 }
13359 resultobj = SWIG_Py_Void();
13360 return resultobj;
13361 fail:
13362 return NULL;
13363 }
13364
13365
13366 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13367 PyObject *resultobj = 0;
13368 wxString *arg1 = 0 ;
13369 wxString result;
13370 bool temp1 = false ;
13371 PyObject * obj0 = 0 ;
13372 char * kwnames[] = {
13373 (char *) "filename", NULL
13374 };
13375
13376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13377 {
13378 arg1 = wxString_in_helper(obj0);
13379 if (arg1 == NULL) SWIG_fail;
13380 temp1 = true;
13381 }
13382 {
13383 PyThreadState* __tstate = wxPyBeginAllowThreads();
13384 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13385 wxPyEndAllowThreads(__tstate);
13386 if (PyErr_Occurred()) SWIG_fail;
13387 }
13388 {
13389 #if wxUSE_UNICODE
13390 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13391 #else
13392 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13393 #endif
13394 }
13395 {
13396 if (temp1)
13397 delete arg1;
13398 }
13399 return resultobj;
13400 fail:
13401 {
13402 if (temp1)
13403 delete arg1;
13404 }
13405 return NULL;
13406 }
13407
13408
13409 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13410 PyObject *resultobj = 0;
13411 wxString *arg1 = 0 ;
13412 wxString result;
13413 bool temp1 = false ;
13414 PyObject * obj0 = 0 ;
13415 char * kwnames[] = {
13416 (char *) "url", NULL
13417 };
13418
13419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13420 {
13421 arg1 = wxString_in_helper(obj0);
13422 if (arg1 == NULL) SWIG_fail;
13423 temp1 = true;
13424 }
13425 {
13426 PyThreadState* __tstate = wxPyBeginAllowThreads();
13427 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
13428 wxPyEndAllowThreads(__tstate);
13429 if (PyErr_Occurred()) SWIG_fail;
13430 }
13431 {
13432 #if wxUSE_UNICODE
13433 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13434 #else
13435 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13436 #endif
13437 }
13438 {
13439 if (temp1)
13440 delete arg1;
13441 }
13442 return resultobj;
13443 fail:
13444 {
13445 if (temp1)
13446 delete arg1;
13447 }
13448 return NULL;
13449 }
13450
13451
13452 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13453 PyObject *obj;
13454 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13455 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13456 return SWIG_Py_Void();
13457 }
13458
13459 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13460 return SWIG_Python_InitShadowInstance(args);
13461 }
13462
13463 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13464 PyObject *resultobj = 0;
13465 wxInternetFSHandler *result = 0 ;
13466
13467 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13468 {
13469 PyThreadState* __tstate = wxPyBeginAllowThreads();
13470 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13471 wxPyEndAllowThreads(__tstate);
13472 if (PyErr_Occurred()) SWIG_fail;
13473 }
13474 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13475 return resultobj;
13476 fail:
13477 return NULL;
13478 }
13479
13480
13481 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13482 PyObject *resultobj = 0;
13483 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13484 wxString *arg2 = 0 ;
13485 bool result;
13486 void *argp1 = 0 ;
13487 int res1 = 0 ;
13488 bool temp2 = false ;
13489 PyObject * obj0 = 0 ;
13490 PyObject * obj1 = 0 ;
13491 char * kwnames[] = {
13492 (char *) "self",(char *) "location", NULL
13493 };
13494
13495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13497 if (!SWIG_IsOK(res1)) {
13498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13499 }
13500 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13501 {
13502 arg2 = wxString_in_helper(obj1);
13503 if (arg2 == NULL) SWIG_fail;
13504 temp2 = true;
13505 }
13506 {
13507 PyThreadState* __tstate = wxPyBeginAllowThreads();
13508 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13509 wxPyEndAllowThreads(__tstate);
13510 if (PyErr_Occurred()) SWIG_fail;
13511 }
13512 {
13513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13514 }
13515 {
13516 if (temp2)
13517 delete arg2;
13518 }
13519 return resultobj;
13520 fail:
13521 {
13522 if (temp2)
13523 delete arg2;
13524 }
13525 return NULL;
13526 }
13527
13528
13529 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13530 PyObject *resultobj = 0;
13531 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13532 wxFileSystem *arg2 = 0 ;
13533 wxString *arg3 = 0 ;
13534 wxFSFile *result = 0 ;
13535 void *argp1 = 0 ;
13536 int res1 = 0 ;
13537 void *argp2 = 0 ;
13538 int res2 = 0 ;
13539 bool temp3 = false ;
13540 PyObject * obj0 = 0 ;
13541 PyObject * obj1 = 0 ;
13542 PyObject * obj2 = 0 ;
13543 char * kwnames[] = {
13544 (char *) "self",(char *) "fs",(char *) "location", NULL
13545 };
13546
13547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13549 if (!SWIG_IsOK(res1)) {
13550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13551 }
13552 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13553 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13554 if (!SWIG_IsOK(res2)) {
13555 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13556 }
13557 if (!argp2) {
13558 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13559 }
13560 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13561 {
13562 arg3 = wxString_in_helper(obj2);
13563 if (arg3 == NULL) SWIG_fail;
13564 temp3 = true;
13565 }
13566 {
13567 PyThreadState* __tstate = wxPyBeginAllowThreads();
13568 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13569 wxPyEndAllowThreads(__tstate);
13570 if (PyErr_Occurred()) SWIG_fail;
13571 }
13572 {
13573 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13574 }
13575 {
13576 if (temp3)
13577 delete arg3;
13578 }
13579 return resultobj;
13580 fail:
13581 {
13582 if (temp3)
13583 delete arg3;
13584 }
13585 return NULL;
13586 }
13587
13588
13589 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13590 PyObject *obj;
13591 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13592 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13593 return SWIG_Py_Void();
13594 }
13595
13596 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13597 return SWIG_Python_InitShadowInstance(args);
13598 }
13599
13600 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13601 PyObject *resultobj = 0;
13602 wxZipFSHandler *result = 0 ;
13603
13604 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13605 {
13606 PyThreadState* __tstate = wxPyBeginAllowThreads();
13607 result = (wxZipFSHandler *)new wxZipFSHandler();
13608 wxPyEndAllowThreads(__tstate);
13609 if (PyErr_Occurred()) SWIG_fail;
13610 }
13611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13612 return resultobj;
13613 fail:
13614 return NULL;
13615 }
13616
13617
13618 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13619 PyObject *resultobj = 0;
13620 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13621 wxString *arg2 = 0 ;
13622 bool result;
13623 void *argp1 = 0 ;
13624 int res1 = 0 ;
13625 bool temp2 = false ;
13626 PyObject * obj0 = 0 ;
13627 PyObject * obj1 = 0 ;
13628 char * kwnames[] = {
13629 (char *) "self",(char *) "location", NULL
13630 };
13631
13632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13634 if (!SWIG_IsOK(res1)) {
13635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13636 }
13637 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13638 {
13639 arg2 = wxString_in_helper(obj1);
13640 if (arg2 == NULL) SWIG_fail;
13641 temp2 = true;
13642 }
13643 {
13644 PyThreadState* __tstate = wxPyBeginAllowThreads();
13645 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13646 wxPyEndAllowThreads(__tstate);
13647 if (PyErr_Occurred()) SWIG_fail;
13648 }
13649 {
13650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13651 }
13652 {
13653 if (temp2)
13654 delete arg2;
13655 }
13656 return resultobj;
13657 fail:
13658 {
13659 if (temp2)
13660 delete arg2;
13661 }
13662 return NULL;
13663 }
13664
13665
13666 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13667 PyObject *resultobj = 0;
13668 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13669 wxFileSystem *arg2 = 0 ;
13670 wxString *arg3 = 0 ;
13671 wxFSFile *result = 0 ;
13672 void *argp1 = 0 ;
13673 int res1 = 0 ;
13674 void *argp2 = 0 ;
13675 int res2 = 0 ;
13676 bool temp3 = false ;
13677 PyObject * obj0 = 0 ;
13678 PyObject * obj1 = 0 ;
13679 PyObject * obj2 = 0 ;
13680 char * kwnames[] = {
13681 (char *) "self",(char *) "fs",(char *) "location", NULL
13682 };
13683
13684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13686 if (!SWIG_IsOK(res1)) {
13687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13688 }
13689 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13690 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13691 if (!SWIG_IsOK(res2)) {
13692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13693 }
13694 if (!argp2) {
13695 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13696 }
13697 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13698 {
13699 arg3 = wxString_in_helper(obj2);
13700 if (arg3 == NULL) SWIG_fail;
13701 temp3 = true;
13702 }
13703 {
13704 PyThreadState* __tstate = wxPyBeginAllowThreads();
13705 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13706 wxPyEndAllowThreads(__tstate);
13707 if (PyErr_Occurred()) SWIG_fail;
13708 }
13709 {
13710 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13711 }
13712 {
13713 if (temp3)
13714 delete arg3;
13715 }
13716 return resultobj;
13717 fail:
13718 {
13719 if (temp3)
13720 delete arg3;
13721 }
13722 return NULL;
13723 }
13724
13725
13726 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13727 PyObject *resultobj = 0;
13728 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13729 wxString *arg2 = 0 ;
13730 int arg3 = (int) 0 ;
13731 wxString result;
13732 void *argp1 = 0 ;
13733 int res1 = 0 ;
13734 bool temp2 = false ;
13735 int val3 ;
13736 int ecode3 = 0 ;
13737 PyObject * obj0 = 0 ;
13738 PyObject * obj1 = 0 ;
13739 PyObject * obj2 = 0 ;
13740 char * kwnames[] = {
13741 (char *) "self",(char *) "spec",(char *) "flags", NULL
13742 };
13743
13744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13746 if (!SWIG_IsOK(res1)) {
13747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13748 }
13749 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13750 {
13751 arg2 = wxString_in_helper(obj1);
13752 if (arg2 == NULL) SWIG_fail;
13753 temp2 = true;
13754 }
13755 if (obj2) {
13756 ecode3 = SWIG_AsVal_int(obj2, &val3);
13757 if (!SWIG_IsOK(ecode3)) {
13758 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13759 }
13760 arg3 = static_cast< int >(val3);
13761 }
13762 {
13763 PyThreadState* __tstate = wxPyBeginAllowThreads();
13764 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13765 wxPyEndAllowThreads(__tstate);
13766 if (PyErr_Occurred()) SWIG_fail;
13767 }
13768 {
13769 #if wxUSE_UNICODE
13770 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13771 #else
13772 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13773 #endif
13774 }
13775 {
13776 if (temp2)
13777 delete arg2;
13778 }
13779 return resultobj;
13780 fail:
13781 {
13782 if (temp2)
13783 delete arg2;
13784 }
13785 return NULL;
13786 }
13787
13788
13789 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13790 PyObject *resultobj = 0;
13791 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13792 wxString result;
13793 void *argp1 = 0 ;
13794 int res1 = 0 ;
13795 PyObject *swig_obj[1] ;
13796
13797 if (!args) SWIG_fail;
13798 swig_obj[0] = args;
13799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13800 if (!SWIG_IsOK(res1)) {
13801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13802 }
13803 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13804 {
13805 PyThreadState* __tstate = wxPyBeginAllowThreads();
13806 result = (arg1)->FindNext();
13807 wxPyEndAllowThreads(__tstate);
13808 if (PyErr_Occurred()) SWIG_fail;
13809 }
13810 {
13811 #if wxUSE_UNICODE
13812 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13813 #else
13814 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13815 #endif
13816 }
13817 return resultobj;
13818 fail:
13819 return NULL;
13820 }
13821
13822
13823 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13824 PyObject *obj;
13825 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13826 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13827 return SWIG_Py_Void();
13828 }
13829
13830 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13831 return SWIG_Python_InitShadowInstance(args);
13832 }
13833
13834 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13835 PyObject *resultobj = 0;
13836 wxString *arg1 = 0 ;
13837 wxImage *arg2 = 0 ;
13838 long arg3 ;
13839 bool temp1 = false ;
13840 void *argp2 = 0 ;
13841 int res2 = 0 ;
13842 long val3 ;
13843 int ecode3 = 0 ;
13844 PyObject * obj0 = 0 ;
13845 PyObject * obj1 = 0 ;
13846 PyObject * obj2 = 0 ;
13847 char * kwnames[] = {
13848 (char *) "filename",(char *) "image",(char *) "type", NULL
13849 };
13850
13851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13852 {
13853 arg1 = wxString_in_helper(obj0);
13854 if (arg1 == NULL) SWIG_fail;
13855 temp1 = true;
13856 }
13857 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13858 if (!SWIG_IsOK(res2)) {
13859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13860 }
13861 if (!argp2) {
13862 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13863 }
13864 arg2 = reinterpret_cast< wxImage * >(argp2);
13865 ecode3 = SWIG_AsVal_long(obj2, &val3);
13866 if (!SWIG_IsOK(ecode3)) {
13867 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13868 }
13869 arg3 = static_cast< long >(val3);
13870 {
13871 PyThreadState* __tstate = wxPyBeginAllowThreads();
13872 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13873 wxPyEndAllowThreads(__tstate);
13874 if (PyErr_Occurred()) SWIG_fail;
13875 }
13876 resultobj = SWIG_Py_Void();
13877 {
13878 if (temp1)
13879 delete arg1;
13880 }
13881 return resultobj;
13882 fail:
13883 {
13884 if (temp1)
13885 delete arg1;
13886 }
13887 return NULL;
13888 }
13889
13890
13891 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13892 PyObject *resultobj = 0;
13893 wxString *arg1 = 0 ;
13894 wxBitmap *arg2 = 0 ;
13895 long arg3 ;
13896 bool temp1 = false ;
13897 void *argp2 = 0 ;
13898 int res2 = 0 ;
13899 long val3 ;
13900 int ecode3 = 0 ;
13901 PyObject * obj0 = 0 ;
13902 PyObject * obj1 = 0 ;
13903 PyObject * obj2 = 0 ;
13904 char * kwnames[] = {
13905 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13906 };
13907
13908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13909 {
13910 arg1 = wxString_in_helper(obj0);
13911 if (arg1 == NULL) SWIG_fail;
13912 temp1 = true;
13913 }
13914 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13915 if (!SWIG_IsOK(res2)) {
13916 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13917 }
13918 if (!argp2) {
13919 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13920 }
13921 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13922 ecode3 = SWIG_AsVal_long(obj2, &val3);
13923 if (!SWIG_IsOK(ecode3)) {
13924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13925 }
13926 arg3 = static_cast< long >(val3);
13927 {
13928 PyThreadState* __tstate = wxPyBeginAllowThreads();
13929 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
13930 wxPyEndAllowThreads(__tstate);
13931 if (PyErr_Occurred()) SWIG_fail;
13932 }
13933 resultobj = SWIG_Py_Void();
13934 {
13935 if (temp1)
13936 delete arg1;
13937 }
13938 return resultobj;
13939 fail:
13940 {
13941 if (temp1)
13942 delete arg1;
13943 }
13944 return NULL;
13945 }
13946
13947
13948 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13949 PyObject *resultobj = 0;
13950 wxString *arg1 = 0 ;
13951 PyObject *arg2 = (PyObject *) 0 ;
13952 bool temp1 = false ;
13953 PyObject * obj0 = 0 ;
13954 PyObject * obj1 = 0 ;
13955 char * kwnames[] = {
13956 (char *) "filename",(char *) "data", NULL
13957 };
13958
13959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
13960 {
13961 arg1 = wxString_in_helper(obj0);
13962 if (arg1 == NULL) SWIG_fail;
13963 temp1 = true;
13964 }
13965 arg2 = obj1;
13966 {
13967 PyThreadState* __tstate = wxPyBeginAllowThreads();
13968 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
13969 wxPyEndAllowThreads(__tstate);
13970 if (PyErr_Occurred()) SWIG_fail;
13971 }
13972 resultobj = SWIG_Py_Void();
13973 {
13974 if (temp1)
13975 delete arg1;
13976 }
13977 return resultobj;
13978 fail:
13979 {
13980 if (temp1)
13981 delete arg1;
13982 }
13983 return NULL;
13984 }
13985
13986
13987 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13988 PyObject *resultobj = 0;
13989 wxMemoryFSHandler *result = 0 ;
13990
13991 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
13992 {
13993 PyThreadState* __tstate = wxPyBeginAllowThreads();
13994 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
13995 wxPyEndAllowThreads(__tstate);
13996 if (PyErr_Occurred()) SWIG_fail;
13997 }
13998 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
13999 return resultobj;
14000 fail:
14001 return NULL;
14002 }
14003
14004
14005 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14006 PyObject *resultobj = 0;
14007 wxString *arg1 = 0 ;
14008 bool temp1 = false ;
14009 PyObject * obj0 = 0 ;
14010 char * kwnames[] = {
14011 (char *) "filename", NULL
14012 };
14013
14014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14015 {
14016 arg1 = wxString_in_helper(obj0);
14017 if (arg1 == NULL) SWIG_fail;
14018 temp1 = true;
14019 }
14020 {
14021 PyThreadState* __tstate = wxPyBeginAllowThreads();
14022 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14023 wxPyEndAllowThreads(__tstate);
14024 if (PyErr_Occurred()) SWIG_fail;
14025 }
14026 resultobj = SWIG_Py_Void();
14027 {
14028 if (temp1)
14029 delete arg1;
14030 }
14031 return resultobj;
14032 fail:
14033 {
14034 if (temp1)
14035 delete arg1;
14036 }
14037 return NULL;
14038 }
14039
14040
14041 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14042 PyObject *resultobj = 0;
14043 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14044 wxString *arg2 = 0 ;
14045 bool result;
14046 void *argp1 = 0 ;
14047 int res1 = 0 ;
14048 bool temp2 = false ;
14049 PyObject * obj0 = 0 ;
14050 PyObject * obj1 = 0 ;
14051 char * kwnames[] = {
14052 (char *) "self",(char *) "location", NULL
14053 };
14054
14055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14057 if (!SWIG_IsOK(res1)) {
14058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14059 }
14060 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14061 {
14062 arg2 = wxString_in_helper(obj1);
14063 if (arg2 == NULL) SWIG_fail;
14064 temp2 = true;
14065 }
14066 {
14067 PyThreadState* __tstate = wxPyBeginAllowThreads();
14068 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14069 wxPyEndAllowThreads(__tstate);
14070 if (PyErr_Occurred()) SWIG_fail;
14071 }
14072 {
14073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14074 }
14075 {
14076 if (temp2)
14077 delete arg2;
14078 }
14079 return resultobj;
14080 fail:
14081 {
14082 if (temp2)
14083 delete arg2;
14084 }
14085 return NULL;
14086 }
14087
14088
14089 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14090 PyObject *resultobj = 0;
14091 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14092 wxFileSystem *arg2 = 0 ;
14093 wxString *arg3 = 0 ;
14094 wxFSFile *result = 0 ;
14095 void *argp1 = 0 ;
14096 int res1 = 0 ;
14097 void *argp2 = 0 ;
14098 int res2 = 0 ;
14099 bool temp3 = false ;
14100 PyObject * obj0 = 0 ;
14101 PyObject * obj1 = 0 ;
14102 PyObject * obj2 = 0 ;
14103 char * kwnames[] = {
14104 (char *) "self",(char *) "fs",(char *) "location", NULL
14105 };
14106
14107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14109 if (!SWIG_IsOK(res1)) {
14110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14111 }
14112 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14113 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14114 if (!SWIG_IsOK(res2)) {
14115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14116 }
14117 if (!argp2) {
14118 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14119 }
14120 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14121 {
14122 arg3 = wxString_in_helper(obj2);
14123 if (arg3 == NULL) SWIG_fail;
14124 temp3 = true;
14125 }
14126 {
14127 PyThreadState* __tstate = wxPyBeginAllowThreads();
14128 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14129 wxPyEndAllowThreads(__tstate);
14130 if (PyErr_Occurred()) SWIG_fail;
14131 }
14132 {
14133 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14134 }
14135 {
14136 if (temp3)
14137 delete arg3;
14138 }
14139 return resultobj;
14140 fail:
14141 {
14142 if (temp3)
14143 delete arg3;
14144 }
14145 return NULL;
14146 }
14147
14148
14149 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14150 PyObject *resultobj = 0;
14151 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14152 wxString *arg2 = 0 ;
14153 int arg3 = (int) 0 ;
14154 wxString result;
14155 void *argp1 = 0 ;
14156 int res1 = 0 ;
14157 bool temp2 = false ;
14158 int val3 ;
14159 int ecode3 = 0 ;
14160 PyObject * obj0 = 0 ;
14161 PyObject * obj1 = 0 ;
14162 PyObject * obj2 = 0 ;
14163 char * kwnames[] = {
14164 (char *) "self",(char *) "spec",(char *) "flags", NULL
14165 };
14166
14167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14169 if (!SWIG_IsOK(res1)) {
14170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14171 }
14172 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14173 {
14174 arg2 = wxString_in_helper(obj1);
14175 if (arg2 == NULL) SWIG_fail;
14176 temp2 = true;
14177 }
14178 if (obj2) {
14179 ecode3 = SWIG_AsVal_int(obj2, &val3);
14180 if (!SWIG_IsOK(ecode3)) {
14181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14182 }
14183 arg3 = static_cast< int >(val3);
14184 }
14185 {
14186 PyThreadState* __tstate = wxPyBeginAllowThreads();
14187 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14188 wxPyEndAllowThreads(__tstate);
14189 if (PyErr_Occurred()) SWIG_fail;
14190 }
14191 {
14192 #if wxUSE_UNICODE
14193 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14194 #else
14195 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14196 #endif
14197 }
14198 {
14199 if (temp2)
14200 delete arg2;
14201 }
14202 return resultobj;
14203 fail:
14204 {
14205 if (temp2)
14206 delete arg2;
14207 }
14208 return NULL;
14209 }
14210
14211
14212 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14213 PyObject *resultobj = 0;
14214 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14215 wxString result;
14216 void *argp1 = 0 ;
14217 int res1 = 0 ;
14218 PyObject *swig_obj[1] ;
14219
14220 if (!args) SWIG_fail;
14221 swig_obj[0] = args;
14222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14223 if (!SWIG_IsOK(res1)) {
14224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14225 }
14226 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14227 {
14228 PyThreadState* __tstate = wxPyBeginAllowThreads();
14229 result = (arg1)->FindNext();
14230 wxPyEndAllowThreads(__tstate);
14231 if (PyErr_Occurred()) SWIG_fail;
14232 }
14233 {
14234 #if wxUSE_UNICODE
14235 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14236 #else
14237 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14238 #endif
14239 }
14240 return resultobj;
14241 fail:
14242 return NULL;
14243 }
14244
14245
14246 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14247 PyObject *obj;
14248 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14249 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14250 return SWIG_Py_Void();
14251 }
14252
14253 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14254 return SWIG_Python_InitShadowInstance(args);
14255 }
14256
14257 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14258 PyObject *resultobj = 0;
14259 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14260 wxString result;
14261 void *argp1 = 0 ;
14262 int res1 = 0 ;
14263 PyObject *swig_obj[1] ;
14264
14265 if (!args) SWIG_fail;
14266 swig_obj[0] = args;
14267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14268 if (!SWIG_IsOK(res1)) {
14269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14270 }
14271 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14272 {
14273 PyThreadState* __tstate = wxPyBeginAllowThreads();
14274 result = (arg1)->GetName();
14275 wxPyEndAllowThreads(__tstate);
14276 if (PyErr_Occurred()) SWIG_fail;
14277 }
14278 {
14279 #if wxUSE_UNICODE
14280 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14281 #else
14282 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14283 #endif
14284 }
14285 return resultobj;
14286 fail:
14287 return NULL;
14288 }
14289
14290
14291 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14292 PyObject *resultobj = 0;
14293 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14294 wxString result;
14295 void *argp1 = 0 ;
14296 int res1 = 0 ;
14297 PyObject *swig_obj[1] ;
14298
14299 if (!args) SWIG_fail;
14300 swig_obj[0] = args;
14301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14302 if (!SWIG_IsOK(res1)) {
14303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14304 }
14305 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14306 {
14307 PyThreadState* __tstate = wxPyBeginAllowThreads();
14308 result = (arg1)->GetExtension();
14309 wxPyEndAllowThreads(__tstate);
14310 if (PyErr_Occurred()) SWIG_fail;
14311 }
14312 {
14313 #if wxUSE_UNICODE
14314 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14315 #else
14316 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14317 #endif
14318 }
14319 return resultobj;
14320 fail:
14321 return NULL;
14322 }
14323
14324
14325 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14326 PyObject *resultobj = 0;
14327 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14328 long result;
14329 void *argp1 = 0 ;
14330 int res1 = 0 ;
14331 PyObject *swig_obj[1] ;
14332
14333 if (!args) SWIG_fail;
14334 swig_obj[0] = args;
14335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14336 if (!SWIG_IsOK(res1)) {
14337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14338 }
14339 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14340 {
14341 PyThreadState* __tstate = wxPyBeginAllowThreads();
14342 result = (long)(arg1)->GetType();
14343 wxPyEndAllowThreads(__tstate);
14344 if (PyErr_Occurred()) SWIG_fail;
14345 }
14346 resultobj = SWIG_From_long(static_cast< long >(result));
14347 return resultobj;
14348 fail:
14349 return NULL;
14350 }
14351
14352
14353 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14354 PyObject *resultobj = 0;
14355 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14356 wxString result;
14357 void *argp1 = 0 ;
14358 int res1 = 0 ;
14359 PyObject *swig_obj[1] ;
14360
14361 if (!args) SWIG_fail;
14362 swig_obj[0] = args;
14363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14364 if (!SWIG_IsOK(res1)) {
14365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14366 }
14367 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14368 {
14369 PyThreadState* __tstate = wxPyBeginAllowThreads();
14370 result = (arg1)->GetMimeType();
14371 wxPyEndAllowThreads(__tstate);
14372 if (PyErr_Occurred()) SWIG_fail;
14373 }
14374 {
14375 #if wxUSE_UNICODE
14376 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14377 #else
14378 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14379 #endif
14380 }
14381 return resultobj;
14382 fail:
14383 return NULL;
14384 }
14385
14386
14387 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14388 PyObject *resultobj = 0;
14389 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14390 wxString *arg2 = 0 ;
14391 bool result;
14392 void *argp1 = 0 ;
14393 int res1 = 0 ;
14394 bool temp2 = false ;
14395 PyObject * obj0 = 0 ;
14396 PyObject * obj1 = 0 ;
14397 char * kwnames[] = {
14398 (char *) "self",(char *) "name", NULL
14399 };
14400
14401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14403 if (!SWIG_IsOK(res1)) {
14404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14405 }
14406 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14407 {
14408 arg2 = wxString_in_helper(obj1);
14409 if (arg2 == NULL) SWIG_fail;
14410 temp2 = true;
14411 }
14412 {
14413 PyThreadState* __tstate = wxPyBeginAllowThreads();
14414 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14415 wxPyEndAllowThreads(__tstate);
14416 if (PyErr_Occurred()) SWIG_fail;
14417 }
14418 {
14419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14420 }
14421 {
14422 if (temp2)
14423 delete arg2;
14424 }
14425 return resultobj;
14426 fail:
14427 {
14428 if (temp2)
14429 delete arg2;
14430 }
14431 return NULL;
14432 }
14433
14434
14435 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14436 PyObject *resultobj = 0;
14437 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14438 wxInputStream *arg2 = 0 ;
14439 bool result;
14440 void *argp1 = 0 ;
14441 int res1 = 0 ;
14442 wxPyInputStream *temp2 ;
14443 bool created2 ;
14444 PyObject * obj0 = 0 ;
14445 PyObject * obj1 = 0 ;
14446 char * kwnames[] = {
14447 (char *) "self",(char *) "stream", NULL
14448 };
14449
14450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14452 if (!SWIG_IsOK(res1)) {
14453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14454 }
14455 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14456 {
14457 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14458 arg2 = temp2->m_wxis;
14459 created2 = false;
14460 } else {
14461 PyErr_Clear(); // clear the failure of the wxPyConvert above
14462 arg2 = wxPyCBInputStream_create(obj1, false);
14463 if (arg2 == NULL) {
14464 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14465 SWIG_fail;
14466 }
14467 created2 = true;
14468 }
14469 }
14470 {
14471 PyThreadState* __tstate = wxPyBeginAllowThreads();
14472 result = (bool)(arg1)->CanRead(*arg2);
14473 wxPyEndAllowThreads(__tstate);
14474 if (PyErr_Occurred()) SWIG_fail;
14475 }
14476 {
14477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14478 }
14479 {
14480 if (created2) delete arg2;
14481 }
14482 return resultobj;
14483 fail:
14484 {
14485 if (created2) delete arg2;
14486 }
14487 return NULL;
14488 }
14489
14490
14491 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14492 PyObject *resultobj = 0;
14493 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14494 wxString *arg2 = 0 ;
14495 void *argp1 = 0 ;
14496 int res1 = 0 ;
14497 bool temp2 = false ;
14498 PyObject * obj0 = 0 ;
14499 PyObject * obj1 = 0 ;
14500 char * kwnames[] = {
14501 (char *) "self",(char *) "name", NULL
14502 };
14503
14504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14506 if (!SWIG_IsOK(res1)) {
14507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14508 }
14509 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14510 {
14511 arg2 = wxString_in_helper(obj1);
14512 if (arg2 == NULL) SWIG_fail;
14513 temp2 = true;
14514 }
14515 {
14516 PyThreadState* __tstate = wxPyBeginAllowThreads();
14517 (arg1)->SetName((wxString const &)*arg2);
14518 wxPyEndAllowThreads(__tstate);
14519 if (PyErr_Occurred()) SWIG_fail;
14520 }
14521 resultobj = SWIG_Py_Void();
14522 {
14523 if (temp2)
14524 delete arg2;
14525 }
14526 return resultobj;
14527 fail:
14528 {
14529 if (temp2)
14530 delete arg2;
14531 }
14532 return NULL;
14533 }
14534
14535
14536 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14537 PyObject *resultobj = 0;
14538 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14539 wxString *arg2 = 0 ;
14540 void *argp1 = 0 ;
14541 int res1 = 0 ;
14542 bool temp2 = false ;
14543 PyObject * obj0 = 0 ;
14544 PyObject * obj1 = 0 ;
14545 char * kwnames[] = {
14546 (char *) "self",(char *) "extension", NULL
14547 };
14548
14549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
14550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14551 if (!SWIG_IsOK(res1)) {
14552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14553 }
14554 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14555 {
14556 arg2 = wxString_in_helper(obj1);
14557 if (arg2 == NULL) SWIG_fail;
14558 temp2 = true;
14559 }
14560 {
14561 PyThreadState* __tstate = wxPyBeginAllowThreads();
14562 (arg1)->SetExtension((wxString const &)*arg2);
14563 wxPyEndAllowThreads(__tstate);
14564 if (PyErr_Occurred()) SWIG_fail;
14565 }
14566 resultobj = SWIG_Py_Void();
14567 {
14568 if (temp2)
14569 delete arg2;
14570 }
14571 return resultobj;
14572 fail:
14573 {
14574 if (temp2)
14575 delete arg2;
14576 }
14577 return NULL;
14578 }
14579
14580
14581 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14582 PyObject *resultobj = 0;
14583 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14584 long arg2 ;
14585 void *argp1 = 0 ;
14586 int res1 = 0 ;
14587 long val2 ;
14588 int ecode2 = 0 ;
14589 PyObject * obj0 = 0 ;
14590 PyObject * obj1 = 0 ;
14591 char * kwnames[] = {
14592 (char *) "self",(char *) "type", NULL
14593 };
14594
14595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14597 if (!SWIG_IsOK(res1)) {
14598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14599 }
14600 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14601 ecode2 = SWIG_AsVal_long(obj1, &val2);
14602 if (!SWIG_IsOK(ecode2)) {
14603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14604 }
14605 arg2 = static_cast< long >(val2);
14606 {
14607 PyThreadState* __tstate = wxPyBeginAllowThreads();
14608 (arg1)->SetType(arg2);
14609 wxPyEndAllowThreads(__tstate);
14610 if (PyErr_Occurred()) SWIG_fail;
14611 }
14612 resultobj = SWIG_Py_Void();
14613 return resultobj;
14614 fail:
14615 return NULL;
14616 }
14617
14618
14619 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14620 PyObject *resultobj = 0;
14621 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14622 wxString *arg2 = 0 ;
14623 void *argp1 = 0 ;
14624 int res1 = 0 ;
14625 bool temp2 = false ;
14626 PyObject * obj0 = 0 ;
14627 PyObject * obj1 = 0 ;
14628 char * kwnames[] = {
14629 (char *) "self",(char *) "mimetype", NULL
14630 };
14631
14632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14634 if (!SWIG_IsOK(res1)) {
14635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14636 }
14637 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14638 {
14639 arg2 = wxString_in_helper(obj1);
14640 if (arg2 == NULL) SWIG_fail;
14641 temp2 = true;
14642 }
14643 {
14644 PyThreadState* __tstate = wxPyBeginAllowThreads();
14645 (arg1)->SetMimeType((wxString const &)*arg2);
14646 wxPyEndAllowThreads(__tstate);
14647 if (PyErr_Occurred()) SWIG_fail;
14648 }
14649 resultobj = SWIG_Py_Void();
14650 {
14651 if (temp2)
14652 delete arg2;
14653 }
14654 return resultobj;
14655 fail:
14656 {
14657 if (temp2)
14658 delete arg2;
14659 }
14660 return NULL;
14661 }
14662
14663
14664 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14665 PyObject *obj;
14666 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14667 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14668 return SWIG_Py_Void();
14669 }
14670
14671 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14672 PyObject *resultobj = 0;
14673 wxPyImageHandler *result = 0 ;
14674
14675 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14676 {
14677 PyThreadState* __tstate = wxPyBeginAllowThreads();
14678 result = (wxPyImageHandler *)new wxPyImageHandler();
14679 wxPyEndAllowThreads(__tstate);
14680 if (PyErr_Occurred()) SWIG_fail;
14681 }
14682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14683 return resultobj;
14684 fail:
14685 return NULL;
14686 }
14687
14688
14689 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14690 PyObject *resultobj = 0;
14691 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14692 PyObject *arg2 = (PyObject *) 0 ;
14693 void *argp1 = 0 ;
14694 int res1 = 0 ;
14695 PyObject * obj0 = 0 ;
14696 PyObject * obj1 = 0 ;
14697 char * kwnames[] = {
14698 (char *) "self",(char *) "self", NULL
14699 };
14700
14701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14703 if (!SWIG_IsOK(res1)) {
14704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14705 }
14706 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14707 arg2 = obj1;
14708 {
14709 PyThreadState* __tstate = wxPyBeginAllowThreads();
14710 (arg1)->_SetSelf(arg2);
14711 wxPyEndAllowThreads(__tstate);
14712 if (PyErr_Occurred()) SWIG_fail;
14713 }
14714 resultobj = SWIG_Py_Void();
14715 return resultobj;
14716 fail:
14717 return NULL;
14718 }
14719
14720
14721 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14722 PyObject *obj;
14723 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14724 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14725 return SWIG_Py_Void();
14726 }
14727
14728 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14729 return SWIG_Python_InitShadowInstance(args);
14730 }
14731
14732 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14733 PyObject *resultobj = 0;
14734 wxImageHistogram *result = 0 ;
14735
14736 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14737 {
14738 PyThreadState* __tstate = wxPyBeginAllowThreads();
14739 result = (wxImageHistogram *)new wxImageHistogram();
14740 wxPyEndAllowThreads(__tstate);
14741 if (PyErr_Occurred()) SWIG_fail;
14742 }
14743 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14744 return resultobj;
14745 fail:
14746 return NULL;
14747 }
14748
14749
14750 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14751 PyObject *resultobj = 0;
14752 byte arg1 ;
14753 byte arg2 ;
14754 byte arg3 ;
14755 unsigned long result;
14756 unsigned char val1 ;
14757 int ecode1 = 0 ;
14758 unsigned char val2 ;
14759 int ecode2 = 0 ;
14760 unsigned char val3 ;
14761 int ecode3 = 0 ;
14762 PyObject * obj0 = 0 ;
14763 PyObject * obj1 = 0 ;
14764 PyObject * obj2 = 0 ;
14765 char * kwnames[] = {
14766 (char *) "r",(char *) "g",(char *) "b", NULL
14767 };
14768
14769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14770 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14771 if (!SWIG_IsOK(ecode1)) {
14772 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14773 }
14774 arg1 = static_cast< byte >(val1);
14775 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14776 if (!SWIG_IsOK(ecode2)) {
14777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14778 }
14779 arg2 = static_cast< byte >(val2);
14780 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14781 if (!SWIG_IsOK(ecode3)) {
14782 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14783 }
14784 arg3 = static_cast< byte >(val3);
14785 {
14786 PyThreadState* __tstate = wxPyBeginAllowThreads();
14787 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14788 wxPyEndAllowThreads(__tstate);
14789 if (PyErr_Occurred()) SWIG_fail;
14790 }
14791 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14792 return resultobj;
14793 fail:
14794 return NULL;
14795 }
14796
14797
14798 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14799 PyObject *resultobj = 0;
14800 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14801 byte *arg2 = (byte *) 0 ;
14802 byte *arg3 = (byte *) 0 ;
14803 byte *arg4 = (byte *) 0 ;
14804 byte arg5 = (byte) 1 ;
14805 byte arg6 = (byte) 0 ;
14806 byte arg7 = (byte) 0 ;
14807 bool result;
14808 void *argp1 = 0 ;
14809 int res1 = 0 ;
14810 byte temp2 ;
14811 int res2 = SWIG_TMPOBJ ;
14812 byte temp3 ;
14813 int res3 = SWIG_TMPOBJ ;
14814 byte temp4 ;
14815 int res4 = SWIG_TMPOBJ ;
14816 unsigned char val5 ;
14817 int ecode5 = 0 ;
14818 unsigned char val6 ;
14819 int ecode6 = 0 ;
14820 unsigned char val7 ;
14821 int ecode7 = 0 ;
14822 PyObject * obj0 = 0 ;
14823 PyObject * obj1 = 0 ;
14824 PyObject * obj2 = 0 ;
14825 PyObject * obj3 = 0 ;
14826 char * kwnames[] = {
14827 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14828 };
14829
14830 arg2 = &temp2;
14831 arg3 = &temp3;
14832 arg4 = &temp4;
14833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14835 if (!SWIG_IsOK(res1)) {
14836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14837 }
14838 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14839 if (obj1) {
14840 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14841 if (!SWIG_IsOK(ecode5)) {
14842 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14843 }
14844 arg5 = static_cast< byte >(val5);
14845 }
14846 if (obj2) {
14847 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14848 if (!SWIG_IsOK(ecode6)) {
14849 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14850 }
14851 arg6 = static_cast< byte >(val6);
14852 }
14853 if (obj3) {
14854 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14855 if (!SWIG_IsOK(ecode7)) {
14856 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14857 }
14858 arg7 = static_cast< byte >(val7);
14859 }
14860 {
14861 PyThreadState* __tstate = wxPyBeginAllowThreads();
14862 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14863 wxPyEndAllowThreads(__tstate);
14864 if (PyErr_Occurred()) SWIG_fail;
14865 }
14866 {
14867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14868 }
14869 if (SWIG_IsTmpObj(res2)) {
14870 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14871 } else {
14872 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14873 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14874 }
14875 if (SWIG_IsTmpObj(res3)) {
14876 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14877 } else {
14878 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14879 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14880 }
14881 if (SWIG_IsTmpObj(res4)) {
14882 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14883 } else {
14884 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14885 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14886 }
14887 return resultobj;
14888 fail:
14889 return NULL;
14890 }
14891
14892
14893 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14894 PyObject *resultobj = 0;
14895 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14896 unsigned long arg2 ;
14897 unsigned long result;
14898 void *argp1 = 0 ;
14899 int res1 = 0 ;
14900 unsigned long val2 ;
14901 int ecode2 = 0 ;
14902 PyObject * obj0 = 0 ;
14903 PyObject * obj1 = 0 ;
14904 char * kwnames[] = {
14905 (char *) "self",(char *) "key", NULL
14906 };
14907
14908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14910 if (!SWIG_IsOK(res1)) {
14911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14912 }
14913 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14914 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14915 if (!SWIG_IsOK(ecode2)) {
14916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14917 }
14918 arg2 = static_cast< unsigned long >(val2);
14919 {
14920 PyThreadState* __tstate = wxPyBeginAllowThreads();
14921 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14922 wxPyEndAllowThreads(__tstate);
14923 if (PyErr_Occurred()) SWIG_fail;
14924 }
14925 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14926 return resultobj;
14927 fail:
14928 return NULL;
14929 }
14930
14931
14932 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14933 PyObject *resultobj = 0;
14934 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14935 byte arg2 ;
14936 byte arg3 ;
14937 byte arg4 ;
14938 unsigned long result;
14939 void *argp1 = 0 ;
14940 int res1 = 0 ;
14941 unsigned char val2 ;
14942 int ecode2 = 0 ;
14943 unsigned char val3 ;
14944 int ecode3 = 0 ;
14945 unsigned char val4 ;
14946 int ecode4 = 0 ;
14947 PyObject * obj0 = 0 ;
14948 PyObject * obj1 = 0 ;
14949 PyObject * obj2 = 0 ;
14950 PyObject * obj3 = 0 ;
14951 char * kwnames[] = {
14952 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14953 };
14954
14955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14957 if (!SWIG_IsOK(res1)) {
14958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14959 }
14960 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14961 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14962 if (!SWIG_IsOK(ecode2)) {
14963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
14964 }
14965 arg2 = static_cast< byte >(val2);
14966 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14967 if (!SWIG_IsOK(ecode3)) {
14968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
14969 }
14970 arg3 = static_cast< byte >(val3);
14971 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14972 if (!SWIG_IsOK(ecode4)) {
14973 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
14974 }
14975 arg4 = static_cast< byte >(val4);
14976 {
14977 PyThreadState* __tstate = wxPyBeginAllowThreads();
14978 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
14979 wxPyEndAllowThreads(__tstate);
14980 if (PyErr_Occurred()) SWIG_fail;
14981 }
14982 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14983 return resultobj;
14984 fail:
14985 return NULL;
14986 }
14987
14988
14989 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14990 PyObject *resultobj = 0;
14991 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14992 wxColour *arg2 = 0 ;
14993 unsigned long result;
14994 void *argp1 = 0 ;
14995 int res1 = 0 ;
14996 wxColour temp2 ;
14997 PyObject * obj0 = 0 ;
14998 PyObject * obj1 = 0 ;
14999 char * kwnames[] = {
15000 (char *) "self",(char *) "colour", NULL
15001 };
15002
15003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
15004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15005 if (!SWIG_IsOK(res1)) {
15006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15007 }
15008 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15009 {
15010 arg2 = &temp2;
15011 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15012 }
15013 {
15014 PyThreadState* __tstate = wxPyBeginAllowThreads();
15015 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15016 wxPyEndAllowThreads(__tstate);
15017 if (PyErr_Occurred()) SWIG_fail;
15018 }
15019 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15020 return resultobj;
15021 fail:
15022 return NULL;
15023 }
15024
15025
15026 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15027 PyObject *obj;
15028 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15029 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15030 return SWIG_Py_Void();
15031 }
15032
15033 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15034 return SWIG_Python_InitShadowInstance(args);
15035 }
15036
15037 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15038 PyObject *resultobj = 0;
15039 byte arg1 = (byte) 0 ;
15040 byte arg2 = (byte) 0 ;
15041 byte arg3 = (byte) 0 ;
15042 wxImage_RGBValue *result = 0 ;
15043 unsigned char val1 ;
15044 int ecode1 = 0 ;
15045 unsigned char val2 ;
15046 int ecode2 = 0 ;
15047 unsigned char val3 ;
15048 int ecode3 = 0 ;
15049 PyObject * obj0 = 0 ;
15050 PyObject * obj1 = 0 ;
15051 PyObject * obj2 = 0 ;
15052 char * kwnames[] = {
15053 (char *) "r",(char *) "g",(char *) "b", NULL
15054 };
15055
15056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15057 if (obj0) {
15058 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15059 if (!SWIG_IsOK(ecode1)) {
15060 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15061 }
15062 arg1 = static_cast< byte >(val1);
15063 }
15064 if (obj1) {
15065 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15066 if (!SWIG_IsOK(ecode2)) {
15067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15068 }
15069 arg2 = static_cast< byte >(val2);
15070 }
15071 if (obj2) {
15072 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15073 if (!SWIG_IsOK(ecode3)) {
15074 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15075 }
15076 arg3 = static_cast< byte >(val3);
15077 }
15078 {
15079 PyThreadState* __tstate = wxPyBeginAllowThreads();
15080 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15081 wxPyEndAllowThreads(__tstate);
15082 if (PyErr_Occurred()) SWIG_fail;
15083 }
15084 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15085 return resultobj;
15086 fail:
15087 return NULL;
15088 }
15089
15090
15091 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15092 PyObject *resultobj = 0;
15093 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15094 byte arg2 ;
15095 void *argp1 = 0 ;
15096 int res1 = 0 ;
15097 unsigned char val2 ;
15098 int ecode2 = 0 ;
15099 PyObject *swig_obj[2] ;
15100
15101 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15103 if (!SWIG_IsOK(res1)) {
15104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15105 }
15106 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15107 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15108 if (!SWIG_IsOK(ecode2)) {
15109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15110 }
15111 arg2 = static_cast< byte >(val2);
15112 if (arg1) (arg1)->red = arg2;
15113
15114 resultobj = SWIG_Py_Void();
15115 return resultobj;
15116 fail:
15117 return NULL;
15118 }
15119
15120
15121 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15122 PyObject *resultobj = 0;
15123 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15124 byte result;
15125 void *argp1 = 0 ;
15126 int res1 = 0 ;
15127 PyObject *swig_obj[1] ;
15128
15129 if (!args) SWIG_fail;
15130 swig_obj[0] = args;
15131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15132 if (!SWIG_IsOK(res1)) {
15133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15134 }
15135 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15136 result = (byte) ((arg1)->red);
15137 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15138 return resultobj;
15139 fail:
15140 return NULL;
15141 }
15142
15143
15144 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15145 PyObject *resultobj = 0;
15146 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15147 byte arg2 ;
15148 void *argp1 = 0 ;
15149 int res1 = 0 ;
15150 unsigned char val2 ;
15151 int ecode2 = 0 ;
15152 PyObject *swig_obj[2] ;
15153
15154 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15156 if (!SWIG_IsOK(res1)) {
15157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15158 }
15159 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15160 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15161 if (!SWIG_IsOK(ecode2)) {
15162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15163 }
15164 arg2 = static_cast< byte >(val2);
15165 if (arg1) (arg1)->green = arg2;
15166
15167 resultobj = SWIG_Py_Void();
15168 return resultobj;
15169 fail:
15170 return NULL;
15171 }
15172
15173
15174 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15175 PyObject *resultobj = 0;
15176 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15177 byte result;
15178 void *argp1 = 0 ;
15179 int res1 = 0 ;
15180 PyObject *swig_obj[1] ;
15181
15182 if (!args) SWIG_fail;
15183 swig_obj[0] = args;
15184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15185 if (!SWIG_IsOK(res1)) {
15186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15187 }
15188 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15189 result = (byte) ((arg1)->green);
15190 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15191 return resultobj;
15192 fail:
15193 return NULL;
15194 }
15195
15196
15197 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15198 PyObject *resultobj = 0;
15199 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15200 byte arg2 ;
15201 void *argp1 = 0 ;
15202 int res1 = 0 ;
15203 unsigned char val2 ;
15204 int ecode2 = 0 ;
15205 PyObject *swig_obj[2] ;
15206
15207 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15209 if (!SWIG_IsOK(res1)) {
15210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15211 }
15212 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15213 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15214 if (!SWIG_IsOK(ecode2)) {
15215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15216 }
15217 arg2 = static_cast< byte >(val2);
15218 if (arg1) (arg1)->blue = arg2;
15219
15220 resultobj = SWIG_Py_Void();
15221 return resultobj;
15222 fail:
15223 return NULL;
15224 }
15225
15226
15227 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15228 PyObject *resultobj = 0;
15229 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15230 byte result;
15231 void *argp1 = 0 ;
15232 int res1 = 0 ;
15233 PyObject *swig_obj[1] ;
15234
15235 if (!args) SWIG_fail;
15236 swig_obj[0] = args;
15237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15238 if (!SWIG_IsOK(res1)) {
15239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15240 }
15241 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15242 result = (byte) ((arg1)->blue);
15243 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15244 return resultobj;
15245 fail:
15246 return NULL;
15247 }
15248
15249
15250 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15251 PyObject *obj;
15252 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15253 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15254 return SWIG_Py_Void();
15255 }
15256
15257 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15258 return SWIG_Python_InitShadowInstance(args);
15259 }
15260
15261 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15262 PyObject *resultobj = 0;
15263 double arg1 = (double) 0.0 ;
15264 double arg2 = (double) 0.0 ;
15265 double arg3 = (double) 0.0 ;
15266 wxImage_HSVValue *result = 0 ;
15267 double val1 ;
15268 int ecode1 = 0 ;
15269 double val2 ;
15270 int ecode2 = 0 ;
15271 double val3 ;
15272 int ecode3 = 0 ;
15273 PyObject * obj0 = 0 ;
15274 PyObject * obj1 = 0 ;
15275 PyObject * obj2 = 0 ;
15276 char * kwnames[] = {
15277 (char *) "h",(char *) "s",(char *) "v", NULL
15278 };
15279
15280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15281 if (obj0) {
15282 ecode1 = SWIG_AsVal_double(obj0, &val1);
15283 if (!SWIG_IsOK(ecode1)) {
15284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15285 }
15286 arg1 = static_cast< double >(val1);
15287 }
15288 if (obj1) {
15289 ecode2 = SWIG_AsVal_double(obj1, &val2);
15290 if (!SWIG_IsOK(ecode2)) {
15291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15292 }
15293 arg2 = static_cast< double >(val2);
15294 }
15295 if (obj2) {
15296 ecode3 = SWIG_AsVal_double(obj2, &val3);
15297 if (!SWIG_IsOK(ecode3)) {
15298 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15299 }
15300 arg3 = static_cast< double >(val3);
15301 }
15302 {
15303 PyThreadState* __tstate = wxPyBeginAllowThreads();
15304 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15305 wxPyEndAllowThreads(__tstate);
15306 if (PyErr_Occurred()) SWIG_fail;
15307 }
15308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15309 return resultobj;
15310 fail:
15311 return NULL;
15312 }
15313
15314
15315 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15316 PyObject *resultobj = 0;
15317 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15318 double arg2 ;
15319 void *argp1 = 0 ;
15320 int res1 = 0 ;
15321 double val2 ;
15322 int ecode2 = 0 ;
15323 PyObject *swig_obj[2] ;
15324
15325 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15327 if (!SWIG_IsOK(res1)) {
15328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15329 }
15330 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15331 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15332 if (!SWIG_IsOK(ecode2)) {
15333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15334 }
15335 arg2 = static_cast< double >(val2);
15336 if (arg1) (arg1)->hue = arg2;
15337
15338 resultobj = SWIG_Py_Void();
15339 return resultobj;
15340 fail:
15341 return NULL;
15342 }
15343
15344
15345 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15346 PyObject *resultobj = 0;
15347 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15348 double result;
15349 void *argp1 = 0 ;
15350 int res1 = 0 ;
15351 PyObject *swig_obj[1] ;
15352
15353 if (!args) SWIG_fail;
15354 swig_obj[0] = args;
15355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15356 if (!SWIG_IsOK(res1)) {
15357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15358 }
15359 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15360 result = (double) ((arg1)->hue);
15361 resultobj = SWIG_From_double(static_cast< double >(result));
15362 return resultobj;
15363 fail:
15364 return NULL;
15365 }
15366
15367
15368 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15369 PyObject *resultobj = 0;
15370 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15371 double arg2 ;
15372 void *argp1 = 0 ;
15373 int res1 = 0 ;
15374 double val2 ;
15375 int ecode2 = 0 ;
15376 PyObject *swig_obj[2] ;
15377
15378 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15380 if (!SWIG_IsOK(res1)) {
15381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15382 }
15383 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15384 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15385 if (!SWIG_IsOK(ecode2)) {
15386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15387 }
15388 arg2 = static_cast< double >(val2);
15389 if (arg1) (arg1)->saturation = arg2;
15390
15391 resultobj = SWIG_Py_Void();
15392 return resultobj;
15393 fail:
15394 return NULL;
15395 }
15396
15397
15398 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15399 PyObject *resultobj = 0;
15400 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15401 double result;
15402 void *argp1 = 0 ;
15403 int res1 = 0 ;
15404 PyObject *swig_obj[1] ;
15405
15406 if (!args) SWIG_fail;
15407 swig_obj[0] = args;
15408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15409 if (!SWIG_IsOK(res1)) {
15410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15411 }
15412 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15413 result = (double) ((arg1)->saturation);
15414 resultobj = SWIG_From_double(static_cast< double >(result));
15415 return resultobj;
15416 fail:
15417 return NULL;
15418 }
15419
15420
15421 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15422 PyObject *resultobj = 0;
15423 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15424 double arg2 ;
15425 void *argp1 = 0 ;
15426 int res1 = 0 ;
15427 double val2 ;
15428 int ecode2 = 0 ;
15429 PyObject *swig_obj[2] ;
15430
15431 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15433 if (!SWIG_IsOK(res1)) {
15434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15435 }
15436 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15437 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15438 if (!SWIG_IsOK(ecode2)) {
15439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15440 }
15441 arg2 = static_cast< double >(val2);
15442 if (arg1) (arg1)->value = arg2;
15443
15444 resultobj = SWIG_Py_Void();
15445 return resultobj;
15446 fail:
15447 return NULL;
15448 }
15449
15450
15451 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15452 PyObject *resultobj = 0;
15453 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15454 double result;
15455 void *argp1 = 0 ;
15456 int res1 = 0 ;
15457 PyObject *swig_obj[1] ;
15458
15459 if (!args) SWIG_fail;
15460 swig_obj[0] = args;
15461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15462 if (!SWIG_IsOK(res1)) {
15463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15464 }
15465 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15466 result = (double) ((arg1)->value);
15467 resultobj = SWIG_From_double(static_cast< double >(result));
15468 return resultobj;
15469 fail:
15470 return NULL;
15471 }
15472
15473
15474 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15475 PyObject *obj;
15476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15477 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15478 return SWIG_Py_Void();
15479 }
15480
15481 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15482 return SWIG_Python_InitShadowInstance(args);
15483 }
15484
15485 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15486 PyObject *resultobj = 0;
15487 wxString *arg1 = 0 ;
15488 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15489 int arg3 = (int) -1 ;
15490 wxImage *result = 0 ;
15491 bool temp1 = false ;
15492 long val2 ;
15493 int ecode2 = 0 ;
15494 int val3 ;
15495 int ecode3 = 0 ;
15496 PyObject * obj0 = 0 ;
15497 PyObject * obj1 = 0 ;
15498 PyObject * obj2 = 0 ;
15499 char * kwnames[] = {
15500 (char *) "name",(char *) "type",(char *) "index", NULL
15501 };
15502
15503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15504 {
15505 arg1 = wxString_in_helper(obj0);
15506 if (arg1 == NULL) SWIG_fail;
15507 temp1 = true;
15508 }
15509 if (obj1) {
15510 ecode2 = SWIG_AsVal_long(obj1, &val2);
15511 if (!SWIG_IsOK(ecode2)) {
15512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15513 }
15514 arg2 = static_cast< long >(val2);
15515 }
15516 if (obj2) {
15517 ecode3 = SWIG_AsVal_int(obj2, &val3);
15518 if (!SWIG_IsOK(ecode3)) {
15519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15520 }
15521 arg3 = static_cast< int >(val3);
15522 }
15523 {
15524 PyThreadState* __tstate = wxPyBeginAllowThreads();
15525 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15526 wxPyEndAllowThreads(__tstate);
15527 if (PyErr_Occurred()) SWIG_fail;
15528 }
15529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15530 {
15531 if (temp1)
15532 delete arg1;
15533 }
15534 return resultobj;
15535 fail:
15536 {
15537 if (temp1)
15538 delete arg1;
15539 }
15540 return NULL;
15541 }
15542
15543
15544 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15545 PyObject *resultobj = 0;
15546 wxImage *arg1 = (wxImage *) 0 ;
15547 void *argp1 = 0 ;
15548 int res1 = 0 ;
15549 PyObject *swig_obj[1] ;
15550
15551 if (!args) SWIG_fail;
15552 swig_obj[0] = args;
15553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15554 if (!SWIG_IsOK(res1)) {
15555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15556 }
15557 arg1 = reinterpret_cast< wxImage * >(argp1);
15558 {
15559 PyThreadState* __tstate = wxPyBeginAllowThreads();
15560 delete arg1;
15561
15562 wxPyEndAllowThreads(__tstate);
15563 if (PyErr_Occurred()) SWIG_fail;
15564 }
15565 resultobj = SWIG_Py_Void();
15566 return resultobj;
15567 fail:
15568 return NULL;
15569 }
15570
15571
15572 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15573 PyObject *resultobj = 0;
15574 wxString *arg1 = 0 ;
15575 wxString *arg2 = 0 ;
15576 int arg3 = (int) -1 ;
15577 wxImage *result = 0 ;
15578 bool temp1 = false ;
15579 bool temp2 = false ;
15580 int val3 ;
15581 int ecode3 = 0 ;
15582 PyObject * obj0 = 0 ;
15583 PyObject * obj1 = 0 ;
15584 PyObject * obj2 = 0 ;
15585 char * kwnames[] = {
15586 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15587 };
15588
15589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15590 {
15591 arg1 = wxString_in_helper(obj0);
15592 if (arg1 == NULL) SWIG_fail;
15593 temp1 = true;
15594 }
15595 {
15596 arg2 = wxString_in_helper(obj1);
15597 if (arg2 == NULL) SWIG_fail;
15598 temp2 = true;
15599 }
15600 if (obj2) {
15601 ecode3 = SWIG_AsVal_int(obj2, &val3);
15602 if (!SWIG_IsOK(ecode3)) {
15603 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15604 }
15605 arg3 = static_cast< int >(val3);
15606 }
15607 {
15608 PyThreadState* __tstate = wxPyBeginAllowThreads();
15609 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15610 wxPyEndAllowThreads(__tstate);
15611 if (PyErr_Occurred()) SWIG_fail;
15612 }
15613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15614 {
15615 if (temp1)
15616 delete arg1;
15617 }
15618 {
15619 if (temp2)
15620 delete arg2;
15621 }
15622 return resultobj;
15623 fail:
15624 {
15625 if (temp1)
15626 delete arg1;
15627 }
15628 {
15629 if (temp2)
15630 delete arg2;
15631 }
15632 return NULL;
15633 }
15634
15635
15636 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15637 PyObject *resultobj = 0;
15638 wxInputStream *arg1 = 0 ;
15639 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15640 int arg3 = (int) -1 ;
15641 wxImage *result = 0 ;
15642 wxPyInputStream *temp1 ;
15643 bool created1 ;
15644 long val2 ;
15645 int ecode2 = 0 ;
15646 int val3 ;
15647 int ecode3 = 0 ;
15648 PyObject * obj0 = 0 ;
15649 PyObject * obj1 = 0 ;
15650 PyObject * obj2 = 0 ;
15651 char * kwnames[] = {
15652 (char *) "stream",(char *) "type",(char *) "index", NULL
15653 };
15654
15655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15656 {
15657 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15658 arg1 = temp1->m_wxis;
15659 created1 = false;
15660 } else {
15661 PyErr_Clear(); // clear the failure of the wxPyConvert above
15662 arg1 = wxPyCBInputStream_create(obj0, false);
15663 if (arg1 == NULL) {
15664 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15665 SWIG_fail;
15666 }
15667 created1 = true;
15668 }
15669 }
15670 if (obj1) {
15671 ecode2 = SWIG_AsVal_long(obj1, &val2);
15672 if (!SWIG_IsOK(ecode2)) {
15673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15674 }
15675 arg2 = static_cast< long >(val2);
15676 }
15677 if (obj2) {
15678 ecode3 = SWIG_AsVal_int(obj2, &val3);
15679 if (!SWIG_IsOK(ecode3)) {
15680 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15681 }
15682 arg3 = static_cast< int >(val3);
15683 }
15684 {
15685 PyThreadState* __tstate = wxPyBeginAllowThreads();
15686 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15687 wxPyEndAllowThreads(__tstate);
15688 if (PyErr_Occurred()) SWIG_fail;
15689 }
15690 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15691 {
15692 if (created1) delete arg1;
15693 }
15694 return resultobj;
15695 fail:
15696 {
15697 if (created1) delete arg1;
15698 }
15699 return NULL;
15700 }
15701
15702
15703 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15704 PyObject *resultobj = 0;
15705 wxInputStream *arg1 = 0 ;
15706 wxString *arg2 = 0 ;
15707 int arg3 = (int) -1 ;
15708 wxImage *result = 0 ;
15709 wxPyInputStream *temp1 ;
15710 bool created1 ;
15711 bool temp2 = false ;
15712 int val3 ;
15713 int ecode3 = 0 ;
15714 PyObject * obj0 = 0 ;
15715 PyObject * obj1 = 0 ;
15716 PyObject * obj2 = 0 ;
15717 char * kwnames[] = {
15718 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15719 };
15720
15721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15722 {
15723 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15724 arg1 = temp1->m_wxis;
15725 created1 = false;
15726 } else {
15727 PyErr_Clear(); // clear the failure of the wxPyConvert above
15728 arg1 = wxPyCBInputStream_create(obj0, false);
15729 if (arg1 == NULL) {
15730 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15731 SWIG_fail;
15732 }
15733 created1 = true;
15734 }
15735 }
15736 {
15737 arg2 = wxString_in_helper(obj1);
15738 if (arg2 == NULL) SWIG_fail;
15739 temp2 = true;
15740 }
15741 if (obj2) {
15742 ecode3 = SWIG_AsVal_int(obj2, &val3);
15743 if (!SWIG_IsOK(ecode3)) {
15744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15745 }
15746 arg3 = static_cast< int >(val3);
15747 }
15748 {
15749 PyThreadState* __tstate = wxPyBeginAllowThreads();
15750 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15751 wxPyEndAllowThreads(__tstate);
15752 if (PyErr_Occurred()) SWIG_fail;
15753 }
15754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15755 {
15756 if (created1) delete arg1;
15757 }
15758 {
15759 if (temp2)
15760 delete arg2;
15761 }
15762 return resultobj;
15763 fail:
15764 {
15765 if (created1) delete arg1;
15766 }
15767 {
15768 if (temp2)
15769 delete arg2;
15770 }
15771 return NULL;
15772 }
15773
15774
15775 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15776 PyObject *resultobj = 0;
15777 int arg1 = (int) 0 ;
15778 int arg2 = (int) 0 ;
15779 bool arg3 = (bool) true ;
15780 wxImage *result = 0 ;
15781 int val1 ;
15782 int ecode1 = 0 ;
15783 int val2 ;
15784 int ecode2 = 0 ;
15785 bool val3 ;
15786 int ecode3 = 0 ;
15787 PyObject * obj0 = 0 ;
15788 PyObject * obj1 = 0 ;
15789 PyObject * obj2 = 0 ;
15790 char * kwnames[] = {
15791 (char *) "width",(char *) "height",(char *) "clear", NULL
15792 };
15793
15794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15795 if (obj0) {
15796 ecode1 = SWIG_AsVal_int(obj0, &val1);
15797 if (!SWIG_IsOK(ecode1)) {
15798 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15799 }
15800 arg1 = static_cast< int >(val1);
15801 }
15802 if (obj1) {
15803 ecode2 = SWIG_AsVal_int(obj1, &val2);
15804 if (!SWIG_IsOK(ecode2)) {
15805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15806 }
15807 arg2 = static_cast< int >(val2);
15808 }
15809 if (obj2) {
15810 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15811 if (!SWIG_IsOK(ecode3)) {
15812 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15813 }
15814 arg3 = static_cast< bool >(val3);
15815 }
15816 {
15817 PyThreadState* __tstate = wxPyBeginAllowThreads();
15818 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15819 wxPyEndAllowThreads(__tstate);
15820 if (PyErr_Occurred()) SWIG_fail;
15821 }
15822 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15823 return resultobj;
15824 fail:
15825 return NULL;
15826 }
15827
15828
15829 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15830 PyObject *resultobj = 0;
15831 wxBitmap *arg1 = 0 ;
15832 wxImage *result = 0 ;
15833 void *argp1 = 0 ;
15834 int res1 = 0 ;
15835 PyObject * obj0 = 0 ;
15836 char * kwnames[] = {
15837 (char *) "bitmap", NULL
15838 };
15839
15840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15841 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15842 if (!SWIG_IsOK(res1)) {
15843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15844 }
15845 if (!argp1) {
15846 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15847 }
15848 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15849 {
15850 if (!wxPyCheckForApp()) SWIG_fail;
15851 PyThreadState* __tstate = wxPyBeginAllowThreads();
15852 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15853 wxPyEndAllowThreads(__tstate);
15854 if (PyErr_Occurred()) SWIG_fail;
15855 }
15856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15857 return resultobj;
15858 fail:
15859 return NULL;
15860 }
15861
15862
15863 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15864 PyObject *resultobj = 0;
15865 int arg1 ;
15866 int arg2 ;
15867 buffer arg3 ;
15868 int arg4 ;
15869 wxImage *result = 0 ;
15870 int val1 ;
15871 int ecode1 = 0 ;
15872 int val2 ;
15873 int ecode2 = 0 ;
15874 Py_ssize_t temp3 ;
15875 PyObject * obj0 = 0 ;
15876 PyObject * obj1 = 0 ;
15877 PyObject * obj2 = 0 ;
15878 char * kwnames[] = {
15879 (char *) "width",(char *) "height",(char *) "data", NULL
15880 };
15881
15882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15883 ecode1 = SWIG_AsVal_int(obj0, &val1);
15884 if (!SWIG_IsOK(ecode1)) {
15885 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15886 }
15887 arg1 = static_cast< int >(val1);
15888 ecode2 = SWIG_AsVal_int(obj1, &val2);
15889 if (!SWIG_IsOK(ecode2)) {
15890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15891 }
15892 arg2 = static_cast< int >(val2);
15893 {
15894 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15895 arg4 = (int)temp3;
15896 }
15897 {
15898 PyThreadState* __tstate = wxPyBeginAllowThreads();
15899 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
15900 wxPyEndAllowThreads(__tstate);
15901 if (PyErr_Occurred()) SWIG_fail;
15902 }
15903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15904 return resultobj;
15905 fail:
15906 return NULL;
15907 }
15908
15909
15910 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15911 PyObject *resultobj = 0;
15912 int arg1 ;
15913 int arg2 ;
15914 buffer arg3 ;
15915 int arg4 ;
15916 buffer arg5 ;
15917 int arg6 ;
15918 wxImage *result = 0 ;
15919 int val1 ;
15920 int ecode1 = 0 ;
15921 int val2 ;
15922 int ecode2 = 0 ;
15923 Py_ssize_t temp3 ;
15924 Py_ssize_t temp5 ;
15925 PyObject * obj0 = 0 ;
15926 PyObject * obj1 = 0 ;
15927 PyObject * obj2 = 0 ;
15928 PyObject * obj3 = 0 ;
15929 char * kwnames[] = {
15930 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
15931 };
15932
15933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15934 ecode1 = SWIG_AsVal_int(obj0, &val1);
15935 if (!SWIG_IsOK(ecode1)) {
15936 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
15937 }
15938 arg1 = static_cast< int >(val1);
15939 ecode2 = SWIG_AsVal_int(obj1, &val2);
15940 if (!SWIG_IsOK(ecode2)) {
15941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
15942 }
15943 arg2 = static_cast< int >(val2);
15944 {
15945 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15946 arg4 = (int)temp3;
15947 }
15948 {
15949 if (obj3 != Py_None) {
15950 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
15951 arg6 = (int)temp5;
15952 }
15953 }
15954 {
15955 PyThreadState* __tstate = wxPyBeginAllowThreads();
15956 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
15957 wxPyEndAllowThreads(__tstate);
15958 if (PyErr_Occurred()) SWIG_fail;
15959 }
15960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15961 return resultobj;
15962 fail:
15963 return NULL;
15964 }
15965
15966
15967 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15968 PyObject *resultobj = 0;
15969 wxImage *arg1 = (wxImage *) 0 ;
15970 int arg2 ;
15971 int arg3 ;
15972 bool arg4 = (bool) true ;
15973 void *argp1 = 0 ;
15974 int res1 = 0 ;
15975 int val2 ;
15976 int ecode2 = 0 ;
15977 int val3 ;
15978 int ecode3 = 0 ;
15979 bool val4 ;
15980 int ecode4 = 0 ;
15981 PyObject * obj0 = 0 ;
15982 PyObject * obj1 = 0 ;
15983 PyObject * obj2 = 0 ;
15984 PyObject * obj3 = 0 ;
15985 char * kwnames[] = {
15986 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
15987 };
15988
15989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15991 if (!SWIG_IsOK(res1)) {
15992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
15993 }
15994 arg1 = reinterpret_cast< wxImage * >(argp1);
15995 ecode2 = SWIG_AsVal_int(obj1, &val2);
15996 if (!SWIG_IsOK(ecode2)) {
15997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
15998 }
15999 arg2 = static_cast< int >(val2);
16000 ecode3 = SWIG_AsVal_int(obj2, &val3);
16001 if (!SWIG_IsOK(ecode3)) {
16002 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
16003 }
16004 arg3 = static_cast< int >(val3);
16005 if (obj3) {
16006 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16007 if (!SWIG_IsOK(ecode4)) {
16008 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
16009 }
16010 arg4 = static_cast< bool >(val4);
16011 }
16012 {
16013 PyThreadState* __tstate = wxPyBeginAllowThreads();
16014 (arg1)->Create(arg2,arg3,arg4);
16015 wxPyEndAllowThreads(__tstate);
16016 if (PyErr_Occurred()) SWIG_fail;
16017 }
16018 resultobj = SWIG_Py_Void();
16019 return resultobj;
16020 fail:
16021 return NULL;
16022 }
16023
16024
16025 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16026 PyObject *resultobj = 0;
16027 wxImage *arg1 = (wxImage *) 0 ;
16028 void *argp1 = 0 ;
16029 int res1 = 0 ;
16030 PyObject *swig_obj[1] ;
16031
16032 if (!args) SWIG_fail;
16033 swig_obj[0] = args;
16034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16035 if (!SWIG_IsOK(res1)) {
16036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16037 }
16038 arg1 = reinterpret_cast< wxImage * >(argp1);
16039 {
16040 PyThreadState* __tstate = wxPyBeginAllowThreads();
16041 (arg1)->Destroy();
16042 wxPyEndAllowThreads(__tstate);
16043 if (PyErr_Occurred()) SWIG_fail;
16044 }
16045 resultobj = SWIG_Py_Void();
16046 return resultobj;
16047 fail:
16048 return NULL;
16049 }
16050
16051
16052 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16053 PyObject *resultobj = 0;
16054 wxImage *arg1 = (wxImage *) 0 ;
16055 int arg2 ;
16056 int arg3 ;
16057 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16058 SwigValueWrapper<wxImage > result;
16059 void *argp1 = 0 ;
16060 int res1 = 0 ;
16061 int val2 ;
16062 int ecode2 = 0 ;
16063 int val3 ;
16064 int ecode3 = 0 ;
16065 int val4 ;
16066 int ecode4 = 0 ;
16067 PyObject * obj0 = 0 ;
16068 PyObject * obj1 = 0 ;
16069 PyObject * obj2 = 0 ;
16070 PyObject * obj3 = 0 ;
16071 char * kwnames[] = {
16072 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16073 };
16074
16075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16077 if (!SWIG_IsOK(res1)) {
16078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16079 }
16080 arg1 = reinterpret_cast< wxImage * >(argp1);
16081 ecode2 = SWIG_AsVal_int(obj1, &val2);
16082 if (!SWIG_IsOK(ecode2)) {
16083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16084 }
16085 arg2 = static_cast< int >(val2);
16086 ecode3 = SWIG_AsVal_int(obj2, &val3);
16087 if (!SWIG_IsOK(ecode3)) {
16088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16089 }
16090 arg3 = static_cast< int >(val3);
16091 if (obj3) {
16092 ecode4 = SWIG_AsVal_int(obj3, &val4);
16093 if (!SWIG_IsOK(ecode4)) {
16094 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16095 }
16096 arg4 = static_cast< int >(val4);
16097 }
16098 {
16099 PyThreadState* __tstate = wxPyBeginAllowThreads();
16100 result = (arg1)->Scale(arg2,arg3,arg4);
16101 wxPyEndAllowThreads(__tstate);
16102 if (PyErr_Occurred()) SWIG_fail;
16103 }
16104 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16105 return resultobj;
16106 fail:
16107 return NULL;
16108 }
16109
16110
16111 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16112 PyObject *resultobj = 0;
16113 wxImage *arg1 = (wxImage *) 0 ;
16114 int arg2 ;
16115 int arg3 ;
16116 SwigValueWrapper<wxImage > result;
16117 void *argp1 = 0 ;
16118 int res1 = 0 ;
16119 int val2 ;
16120 int ecode2 = 0 ;
16121 int val3 ;
16122 int ecode3 = 0 ;
16123 PyObject * obj0 = 0 ;
16124 PyObject * obj1 = 0 ;
16125 PyObject * obj2 = 0 ;
16126 char * kwnames[] = {
16127 (char *) "self",(char *) "width",(char *) "height", NULL
16128 };
16129
16130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16132 if (!SWIG_IsOK(res1)) {
16133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16134 }
16135 arg1 = reinterpret_cast< wxImage * >(argp1);
16136 ecode2 = SWIG_AsVal_int(obj1, &val2);
16137 if (!SWIG_IsOK(ecode2)) {
16138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16139 }
16140 arg2 = static_cast< int >(val2);
16141 ecode3 = SWIG_AsVal_int(obj2, &val3);
16142 if (!SWIG_IsOK(ecode3)) {
16143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16144 }
16145 arg3 = static_cast< int >(val3);
16146 {
16147 PyThreadState* __tstate = wxPyBeginAllowThreads();
16148 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16149 wxPyEndAllowThreads(__tstate);
16150 if (PyErr_Occurred()) SWIG_fail;
16151 }
16152 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16153 return resultobj;
16154 fail:
16155 return NULL;
16156 }
16157
16158
16159 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16160 PyObject *resultobj = 0;
16161 wxImage *arg1 = (wxImage *) 0 ;
16162 int arg2 ;
16163 int arg3 ;
16164 SwigValueWrapper<wxImage > result;
16165 void *argp1 = 0 ;
16166 int res1 = 0 ;
16167 int val2 ;
16168 int ecode2 = 0 ;
16169 int val3 ;
16170 int ecode3 = 0 ;
16171 PyObject * obj0 = 0 ;
16172 PyObject * obj1 = 0 ;
16173 PyObject * obj2 = 0 ;
16174 char * kwnames[] = {
16175 (char *) "self",(char *) "width",(char *) "height", NULL
16176 };
16177
16178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16180 if (!SWIG_IsOK(res1)) {
16181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16182 }
16183 arg1 = reinterpret_cast< wxImage * >(argp1);
16184 ecode2 = SWIG_AsVal_int(obj1, &val2);
16185 if (!SWIG_IsOK(ecode2)) {
16186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16187 }
16188 arg2 = static_cast< int >(val2);
16189 ecode3 = SWIG_AsVal_int(obj2, &val3);
16190 if (!SWIG_IsOK(ecode3)) {
16191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16192 }
16193 arg3 = static_cast< int >(val3);
16194 {
16195 PyThreadState* __tstate = wxPyBeginAllowThreads();
16196 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16197 wxPyEndAllowThreads(__tstate);
16198 if (PyErr_Occurred()) SWIG_fail;
16199 }
16200 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16201 return resultobj;
16202 fail:
16203 return NULL;
16204 }
16205
16206
16207 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16208 PyObject *resultobj = 0;
16209 wxImage *arg1 = (wxImage *) 0 ;
16210 int arg2 ;
16211 SwigValueWrapper<wxImage > result;
16212 void *argp1 = 0 ;
16213 int res1 = 0 ;
16214 int val2 ;
16215 int ecode2 = 0 ;
16216 PyObject * obj0 = 0 ;
16217 PyObject * obj1 = 0 ;
16218 char * kwnames[] = {
16219 (char *) "self",(char *) "radius", NULL
16220 };
16221
16222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16224 if (!SWIG_IsOK(res1)) {
16225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16226 }
16227 arg1 = reinterpret_cast< wxImage * >(argp1);
16228 ecode2 = SWIG_AsVal_int(obj1, &val2);
16229 if (!SWIG_IsOK(ecode2)) {
16230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16231 }
16232 arg2 = static_cast< int >(val2);
16233 {
16234 PyThreadState* __tstate = wxPyBeginAllowThreads();
16235 result = (arg1)->Blur(arg2);
16236 wxPyEndAllowThreads(__tstate);
16237 if (PyErr_Occurred()) SWIG_fail;
16238 }
16239 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16240 return resultobj;
16241 fail:
16242 return NULL;
16243 }
16244
16245
16246 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16247 PyObject *resultobj = 0;
16248 wxImage *arg1 = (wxImage *) 0 ;
16249 int arg2 ;
16250 SwigValueWrapper<wxImage > result;
16251 void *argp1 = 0 ;
16252 int res1 = 0 ;
16253 int val2 ;
16254 int ecode2 = 0 ;
16255 PyObject * obj0 = 0 ;
16256 PyObject * obj1 = 0 ;
16257 char * kwnames[] = {
16258 (char *) "self",(char *) "radius", NULL
16259 };
16260
16261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16263 if (!SWIG_IsOK(res1)) {
16264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16265 }
16266 arg1 = reinterpret_cast< wxImage * >(argp1);
16267 ecode2 = SWIG_AsVal_int(obj1, &val2);
16268 if (!SWIG_IsOK(ecode2)) {
16269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16270 }
16271 arg2 = static_cast< int >(val2);
16272 {
16273 PyThreadState* __tstate = wxPyBeginAllowThreads();
16274 result = (arg1)->BlurHorizontal(arg2);
16275 wxPyEndAllowThreads(__tstate);
16276 if (PyErr_Occurred()) SWIG_fail;
16277 }
16278 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16279 return resultobj;
16280 fail:
16281 return NULL;
16282 }
16283
16284
16285 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16286 PyObject *resultobj = 0;
16287 wxImage *arg1 = (wxImage *) 0 ;
16288 int arg2 ;
16289 SwigValueWrapper<wxImage > result;
16290 void *argp1 = 0 ;
16291 int res1 = 0 ;
16292 int val2 ;
16293 int ecode2 = 0 ;
16294 PyObject * obj0 = 0 ;
16295 PyObject * obj1 = 0 ;
16296 char * kwnames[] = {
16297 (char *) "self",(char *) "radius", NULL
16298 };
16299
16300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16302 if (!SWIG_IsOK(res1)) {
16303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16304 }
16305 arg1 = reinterpret_cast< wxImage * >(argp1);
16306 ecode2 = SWIG_AsVal_int(obj1, &val2);
16307 if (!SWIG_IsOK(ecode2)) {
16308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16309 }
16310 arg2 = static_cast< int >(val2);
16311 {
16312 PyThreadState* __tstate = wxPyBeginAllowThreads();
16313 result = (arg1)->BlurVertical(arg2);
16314 wxPyEndAllowThreads(__tstate);
16315 if (PyErr_Occurred()) SWIG_fail;
16316 }
16317 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16318 return resultobj;
16319 fail:
16320 return NULL;
16321 }
16322
16323
16324 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16325 PyObject *resultobj = 0;
16326 wxImage *arg1 = (wxImage *) 0 ;
16327 int arg2 ;
16328 int arg3 ;
16329 SwigValueWrapper<wxImage > result;
16330 void *argp1 = 0 ;
16331 int res1 = 0 ;
16332 int val2 ;
16333 int ecode2 = 0 ;
16334 int val3 ;
16335 int ecode3 = 0 ;
16336 PyObject * obj0 = 0 ;
16337 PyObject * obj1 = 0 ;
16338 PyObject * obj2 = 0 ;
16339 char * kwnames[] = {
16340 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16341 };
16342
16343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16345 if (!SWIG_IsOK(res1)) {
16346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16347 }
16348 arg1 = reinterpret_cast< wxImage * >(argp1);
16349 ecode2 = SWIG_AsVal_int(obj1, &val2);
16350 if (!SWIG_IsOK(ecode2)) {
16351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16352 }
16353 arg2 = static_cast< int >(val2);
16354 ecode3 = SWIG_AsVal_int(obj2, &val3);
16355 if (!SWIG_IsOK(ecode3)) {
16356 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16357 }
16358 arg3 = static_cast< int >(val3);
16359 {
16360 PyThreadState* __tstate = wxPyBeginAllowThreads();
16361 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16362 wxPyEndAllowThreads(__tstate);
16363 if (PyErr_Occurred()) SWIG_fail;
16364 }
16365 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16366 return resultobj;
16367 fail:
16368 return NULL;
16369 }
16370
16371
16372 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16373 PyObject *resultobj = 0;
16374 wxImage *arg1 = (wxImage *) 0 ;
16375 int arg2 ;
16376 int arg3 ;
16377 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16378 wxImage *result = 0 ;
16379 void *argp1 = 0 ;
16380 int res1 = 0 ;
16381 int val2 ;
16382 int ecode2 = 0 ;
16383 int val3 ;
16384 int ecode3 = 0 ;
16385 int val4 ;
16386 int ecode4 = 0 ;
16387 PyObject * obj0 = 0 ;
16388 PyObject * obj1 = 0 ;
16389 PyObject * obj2 = 0 ;
16390 PyObject * obj3 = 0 ;
16391 char * kwnames[] = {
16392 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16393 };
16394
16395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16397 if (!SWIG_IsOK(res1)) {
16398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16399 }
16400 arg1 = reinterpret_cast< wxImage * >(argp1);
16401 ecode2 = SWIG_AsVal_int(obj1, &val2);
16402 if (!SWIG_IsOK(ecode2)) {
16403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16404 }
16405 arg2 = static_cast< int >(val2);
16406 ecode3 = SWIG_AsVal_int(obj2, &val3);
16407 if (!SWIG_IsOK(ecode3)) {
16408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16409 }
16410 arg3 = static_cast< int >(val3);
16411 if (obj3) {
16412 ecode4 = SWIG_AsVal_int(obj3, &val4);
16413 if (!SWIG_IsOK(ecode4)) {
16414 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16415 }
16416 arg4 = static_cast< int >(val4);
16417 }
16418 {
16419 PyThreadState* __tstate = wxPyBeginAllowThreads();
16420 {
16421 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
16422 result = (wxImage *) &_result_ref;
16423 }
16424 wxPyEndAllowThreads(__tstate);
16425 if (PyErr_Occurred()) SWIG_fail;
16426 }
16427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16428 return resultobj;
16429 fail:
16430 return NULL;
16431 }
16432
16433
16434 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16435 PyObject *resultobj = 0;
16436 wxImage *arg1 = (wxImage *) 0 ;
16437 wxSize *arg2 = 0 ;
16438 wxPoint *arg3 = 0 ;
16439 int arg4 = (int) -1 ;
16440 int arg5 = (int) -1 ;
16441 int arg6 = (int) -1 ;
16442 wxImage *result = 0 ;
16443 void *argp1 = 0 ;
16444 int res1 = 0 ;
16445 wxSize temp2 ;
16446 wxPoint temp3 ;
16447 int val4 ;
16448 int ecode4 = 0 ;
16449 int val5 ;
16450 int ecode5 = 0 ;
16451 int val6 ;
16452 int ecode6 = 0 ;
16453 PyObject * obj0 = 0 ;
16454 PyObject * obj1 = 0 ;
16455 PyObject * obj2 = 0 ;
16456 PyObject * obj3 = 0 ;
16457 PyObject * obj4 = 0 ;
16458 PyObject * obj5 = 0 ;
16459 char * kwnames[] = {
16460 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16461 };
16462
16463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16465 if (!SWIG_IsOK(res1)) {
16466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16467 }
16468 arg1 = reinterpret_cast< wxImage * >(argp1);
16469 {
16470 arg2 = &temp2;
16471 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16472 }
16473 {
16474 arg3 = &temp3;
16475 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16476 }
16477 if (obj3) {
16478 ecode4 = SWIG_AsVal_int(obj3, &val4);
16479 if (!SWIG_IsOK(ecode4)) {
16480 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16481 }
16482 arg4 = static_cast< int >(val4);
16483 }
16484 if (obj4) {
16485 ecode5 = SWIG_AsVal_int(obj4, &val5);
16486 if (!SWIG_IsOK(ecode5)) {
16487 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16488 }
16489 arg5 = static_cast< int >(val5);
16490 }
16491 if (obj5) {
16492 ecode6 = SWIG_AsVal_int(obj5, &val6);
16493 if (!SWIG_IsOK(ecode6)) {
16494 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16495 }
16496 arg6 = static_cast< int >(val6);
16497 }
16498 {
16499 PyThreadState* __tstate = wxPyBeginAllowThreads();
16500 {
16501 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16502 result = (wxImage *) &_result_ref;
16503 }
16504 wxPyEndAllowThreads(__tstate);
16505 if (PyErr_Occurred()) SWIG_fail;
16506 }
16507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16508 return resultobj;
16509 fail:
16510 return NULL;
16511 }
16512
16513
16514 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16515 PyObject *resultobj = 0;
16516 wxImage *arg1 = (wxImage *) 0 ;
16517 int arg2 ;
16518 int arg3 ;
16519 byte arg4 ;
16520 byte arg5 ;
16521 byte arg6 ;
16522 void *argp1 = 0 ;
16523 int res1 = 0 ;
16524 int val2 ;
16525 int ecode2 = 0 ;
16526 int val3 ;
16527 int ecode3 = 0 ;
16528 unsigned char val4 ;
16529 int ecode4 = 0 ;
16530 unsigned char val5 ;
16531 int ecode5 = 0 ;
16532 unsigned char val6 ;
16533 int ecode6 = 0 ;
16534 PyObject * obj0 = 0 ;
16535 PyObject * obj1 = 0 ;
16536 PyObject * obj2 = 0 ;
16537 PyObject * obj3 = 0 ;
16538 PyObject * obj4 = 0 ;
16539 PyObject * obj5 = 0 ;
16540 char * kwnames[] = {
16541 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16542 };
16543
16544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16546 if (!SWIG_IsOK(res1)) {
16547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16548 }
16549 arg1 = reinterpret_cast< wxImage * >(argp1);
16550 ecode2 = SWIG_AsVal_int(obj1, &val2);
16551 if (!SWIG_IsOK(ecode2)) {
16552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16553 }
16554 arg2 = static_cast< int >(val2);
16555 ecode3 = SWIG_AsVal_int(obj2, &val3);
16556 if (!SWIG_IsOK(ecode3)) {
16557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16558 }
16559 arg3 = static_cast< int >(val3);
16560 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16561 if (!SWIG_IsOK(ecode4)) {
16562 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16563 }
16564 arg4 = static_cast< byte >(val4);
16565 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16566 if (!SWIG_IsOK(ecode5)) {
16567 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16568 }
16569 arg5 = static_cast< byte >(val5);
16570 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16571 if (!SWIG_IsOK(ecode6)) {
16572 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16573 }
16574 arg6 = static_cast< byte >(val6);
16575 {
16576 PyThreadState* __tstate = wxPyBeginAllowThreads();
16577 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16578 wxPyEndAllowThreads(__tstate);
16579 if (PyErr_Occurred()) SWIG_fail;
16580 }
16581 resultobj = SWIG_Py_Void();
16582 return resultobj;
16583 fail:
16584 return NULL;
16585 }
16586
16587
16588 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16589 PyObject *resultobj = 0;
16590 wxImage *arg1 = (wxImage *) 0 ;
16591 wxRect *arg2 = 0 ;
16592 byte arg3 ;
16593 byte arg4 ;
16594 byte arg5 ;
16595 void *argp1 = 0 ;
16596 int res1 = 0 ;
16597 wxRect temp2 ;
16598 unsigned char val3 ;
16599 int ecode3 = 0 ;
16600 unsigned char val4 ;
16601 int ecode4 = 0 ;
16602 unsigned char val5 ;
16603 int ecode5 = 0 ;
16604 PyObject * obj0 = 0 ;
16605 PyObject * obj1 = 0 ;
16606 PyObject * obj2 = 0 ;
16607 PyObject * obj3 = 0 ;
16608 PyObject * obj4 = 0 ;
16609 char * kwnames[] = {
16610 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16611 };
16612
16613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16615 if (!SWIG_IsOK(res1)) {
16616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16617 }
16618 arg1 = reinterpret_cast< wxImage * >(argp1);
16619 {
16620 arg2 = &temp2;
16621 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16622 }
16623 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16624 if (!SWIG_IsOK(ecode3)) {
16625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16626 }
16627 arg3 = static_cast< byte >(val3);
16628 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16629 if (!SWIG_IsOK(ecode4)) {
16630 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16631 }
16632 arg4 = static_cast< byte >(val4);
16633 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16634 if (!SWIG_IsOK(ecode5)) {
16635 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16636 }
16637 arg5 = static_cast< byte >(val5);
16638 {
16639 PyThreadState* __tstate = wxPyBeginAllowThreads();
16640 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16641 wxPyEndAllowThreads(__tstate);
16642 if (PyErr_Occurred()) SWIG_fail;
16643 }
16644 resultobj = SWIG_Py_Void();
16645 return resultobj;
16646 fail:
16647 return NULL;
16648 }
16649
16650
16651 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16652 PyObject *resultobj = 0;
16653 wxImage *arg1 = (wxImage *) 0 ;
16654 int arg2 ;
16655 int arg3 ;
16656 byte result;
16657 void *argp1 = 0 ;
16658 int res1 = 0 ;
16659 int val2 ;
16660 int ecode2 = 0 ;
16661 int val3 ;
16662 int ecode3 = 0 ;
16663 PyObject * obj0 = 0 ;
16664 PyObject * obj1 = 0 ;
16665 PyObject * obj2 = 0 ;
16666 char * kwnames[] = {
16667 (char *) "self",(char *) "x",(char *) "y", NULL
16668 };
16669
16670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16672 if (!SWIG_IsOK(res1)) {
16673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
16674 }
16675 arg1 = reinterpret_cast< wxImage * >(argp1);
16676 ecode2 = SWIG_AsVal_int(obj1, &val2);
16677 if (!SWIG_IsOK(ecode2)) {
16678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
16679 }
16680 arg2 = static_cast< int >(val2);
16681 ecode3 = SWIG_AsVal_int(obj2, &val3);
16682 if (!SWIG_IsOK(ecode3)) {
16683 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
16684 }
16685 arg3 = static_cast< int >(val3);
16686 {
16687 PyThreadState* __tstate = wxPyBeginAllowThreads();
16688 result = (byte)(arg1)->GetRed(arg2,arg3);
16689 wxPyEndAllowThreads(__tstate);
16690 if (PyErr_Occurred()) SWIG_fail;
16691 }
16692 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16693 return resultobj;
16694 fail:
16695 return NULL;
16696 }
16697
16698
16699 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16700 PyObject *resultobj = 0;
16701 wxImage *arg1 = (wxImage *) 0 ;
16702 int arg2 ;
16703 int arg3 ;
16704 byte result;
16705 void *argp1 = 0 ;
16706 int res1 = 0 ;
16707 int val2 ;
16708 int ecode2 = 0 ;
16709 int val3 ;
16710 int ecode3 = 0 ;
16711 PyObject * obj0 = 0 ;
16712 PyObject * obj1 = 0 ;
16713 PyObject * obj2 = 0 ;
16714 char * kwnames[] = {
16715 (char *) "self",(char *) "x",(char *) "y", NULL
16716 };
16717
16718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16720 if (!SWIG_IsOK(res1)) {
16721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16722 }
16723 arg1 = reinterpret_cast< wxImage * >(argp1);
16724 ecode2 = SWIG_AsVal_int(obj1, &val2);
16725 if (!SWIG_IsOK(ecode2)) {
16726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
16727 }
16728 arg2 = static_cast< int >(val2);
16729 ecode3 = SWIG_AsVal_int(obj2, &val3);
16730 if (!SWIG_IsOK(ecode3)) {
16731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
16732 }
16733 arg3 = static_cast< int >(val3);
16734 {
16735 PyThreadState* __tstate = wxPyBeginAllowThreads();
16736 result = (byte)(arg1)->GetGreen(arg2,arg3);
16737 wxPyEndAllowThreads(__tstate);
16738 if (PyErr_Occurred()) SWIG_fail;
16739 }
16740 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16741 return resultobj;
16742 fail:
16743 return NULL;
16744 }
16745
16746
16747 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16748 PyObject *resultobj = 0;
16749 wxImage *arg1 = (wxImage *) 0 ;
16750 int arg2 ;
16751 int arg3 ;
16752 byte result;
16753 void *argp1 = 0 ;
16754 int res1 = 0 ;
16755 int val2 ;
16756 int ecode2 = 0 ;
16757 int val3 ;
16758 int ecode3 = 0 ;
16759 PyObject * obj0 = 0 ;
16760 PyObject * obj1 = 0 ;
16761 PyObject * obj2 = 0 ;
16762 char * kwnames[] = {
16763 (char *) "self",(char *) "x",(char *) "y", NULL
16764 };
16765
16766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16768 if (!SWIG_IsOK(res1)) {
16769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16770 }
16771 arg1 = reinterpret_cast< wxImage * >(argp1);
16772 ecode2 = SWIG_AsVal_int(obj1, &val2);
16773 if (!SWIG_IsOK(ecode2)) {
16774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16775 }
16776 arg2 = static_cast< int >(val2);
16777 ecode3 = SWIG_AsVal_int(obj2, &val3);
16778 if (!SWIG_IsOK(ecode3)) {
16779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16780 }
16781 arg3 = static_cast< int >(val3);
16782 {
16783 PyThreadState* __tstate = wxPyBeginAllowThreads();
16784 result = (byte)(arg1)->GetBlue(arg2,arg3);
16785 wxPyEndAllowThreads(__tstate);
16786 if (PyErr_Occurred()) SWIG_fail;
16787 }
16788 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16789 return resultobj;
16790 fail:
16791 return NULL;
16792 }
16793
16794
16795 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16796 PyObject *resultobj = 0;
16797 wxImage *arg1 = (wxImage *) 0 ;
16798 int arg2 ;
16799 int arg3 ;
16800 byte arg4 ;
16801 void *argp1 = 0 ;
16802 int res1 = 0 ;
16803 int val2 ;
16804 int ecode2 = 0 ;
16805 int val3 ;
16806 int ecode3 = 0 ;
16807 unsigned char val4 ;
16808 int ecode4 = 0 ;
16809 PyObject * obj0 = 0 ;
16810 PyObject * obj1 = 0 ;
16811 PyObject * obj2 = 0 ;
16812 PyObject * obj3 = 0 ;
16813 char * kwnames[] = {
16814 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16815 };
16816
16817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16819 if (!SWIG_IsOK(res1)) {
16820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16821 }
16822 arg1 = reinterpret_cast< wxImage * >(argp1);
16823 ecode2 = SWIG_AsVal_int(obj1, &val2);
16824 if (!SWIG_IsOK(ecode2)) {
16825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16826 }
16827 arg2 = static_cast< int >(val2);
16828 ecode3 = SWIG_AsVal_int(obj2, &val3);
16829 if (!SWIG_IsOK(ecode3)) {
16830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16831 }
16832 arg3 = static_cast< int >(val3);
16833 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16834 if (!SWIG_IsOK(ecode4)) {
16835 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16836 }
16837 arg4 = static_cast< byte >(val4);
16838 {
16839 PyThreadState* __tstate = wxPyBeginAllowThreads();
16840 (arg1)->SetAlpha(arg2,arg3,arg4);
16841 wxPyEndAllowThreads(__tstate);
16842 if (PyErr_Occurred()) SWIG_fail;
16843 }
16844 resultobj = SWIG_Py_Void();
16845 return resultobj;
16846 fail:
16847 return NULL;
16848 }
16849
16850
16851 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16852 PyObject *resultobj = 0;
16853 wxImage *arg1 = (wxImage *) 0 ;
16854 int arg2 ;
16855 int arg3 ;
16856 byte result;
16857 void *argp1 = 0 ;
16858 int res1 = 0 ;
16859 int val2 ;
16860 int ecode2 = 0 ;
16861 int val3 ;
16862 int ecode3 = 0 ;
16863 PyObject * obj0 = 0 ;
16864 PyObject * obj1 = 0 ;
16865 PyObject * obj2 = 0 ;
16866 char * kwnames[] = {
16867 (char *) "self",(char *) "x",(char *) "y", NULL
16868 };
16869
16870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16872 if (!SWIG_IsOK(res1)) {
16873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16874 }
16875 arg1 = reinterpret_cast< wxImage * >(argp1);
16876 ecode2 = SWIG_AsVal_int(obj1, &val2);
16877 if (!SWIG_IsOK(ecode2)) {
16878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16879 }
16880 arg2 = static_cast< int >(val2);
16881 ecode3 = SWIG_AsVal_int(obj2, &val3);
16882 if (!SWIG_IsOK(ecode3)) {
16883 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16884 }
16885 arg3 = static_cast< int >(val3);
16886 {
16887 PyThreadState* __tstate = wxPyBeginAllowThreads();
16888 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16889 wxPyEndAllowThreads(__tstate);
16890 if (PyErr_Occurred()) SWIG_fail;
16891 }
16892 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16893 return resultobj;
16894 fail:
16895 return NULL;
16896 }
16897
16898
16899 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16900 PyObject *resultobj = 0;
16901 wxImage *arg1 = (wxImage *) 0 ;
16902 bool result;
16903 void *argp1 = 0 ;
16904 int res1 = 0 ;
16905 PyObject *swig_obj[1] ;
16906
16907 if (!args) SWIG_fail;
16908 swig_obj[0] = args;
16909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16910 if (!SWIG_IsOK(res1)) {
16911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16912 }
16913 arg1 = reinterpret_cast< wxImage * >(argp1);
16914 {
16915 PyThreadState* __tstate = wxPyBeginAllowThreads();
16916 result = (bool)(arg1)->HasAlpha();
16917 wxPyEndAllowThreads(__tstate);
16918 if (PyErr_Occurred()) SWIG_fail;
16919 }
16920 {
16921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16922 }
16923 return resultobj;
16924 fail:
16925 return NULL;
16926 }
16927
16928
16929 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16930 PyObject *resultobj = 0;
16931 wxImage *arg1 = (wxImage *) 0 ;
16932 void *argp1 = 0 ;
16933 int res1 = 0 ;
16934 PyObject *swig_obj[1] ;
16935
16936 if (!args) SWIG_fail;
16937 swig_obj[0] = args;
16938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16939 if (!SWIG_IsOK(res1)) {
16940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16941 }
16942 arg1 = reinterpret_cast< wxImage * >(argp1);
16943 {
16944 PyThreadState* __tstate = wxPyBeginAllowThreads();
16945 (arg1)->InitAlpha();
16946 wxPyEndAllowThreads(__tstate);
16947 if (PyErr_Occurred()) SWIG_fail;
16948 }
16949 resultobj = SWIG_Py_Void();
16950 return resultobj;
16951 fail:
16952 return NULL;
16953 }
16954
16955
16956 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16957 PyObject *resultobj = 0;
16958 wxImage *arg1 = (wxImage *) 0 ;
16959 int arg2 ;
16960 int arg3 ;
16961 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
16962 bool result;
16963 void *argp1 = 0 ;
16964 int res1 = 0 ;
16965 int val2 ;
16966 int ecode2 = 0 ;
16967 int val3 ;
16968 int ecode3 = 0 ;
16969 unsigned char val4 ;
16970 int ecode4 = 0 ;
16971 PyObject * obj0 = 0 ;
16972 PyObject * obj1 = 0 ;
16973 PyObject * obj2 = 0 ;
16974 PyObject * obj3 = 0 ;
16975 char * kwnames[] = {
16976 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
16977 };
16978
16979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16981 if (!SWIG_IsOK(res1)) {
16982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
16983 }
16984 arg1 = reinterpret_cast< wxImage * >(argp1);
16985 ecode2 = SWIG_AsVal_int(obj1, &val2);
16986 if (!SWIG_IsOK(ecode2)) {
16987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
16988 }
16989 arg2 = static_cast< int >(val2);
16990 ecode3 = SWIG_AsVal_int(obj2, &val3);
16991 if (!SWIG_IsOK(ecode3)) {
16992 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
16993 }
16994 arg3 = static_cast< int >(val3);
16995 if (obj3) {
16996 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16997 if (!SWIG_IsOK(ecode4)) {
16998 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
16999 }
17000 arg4 = static_cast< byte >(val4);
17001 }
17002 {
17003 PyThreadState* __tstate = wxPyBeginAllowThreads();
17004 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
17005 wxPyEndAllowThreads(__tstate);
17006 if (PyErr_Occurred()) SWIG_fail;
17007 }
17008 {
17009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17010 }
17011 return resultobj;
17012 fail:
17013 return NULL;
17014 }
17015
17016
17017 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17018 PyObject *resultobj = 0;
17019 wxImage *arg1 = (wxImage *) 0 ;
17020 byte *arg2 = (byte *) 0 ;
17021 byte *arg3 = (byte *) 0 ;
17022 byte *arg4 = (byte *) 0 ;
17023 byte arg5 = (byte) 0 ;
17024 byte arg6 = (byte) 0 ;
17025 byte arg7 = (byte) 0 ;
17026 bool result;
17027 void *argp1 = 0 ;
17028 int res1 = 0 ;
17029 byte temp2 ;
17030 int res2 = SWIG_TMPOBJ ;
17031 byte temp3 ;
17032 int res3 = SWIG_TMPOBJ ;
17033 byte temp4 ;
17034 int res4 = SWIG_TMPOBJ ;
17035 unsigned char val5 ;
17036 int ecode5 = 0 ;
17037 unsigned char val6 ;
17038 int ecode6 = 0 ;
17039 unsigned char val7 ;
17040 int ecode7 = 0 ;
17041 PyObject * obj0 = 0 ;
17042 PyObject * obj1 = 0 ;
17043 PyObject * obj2 = 0 ;
17044 PyObject * obj3 = 0 ;
17045 char * kwnames[] = {
17046 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17047 };
17048
17049 arg2 = &temp2;
17050 arg3 = &temp3;
17051 arg4 = &temp4;
17052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17054 if (!SWIG_IsOK(res1)) {
17055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17056 }
17057 arg1 = reinterpret_cast< wxImage * >(argp1);
17058 if (obj1) {
17059 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17060 if (!SWIG_IsOK(ecode5)) {
17061 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17062 }
17063 arg5 = static_cast< byte >(val5);
17064 }
17065 if (obj2) {
17066 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17067 if (!SWIG_IsOK(ecode6)) {
17068 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17069 }
17070 arg6 = static_cast< byte >(val6);
17071 }
17072 if (obj3) {
17073 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17074 if (!SWIG_IsOK(ecode7)) {
17075 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17076 }
17077 arg7 = static_cast< byte >(val7);
17078 }
17079 {
17080 PyThreadState* __tstate = wxPyBeginAllowThreads();
17081 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17082 wxPyEndAllowThreads(__tstate);
17083 if (PyErr_Occurred()) SWIG_fail;
17084 }
17085 {
17086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17087 }
17088 if (SWIG_IsTmpObj(res2)) {
17089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17090 } else {
17091 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17092 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17093 }
17094 if (SWIG_IsTmpObj(res3)) {
17095 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17096 } else {
17097 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17098 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17099 }
17100 if (SWIG_IsTmpObj(res4)) {
17101 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17102 } else {
17103 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17104 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17105 }
17106 return resultobj;
17107 fail:
17108 return NULL;
17109 }
17110
17111
17112 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17113 PyObject *resultobj = 0;
17114 wxImage *arg1 = (wxImage *) 0 ;
17115 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17116 bool result;
17117 void *argp1 = 0 ;
17118 int res1 = 0 ;
17119 unsigned char val2 ;
17120 int ecode2 = 0 ;
17121 PyObject * obj0 = 0 ;
17122 PyObject * obj1 = 0 ;
17123 char * kwnames[] = {
17124 (char *) "self",(char *) "threshold", NULL
17125 };
17126
17127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17129 if (!SWIG_IsOK(res1)) {
17130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17131 }
17132 arg1 = reinterpret_cast< wxImage * >(argp1);
17133 if (obj1) {
17134 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17135 if (!SWIG_IsOK(ecode2)) {
17136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17137 }
17138 arg2 = static_cast< byte >(val2);
17139 }
17140 {
17141 PyThreadState* __tstate = wxPyBeginAllowThreads();
17142 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17143 wxPyEndAllowThreads(__tstate);
17144 if (PyErr_Occurred()) SWIG_fail;
17145 }
17146 {
17147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17148 }
17149 return resultobj;
17150 fail:
17151 return NULL;
17152 }
17153
17154
17155 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17156 PyObject *resultobj = 0;
17157 wxImage *arg1 = (wxImage *) 0 ;
17158 byte arg2 ;
17159 byte arg3 ;
17160 byte arg4 ;
17161 bool result;
17162 void *argp1 = 0 ;
17163 int res1 = 0 ;
17164 unsigned char val2 ;
17165 int ecode2 = 0 ;
17166 unsigned char val3 ;
17167 int ecode3 = 0 ;
17168 unsigned char val4 ;
17169 int ecode4 = 0 ;
17170 PyObject * obj0 = 0 ;
17171 PyObject * obj1 = 0 ;
17172 PyObject * obj2 = 0 ;
17173 PyObject * obj3 = 0 ;
17174 char * kwnames[] = {
17175 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17176 };
17177
17178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17180 if (!SWIG_IsOK(res1)) {
17181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17182 }
17183 arg1 = reinterpret_cast< wxImage * >(argp1);
17184 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17185 if (!SWIG_IsOK(ecode2)) {
17186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17187 }
17188 arg2 = static_cast< byte >(val2);
17189 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17190 if (!SWIG_IsOK(ecode3)) {
17191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17192 }
17193 arg3 = static_cast< byte >(val3);
17194 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17195 if (!SWIG_IsOK(ecode4)) {
17196 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17197 }
17198 arg4 = static_cast< byte >(val4);
17199 {
17200 PyThreadState* __tstate = wxPyBeginAllowThreads();
17201 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17202 wxPyEndAllowThreads(__tstate);
17203 if (PyErr_Occurred()) SWIG_fail;
17204 }
17205 {
17206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17207 }
17208 return resultobj;
17209 fail:
17210 return NULL;
17211 }
17212
17213
17214 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17215 PyObject *resultobj = 0;
17216 wxImage *arg1 = (wxImage *) 0 ;
17217 wxImage *arg2 = 0 ;
17218 byte arg3 ;
17219 byte arg4 ;
17220 byte arg5 ;
17221 bool result;
17222 void *argp1 = 0 ;
17223 int res1 = 0 ;
17224 void *argp2 = 0 ;
17225 int res2 = 0 ;
17226 unsigned char val3 ;
17227 int ecode3 = 0 ;
17228 unsigned char val4 ;
17229 int ecode4 = 0 ;
17230 unsigned char val5 ;
17231 int ecode5 = 0 ;
17232 PyObject * obj0 = 0 ;
17233 PyObject * obj1 = 0 ;
17234 PyObject * obj2 = 0 ;
17235 PyObject * obj3 = 0 ;
17236 PyObject * obj4 = 0 ;
17237 char * kwnames[] = {
17238 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17239 };
17240
17241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17243 if (!SWIG_IsOK(res1)) {
17244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17245 }
17246 arg1 = reinterpret_cast< wxImage * >(argp1);
17247 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17248 if (!SWIG_IsOK(res2)) {
17249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17250 }
17251 if (!argp2) {
17252 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17253 }
17254 arg2 = reinterpret_cast< wxImage * >(argp2);
17255 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17256 if (!SWIG_IsOK(ecode3)) {
17257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17258 }
17259 arg3 = static_cast< byte >(val3);
17260 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17261 if (!SWIG_IsOK(ecode4)) {
17262 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17263 }
17264 arg4 = static_cast< byte >(val4);
17265 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17266 if (!SWIG_IsOK(ecode5)) {
17267 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17268 }
17269 arg5 = static_cast< byte >(val5);
17270 {
17271 PyThreadState* __tstate = wxPyBeginAllowThreads();
17272 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17273 wxPyEndAllowThreads(__tstate);
17274 if (PyErr_Occurred()) SWIG_fail;
17275 }
17276 {
17277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17278 }
17279 return resultobj;
17280 fail:
17281 return NULL;
17282 }
17283
17284
17285 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17286 PyObject *resultobj = 0;
17287 wxString *arg1 = 0 ;
17288 bool result;
17289 bool temp1 = false ;
17290 PyObject * obj0 = 0 ;
17291 char * kwnames[] = {
17292 (char *) "filename", NULL
17293 };
17294
17295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17296 {
17297 arg1 = wxString_in_helper(obj0);
17298 if (arg1 == NULL) SWIG_fail;
17299 temp1 = true;
17300 }
17301 {
17302 PyThreadState* __tstate = wxPyBeginAllowThreads();
17303 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17304 wxPyEndAllowThreads(__tstate);
17305 if (PyErr_Occurred()) SWIG_fail;
17306 }
17307 {
17308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17309 }
17310 {
17311 if (temp1)
17312 delete arg1;
17313 }
17314 return resultobj;
17315 fail:
17316 {
17317 if (temp1)
17318 delete arg1;
17319 }
17320 return NULL;
17321 }
17322
17323
17324 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17325 PyObject *resultobj = 0;
17326 wxString *arg1 = 0 ;
17327 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17328 int result;
17329 bool temp1 = false ;
17330 long val2 ;
17331 int ecode2 = 0 ;
17332 PyObject * obj0 = 0 ;
17333 PyObject * obj1 = 0 ;
17334 char * kwnames[] = {
17335 (char *) "filename",(char *) "type", NULL
17336 };
17337
17338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17339 {
17340 arg1 = wxString_in_helper(obj0);
17341 if (arg1 == NULL) SWIG_fail;
17342 temp1 = true;
17343 }
17344 if (obj1) {
17345 ecode2 = SWIG_AsVal_long(obj1, &val2);
17346 if (!SWIG_IsOK(ecode2)) {
17347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17348 }
17349 arg2 = static_cast< long >(val2);
17350 }
17351 {
17352 PyThreadState* __tstate = wxPyBeginAllowThreads();
17353 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17354 wxPyEndAllowThreads(__tstate);
17355 if (PyErr_Occurred()) SWIG_fail;
17356 }
17357 resultobj = SWIG_From_int(static_cast< int >(result));
17358 {
17359 if (temp1)
17360 delete arg1;
17361 }
17362 return resultobj;
17363 fail:
17364 {
17365 if (temp1)
17366 delete arg1;
17367 }
17368 return NULL;
17369 }
17370
17371
17372 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17373 PyObject *resultobj = 0;
17374 wxImage *arg1 = (wxImage *) 0 ;
17375 wxString *arg2 = 0 ;
17376 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17377 int arg4 = (int) -1 ;
17378 bool result;
17379 void *argp1 = 0 ;
17380 int res1 = 0 ;
17381 bool temp2 = false ;
17382 long val3 ;
17383 int ecode3 = 0 ;
17384 int val4 ;
17385 int ecode4 = 0 ;
17386 PyObject * obj0 = 0 ;
17387 PyObject * obj1 = 0 ;
17388 PyObject * obj2 = 0 ;
17389 PyObject * obj3 = 0 ;
17390 char * kwnames[] = {
17391 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17392 };
17393
17394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17396 if (!SWIG_IsOK(res1)) {
17397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17398 }
17399 arg1 = reinterpret_cast< wxImage * >(argp1);
17400 {
17401 arg2 = wxString_in_helper(obj1);
17402 if (arg2 == NULL) SWIG_fail;
17403 temp2 = true;
17404 }
17405 if (obj2) {
17406 ecode3 = SWIG_AsVal_long(obj2, &val3);
17407 if (!SWIG_IsOK(ecode3)) {
17408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17409 }
17410 arg3 = static_cast< long >(val3);
17411 }
17412 if (obj3) {
17413 ecode4 = SWIG_AsVal_int(obj3, &val4);
17414 if (!SWIG_IsOK(ecode4)) {
17415 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17416 }
17417 arg4 = static_cast< int >(val4);
17418 }
17419 {
17420 PyThreadState* __tstate = wxPyBeginAllowThreads();
17421 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17422 wxPyEndAllowThreads(__tstate);
17423 if (PyErr_Occurred()) SWIG_fail;
17424 }
17425 {
17426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17427 }
17428 {
17429 if (temp2)
17430 delete arg2;
17431 }
17432 return resultobj;
17433 fail:
17434 {
17435 if (temp2)
17436 delete arg2;
17437 }
17438 return NULL;
17439 }
17440
17441
17442 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17443 PyObject *resultobj = 0;
17444 wxImage *arg1 = (wxImage *) 0 ;
17445 wxString *arg2 = 0 ;
17446 wxString *arg3 = 0 ;
17447 int arg4 = (int) -1 ;
17448 bool result;
17449 void *argp1 = 0 ;
17450 int res1 = 0 ;
17451 bool temp2 = false ;
17452 bool temp3 = false ;
17453 int val4 ;
17454 int ecode4 = 0 ;
17455 PyObject * obj0 = 0 ;
17456 PyObject * obj1 = 0 ;
17457 PyObject * obj2 = 0 ;
17458 PyObject * obj3 = 0 ;
17459 char * kwnames[] = {
17460 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17461 };
17462
17463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17465 if (!SWIG_IsOK(res1)) {
17466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17467 }
17468 arg1 = reinterpret_cast< wxImage * >(argp1);
17469 {
17470 arg2 = wxString_in_helper(obj1);
17471 if (arg2 == NULL) SWIG_fail;
17472 temp2 = true;
17473 }
17474 {
17475 arg3 = wxString_in_helper(obj2);
17476 if (arg3 == NULL) SWIG_fail;
17477 temp3 = true;
17478 }
17479 if (obj3) {
17480 ecode4 = SWIG_AsVal_int(obj3, &val4);
17481 if (!SWIG_IsOK(ecode4)) {
17482 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17483 }
17484 arg4 = static_cast< int >(val4);
17485 }
17486 {
17487 PyThreadState* __tstate = wxPyBeginAllowThreads();
17488 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17489 wxPyEndAllowThreads(__tstate);
17490 if (PyErr_Occurred()) SWIG_fail;
17491 }
17492 {
17493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17494 }
17495 {
17496 if (temp2)
17497 delete arg2;
17498 }
17499 {
17500 if (temp3)
17501 delete arg3;
17502 }
17503 return resultobj;
17504 fail:
17505 {
17506 if (temp2)
17507 delete arg2;
17508 }
17509 {
17510 if (temp3)
17511 delete arg3;
17512 }
17513 return NULL;
17514 }
17515
17516
17517 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17518 PyObject *resultobj = 0;
17519 wxImage *arg1 = (wxImage *) 0 ;
17520 wxString *arg2 = 0 ;
17521 int arg3 ;
17522 bool result;
17523 void *argp1 = 0 ;
17524 int res1 = 0 ;
17525 bool temp2 = false ;
17526 int val3 ;
17527 int ecode3 = 0 ;
17528 PyObject * obj0 = 0 ;
17529 PyObject * obj1 = 0 ;
17530 PyObject * obj2 = 0 ;
17531 char * kwnames[] = {
17532 (char *) "self",(char *) "name",(char *) "type", NULL
17533 };
17534
17535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17537 if (!SWIG_IsOK(res1)) {
17538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17539 }
17540 arg1 = reinterpret_cast< wxImage * >(argp1);
17541 {
17542 arg2 = wxString_in_helper(obj1);
17543 if (arg2 == NULL) SWIG_fail;
17544 temp2 = true;
17545 }
17546 ecode3 = SWIG_AsVal_int(obj2, &val3);
17547 if (!SWIG_IsOK(ecode3)) {
17548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17549 }
17550 arg3 = static_cast< int >(val3);
17551 {
17552 PyThreadState* __tstate = wxPyBeginAllowThreads();
17553 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17554 wxPyEndAllowThreads(__tstate);
17555 if (PyErr_Occurred()) SWIG_fail;
17556 }
17557 {
17558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17559 }
17560 {
17561 if (temp2)
17562 delete arg2;
17563 }
17564 return resultobj;
17565 fail:
17566 {
17567 if (temp2)
17568 delete arg2;
17569 }
17570 return NULL;
17571 }
17572
17573
17574 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17575 PyObject *resultobj = 0;
17576 wxImage *arg1 = (wxImage *) 0 ;
17577 wxString *arg2 = 0 ;
17578 wxString *arg3 = 0 ;
17579 bool result;
17580 void *argp1 = 0 ;
17581 int res1 = 0 ;
17582 bool temp2 = false ;
17583 bool temp3 = false ;
17584 PyObject * obj0 = 0 ;
17585 PyObject * obj1 = 0 ;
17586 PyObject * obj2 = 0 ;
17587 char * kwnames[] = {
17588 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17589 };
17590
17591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17593 if (!SWIG_IsOK(res1)) {
17594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17595 }
17596 arg1 = reinterpret_cast< wxImage * >(argp1);
17597 {
17598 arg2 = wxString_in_helper(obj1);
17599 if (arg2 == NULL) SWIG_fail;
17600 temp2 = true;
17601 }
17602 {
17603 arg3 = wxString_in_helper(obj2);
17604 if (arg3 == NULL) SWIG_fail;
17605 temp3 = true;
17606 }
17607 {
17608 PyThreadState* __tstate = wxPyBeginAllowThreads();
17609 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17610 wxPyEndAllowThreads(__tstate);
17611 if (PyErr_Occurred()) SWIG_fail;
17612 }
17613 {
17614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17615 }
17616 {
17617 if (temp2)
17618 delete arg2;
17619 }
17620 {
17621 if (temp3)
17622 delete arg3;
17623 }
17624 return resultobj;
17625 fail:
17626 {
17627 if (temp2)
17628 delete arg2;
17629 }
17630 {
17631 if (temp3)
17632 delete arg3;
17633 }
17634 return NULL;
17635 }
17636
17637
17638 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17639 PyObject *resultobj = 0;
17640 wxInputStream *arg1 = 0 ;
17641 bool result;
17642 wxPyInputStream *temp1 ;
17643 bool created1 ;
17644 PyObject * obj0 = 0 ;
17645 char * kwnames[] = {
17646 (char *) "stream", NULL
17647 };
17648
17649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17650 {
17651 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17652 arg1 = temp1->m_wxis;
17653 created1 = false;
17654 } else {
17655 PyErr_Clear(); // clear the failure of the wxPyConvert above
17656 arg1 = wxPyCBInputStream_create(obj0, false);
17657 if (arg1 == NULL) {
17658 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17659 SWIG_fail;
17660 }
17661 created1 = true;
17662 }
17663 }
17664 {
17665 PyThreadState* __tstate = wxPyBeginAllowThreads();
17666 result = (bool)wxImage::CanRead(*arg1);
17667 wxPyEndAllowThreads(__tstate);
17668 if (PyErr_Occurred()) SWIG_fail;
17669 }
17670 {
17671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17672 }
17673 {
17674 if (created1) delete arg1;
17675 }
17676 return resultobj;
17677 fail:
17678 {
17679 if (created1) delete arg1;
17680 }
17681 return NULL;
17682 }
17683
17684
17685 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17686 PyObject *resultobj = 0;
17687 wxImage *arg1 = (wxImage *) 0 ;
17688 wxInputStream *arg2 = 0 ;
17689 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17690 int arg4 = (int) -1 ;
17691 bool result;
17692 void *argp1 = 0 ;
17693 int res1 = 0 ;
17694 wxPyInputStream *temp2 ;
17695 bool created2 ;
17696 long val3 ;
17697 int ecode3 = 0 ;
17698 int val4 ;
17699 int ecode4 = 0 ;
17700 PyObject * obj0 = 0 ;
17701 PyObject * obj1 = 0 ;
17702 PyObject * obj2 = 0 ;
17703 PyObject * obj3 = 0 ;
17704 char * kwnames[] = {
17705 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17706 };
17707
17708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17710 if (!SWIG_IsOK(res1)) {
17711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17712 }
17713 arg1 = reinterpret_cast< wxImage * >(argp1);
17714 {
17715 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17716 arg2 = temp2->m_wxis;
17717 created2 = false;
17718 } else {
17719 PyErr_Clear(); // clear the failure of the wxPyConvert above
17720 arg2 = wxPyCBInputStream_create(obj1, false);
17721 if (arg2 == NULL) {
17722 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17723 SWIG_fail;
17724 }
17725 created2 = true;
17726 }
17727 }
17728 if (obj2) {
17729 ecode3 = SWIG_AsVal_long(obj2, &val3);
17730 if (!SWIG_IsOK(ecode3)) {
17731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17732 }
17733 arg3 = static_cast< long >(val3);
17734 }
17735 if (obj3) {
17736 ecode4 = SWIG_AsVal_int(obj3, &val4);
17737 if (!SWIG_IsOK(ecode4)) {
17738 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17739 }
17740 arg4 = static_cast< int >(val4);
17741 }
17742 {
17743 PyThreadState* __tstate = wxPyBeginAllowThreads();
17744 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17745 wxPyEndAllowThreads(__tstate);
17746 if (PyErr_Occurred()) SWIG_fail;
17747 }
17748 {
17749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17750 }
17751 {
17752 if (created2) delete arg2;
17753 }
17754 return resultobj;
17755 fail:
17756 {
17757 if (created2) delete arg2;
17758 }
17759 return NULL;
17760 }
17761
17762
17763 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17764 PyObject *resultobj = 0;
17765 wxImage *arg1 = (wxImage *) 0 ;
17766 wxInputStream *arg2 = 0 ;
17767 wxString *arg3 = 0 ;
17768 int arg4 = (int) -1 ;
17769 bool result;
17770 void *argp1 = 0 ;
17771 int res1 = 0 ;
17772 wxPyInputStream *temp2 ;
17773 bool created2 ;
17774 bool temp3 = false ;
17775 int val4 ;
17776 int ecode4 = 0 ;
17777 PyObject * obj0 = 0 ;
17778 PyObject * obj1 = 0 ;
17779 PyObject * obj2 = 0 ;
17780 PyObject * obj3 = 0 ;
17781 char * kwnames[] = {
17782 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17783 };
17784
17785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17787 if (!SWIG_IsOK(res1)) {
17788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17789 }
17790 arg1 = reinterpret_cast< wxImage * >(argp1);
17791 {
17792 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17793 arg2 = temp2->m_wxis;
17794 created2 = false;
17795 } else {
17796 PyErr_Clear(); // clear the failure of the wxPyConvert above
17797 arg2 = wxPyCBInputStream_create(obj1, false);
17798 if (arg2 == NULL) {
17799 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17800 SWIG_fail;
17801 }
17802 created2 = true;
17803 }
17804 }
17805 {
17806 arg3 = wxString_in_helper(obj2);
17807 if (arg3 == NULL) SWIG_fail;
17808 temp3 = true;
17809 }
17810 if (obj3) {
17811 ecode4 = SWIG_AsVal_int(obj3, &val4);
17812 if (!SWIG_IsOK(ecode4)) {
17813 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17814 }
17815 arg4 = static_cast< int >(val4);
17816 }
17817 {
17818 PyThreadState* __tstate = wxPyBeginAllowThreads();
17819 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17820 wxPyEndAllowThreads(__tstate);
17821 if (PyErr_Occurred()) SWIG_fail;
17822 }
17823 {
17824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17825 }
17826 {
17827 if (created2) delete arg2;
17828 }
17829 {
17830 if (temp3)
17831 delete arg3;
17832 }
17833 return resultobj;
17834 fail:
17835 {
17836 if (created2) delete arg2;
17837 }
17838 {
17839 if (temp3)
17840 delete arg3;
17841 }
17842 return NULL;
17843 }
17844
17845
17846 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17847 PyObject *resultobj = 0;
17848 wxImage *arg1 = (wxImage *) 0 ;
17849 bool result;
17850 void *argp1 = 0 ;
17851 int res1 = 0 ;
17852 PyObject *swig_obj[1] ;
17853
17854 if (!args) SWIG_fail;
17855 swig_obj[0] = args;
17856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17857 if (!SWIG_IsOK(res1)) {
17858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
17859 }
17860 arg1 = reinterpret_cast< wxImage * >(argp1);
17861 {
17862 PyThreadState* __tstate = wxPyBeginAllowThreads();
17863 result = (bool)(arg1)->IsOk();
17864 wxPyEndAllowThreads(__tstate);
17865 if (PyErr_Occurred()) SWIG_fail;
17866 }
17867 {
17868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17869 }
17870 return resultobj;
17871 fail:
17872 return NULL;
17873 }
17874
17875
17876 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17877 PyObject *resultobj = 0;
17878 wxImage *arg1 = (wxImage *) 0 ;
17879 int result;
17880 void *argp1 = 0 ;
17881 int res1 = 0 ;
17882 PyObject *swig_obj[1] ;
17883
17884 if (!args) SWIG_fail;
17885 swig_obj[0] = args;
17886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17887 if (!SWIG_IsOK(res1)) {
17888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17889 }
17890 arg1 = reinterpret_cast< wxImage * >(argp1);
17891 {
17892 PyThreadState* __tstate = wxPyBeginAllowThreads();
17893 result = (int)(arg1)->GetWidth();
17894 wxPyEndAllowThreads(__tstate);
17895 if (PyErr_Occurred()) SWIG_fail;
17896 }
17897 resultobj = SWIG_From_int(static_cast< int >(result));
17898 return resultobj;
17899 fail:
17900 return NULL;
17901 }
17902
17903
17904 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17905 PyObject *resultobj = 0;
17906 wxImage *arg1 = (wxImage *) 0 ;
17907 int result;
17908 void *argp1 = 0 ;
17909 int res1 = 0 ;
17910 PyObject *swig_obj[1] ;
17911
17912 if (!args) SWIG_fail;
17913 swig_obj[0] = args;
17914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17915 if (!SWIG_IsOK(res1)) {
17916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17917 }
17918 arg1 = reinterpret_cast< wxImage * >(argp1);
17919 {
17920 PyThreadState* __tstate = wxPyBeginAllowThreads();
17921 result = (int)(arg1)->GetHeight();
17922 wxPyEndAllowThreads(__tstate);
17923 if (PyErr_Occurred()) SWIG_fail;
17924 }
17925 resultobj = SWIG_From_int(static_cast< int >(result));
17926 return resultobj;
17927 fail:
17928 return NULL;
17929 }
17930
17931
17932 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17933 PyObject *resultobj = 0;
17934 wxImage *arg1 = (wxImage *) 0 ;
17935 wxSize result;
17936 void *argp1 = 0 ;
17937 int res1 = 0 ;
17938 PyObject *swig_obj[1] ;
17939
17940 if (!args) SWIG_fail;
17941 swig_obj[0] = args;
17942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17943 if (!SWIG_IsOK(res1)) {
17944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
17945 }
17946 arg1 = reinterpret_cast< wxImage * >(argp1);
17947 {
17948 PyThreadState* __tstate = wxPyBeginAllowThreads();
17949 result = wxImage_GetSize(arg1);
17950 wxPyEndAllowThreads(__tstate);
17951 if (PyErr_Occurred()) SWIG_fail;
17952 }
17953 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
17954 return resultobj;
17955 fail:
17956 return NULL;
17957 }
17958
17959
17960 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17961 PyObject *resultobj = 0;
17962 wxImage *arg1 = (wxImage *) 0 ;
17963 wxRect *arg2 = 0 ;
17964 SwigValueWrapper<wxImage > result;
17965 void *argp1 = 0 ;
17966 int res1 = 0 ;
17967 wxRect temp2 ;
17968 PyObject * obj0 = 0 ;
17969 PyObject * obj1 = 0 ;
17970 char * kwnames[] = {
17971 (char *) "self",(char *) "rect", NULL
17972 };
17973
17974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
17975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17976 if (!SWIG_IsOK(res1)) {
17977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
17978 }
17979 arg1 = reinterpret_cast< wxImage * >(argp1);
17980 {
17981 arg2 = &temp2;
17982 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17983 }
17984 {
17985 PyThreadState* __tstate = wxPyBeginAllowThreads();
17986 result = (arg1)->GetSubImage((wxRect const &)*arg2);
17987 wxPyEndAllowThreads(__tstate);
17988 if (PyErr_Occurred()) SWIG_fail;
17989 }
17990 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
17991 return resultobj;
17992 fail:
17993 return NULL;
17994 }
17995
17996
17997 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17998 PyObject *resultobj = 0;
17999 wxImage *arg1 = (wxImage *) 0 ;
18000 wxSize *arg2 = 0 ;
18001 wxPoint *arg3 = 0 ;
18002 int arg4 = (int) -1 ;
18003 int arg5 = (int) -1 ;
18004 int arg6 = (int) -1 ;
18005 SwigValueWrapper<wxImage > result;
18006 void *argp1 = 0 ;
18007 int res1 = 0 ;
18008 wxSize temp2 ;
18009 wxPoint temp3 ;
18010 int val4 ;
18011 int ecode4 = 0 ;
18012 int val5 ;
18013 int ecode5 = 0 ;
18014 int val6 ;
18015 int ecode6 = 0 ;
18016 PyObject * obj0 = 0 ;
18017 PyObject * obj1 = 0 ;
18018 PyObject * obj2 = 0 ;
18019 PyObject * obj3 = 0 ;
18020 PyObject * obj4 = 0 ;
18021 PyObject * obj5 = 0 ;
18022 char * kwnames[] = {
18023 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18024 };
18025
18026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18028 if (!SWIG_IsOK(res1)) {
18029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18030 }
18031 arg1 = reinterpret_cast< wxImage * >(argp1);
18032 {
18033 arg2 = &temp2;
18034 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18035 }
18036 {
18037 arg3 = &temp3;
18038 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18039 }
18040 if (obj3) {
18041 ecode4 = SWIG_AsVal_int(obj3, &val4);
18042 if (!SWIG_IsOK(ecode4)) {
18043 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18044 }
18045 arg4 = static_cast< int >(val4);
18046 }
18047 if (obj4) {
18048 ecode5 = SWIG_AsVal_int(obj4, &val5);
18049 if (!SWIG_IsOK(ecode5)) {
18050 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18051 }
18052 arg5 = static_cast< int >(val5);
18053 }
18054 if (obj5) {
18055 ecode6 = SWIG_AsVal_int(obj5, &val6);
18056 if (!SWIG_IsOK(ecode6)) {
18057 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18058 }
18059 arg6 = static_cast< int >(val6);
18060 }
18061 {
18062 PyThreadState* __tstate = wxPyBeginAllowThreads();
18063 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18064 wxPyEndAllowThreads(__tstate);
18065 if (PyErr_Occurred()) SWIG_fail;
18066 }
18067 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18068 return resultobj;
18069 fail:
18070 return NULL;
18071 }
18072
18073
18074 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18075 PyObject *resultobj = 0;
18076 wxImage *arg1 = (wxImage *) 0 ;
18077 SwigValueWrapper<wxImage > result;
18078 void *argp1 = 0 ;
18079 int res1 = 0 ;
18080 PyObject *swig_obj[1] ;
18081
18082 if (!args) SWIG_fail;
18083 swig_obj[0] = args;
18084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18085 if (!SWIG_IsOK(res1)) {
18086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18087 }
18088 arg1 = reinterpret_cast< wxImage * >(argp1);
18089 {
18090 PyThreadState* __tstate = wxPyBeginAllowThreads();
18091 result = (arg1)->Copy();
18092 wxPyEndAllowThreads(__tstate);
18093 if (PyErr_Occurred()) SWIG_fail;
18094 }
18095 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18096 return resultobj;
18097 fail:
18098 return NULL;
18099 }
18100
18101
18102 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18103 PyObject *resultobj = 0;
18104 wxImage *arg1 = (wxImage *) 0 ;
18105 wxImage *arg2 = 0 ;
18106 int arg3 ;
18107 int arg4 ;
18108 void *argp1 = 0 ;
18109 int res1 = 0 ;
18110 void *argp2 = 0 ;
18111 int res2 = 0 ;
18112 int val3 ;
18113 int ecode3 = 0 ;
18114 int val4 ;
18115 int ecode4 = 0 ;
18116 PyObject * obj0 = 0 ;
18117 PyObject * obj1 = 0 ;
18118 PyObject * obj2 = 0 ;
18119 PyObject * obj3 = 0 ;
18120 char * kwnames[] = {
18121 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18122 };
18123
18124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18126 if (!SWIG_IsOK(res1)) {
18127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18128 }
18129 arg1 = reinterpret_cast< wxImage * >(argp1);
18130 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18131 if (!SWIG_IsOK(res2)) {
18132 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18133 }
18134 if (!argp2) {
18135 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18136 }
18137 arg2 = reinterpret_cast< wxImage * >(argp2);
18138 ecode3 = SWIG_AsVal_int(obj2, &val3);
18139 if (!SWIG_IsOK(ecode3)) {
18140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18141 }
18142 arg3 = static_cast< int >(val3);
18143 ecode4 = SWIG_AsVal_int(obj3, &val4);
18144 if (!SWIG_IsOK(ecode4)) {
18145 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18146 }
18147 arg4 = static_cast< int >(val4);
18148 {
18149 PyThreadState* __tstate = wxPyBeginAllowThreads();
18150 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18151 wxPyEndAllowThreads(__tstate);
18152 if (PyErr_Occurred()) SWIG_fail;
18153 }
18154 resultobj = SWIG_Py_Void();
18155 return resultobj;
18156 fail:
18157 return NULL;
18158 }
18159
18160
18161 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18162 PyObject *resultobj = 0;
18163 wxImage *arg1 = (wxImage *) 0 ;
18164 PyObject *result = 0 ;
18165 void *argp1 = 0 ;
18166 int res1 = 0 ;
18167 PyObject *swig_obj[1] ;
18168
18169 if (!args) SWIG_fail;
18170 swig_obj[0] = args;
18171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18172 if (!SWIG_IsOK(res1)) {
18173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18174 }
18175 arg1 = reinterpret_cast< wxImage * >(argp1);
18176 {
18177 PyThreadState* __tstate = wxPyBeginAllowThreads();
18178 result = (PyObject *)wxImage_GetData(arg1);
18179 wxPyEndAllowThreads(__tstate);
18180 if (PyErr_Occurred()) SWIG_fail;
18181 }
18182 resultobj = result;
18183 return resultobj;
18184 fail:
18185 return NULL;
18186 }
18187
18188
18189 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18190 PyObject *resultobj = 0;
18191 wxImage *arg1 = (wxImage *) 0 ;
18192 buffer arg2 ;
18193 int arg3 ;
18194 void *argp1 = 0 ;
18195 int res1 = 0 ;
18196 Py_ssize_t temp2 ;
18197 PyObject * obj0 = 0 ;
18198 PyObject * obj1 = 0 ;
18199 char * kwnames[] = {
18200 (char *) "self",(char *) "data", NULL
18201 };
18202
18203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18205 if (!SWIG_IsOK(res1)) {
18206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18207 }
18208 arg1 = reinterpret_cast< wxImage * >(argp1);
18209 {
18210 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18211 arg3 = (int)temp2;
18212 }
18213 {
18214 PyThreadState* __tstate = wxPyBeginAllowThreads();
18215 wxImage_SetData(arg1,arg2,arg3);
18216 wxPyEndAllowThreads(__tstate);
18217 if (PyErr_Occurred()) SWIG_fail;
18218 }
18219 resultobj = SWIG_Py_Void();
18220 return resultobj;
18221 fail:
18222 return NULL;
18223 }
18224
18225
18226 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18227 PyObject *resultobj = 0;
18228 wxImage *arg1 = (wxImage *) 0 ;
18229 PyObject *result = 0 ;
18230 void *argp1 = 0 ;
18231 int res1 = 0 ;
18232 PyObject *swig_obj[1] ;
18233
18234 if (!args) SWIG_fail;
18235 swig_obj[0] = args;
18236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18237 if (!SWIG_IsOK(res1)) {
18238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18239 }
18240 arg1 = reinterpret_cast< wxImage * >(argp1);
18241 {
18242 PyThreadState* __tstate = wxPyBeginAllowThreads();
18243 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18244 wxPyEndAllowThreads(__tstate);
18245 if (PyErr_Occurred()) SWIG_fail;
18246 }
18247 resultobj = result;
18248 return resultobj;
18249 fail:
18250 return NULL;
18251 }
18252
18253
18254 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18255 PyObject *resultobj = 0;
18256 wxImage *arg1 = (wxImage *) 0 ;
18257 buffer arg2 ;
18258 int arg3 ;
18259 void *argp1 = 0 ;
18260 int res1 = 0 ;
18261 Py_ssize_t temp2 ;
18262 PyObject * obj0 = 0 ;
18263 PyObject * obj1 = 0 ;
18264 char * kwnames[] = {
18265 (char *) "self",(char *) "data", NULL
18266 };
18267
18268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18270 if (!SWIG_IsOK(res1)) {
18271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18272 }
18273 arg1 = reinterpret_cast< wxImage * >(argp1);
18274 {
18275 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18276 arg3 = (int)temp2;
18277 }
18278 {
18279 PyThreadState* __tstate = wxPyBeginAllowThreads();
18280 wxImage_SetDataBuffer(arg1,arg2,arg3);
18281 wxPyEndAllowThreads(__tstate);
18282 if (PyErr_Occurred()) SWIG_fail;
18283 }
18284 resultobj = SWIG_Py_Void();
18285 return resultobj;
18286 fail:
18287 return NULL;
18288 }
18289
18290
18291 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18292 PyObject *resultobj = 0;
18293 wxImage *arg1 = (wxImage *) 0 ;
18294 PyObject *result = 0 ;
18295 void *argp1 = 0 ;
18296 int res1 = 0 ;
18297 PyObject *swig_obj[1] ;
18298
18299 if (!args) SWIG_fail;
18300 swig_obj[0] = args;
18301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18302 if (!SWIG_IsOK(res1)) {
18303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18304 }
18305 arg1 = reinterpret_cast< wxImage * >(argp1);
18306 {
18307 PyThreadState* __tstate = wxPyBeginAllowThreads();
18308 result = (PyObject *)wxImage_GetAlphaData(arg1);
18309 wxPyEndAllowThreads(__tstate);
18310 if (PyErr_Occurred()) SWIG_fail;
18311 }
18312 resultobj = result;
18313 return resultobj;
18314 fail:
18315 return NULL;
18316 }
18317
18318
18319 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18320 PyObject *resultobj = 0;
18321 wxImage *arg1 = (wxImage *) 0 ;
18322 buffer arg2 ;
18323 int arg3 ;
18324 void *argp1 = 0 ;
18325 int res1 = 0 ;
18326 Py_ssize_t temp2 ;
18327 PyObject * obj0 = 0 ;
18328 PyObject * obj1 = 0 ;
18329 char * kwnames[] = {
18330 (char *) "self",(char *) "alpha", NULL
18331 };
18332
18333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18335 if (!SWIG_IsOK(res1)) {
18336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18337 }
18338 arg1 = reinterpret_cast< wxImage * >(argp1);
18339 {
18340 if (obj1 != Py_None) {
18341 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18342 arg3 = (int)temp2;
18343 }
18344 }
18345 {
18346 PyThreadState* __tstate = wxPyBeginAllowThreads();
18347 wxImage_SetAlphaData(arg1,arg2,arg3);
18348 wxPyEndAllowThreads(__tstate);
18349 if (PyErr_Occurred()) SWIG_fail;
18350 }
18351 resultobj = SWIG_Py_Void();
18352 return resultobj;
18353 fail:
18354 return NULL;
18355 }
18356
18357
18358 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18359 PyObject *resultobj = 0;
18360 wxImage *arg1 = (wxImage *) 0 ;
18361 PyObject *result = 0 ;
18362 void *argp1 = 0 ;
18363 int res1 = 0 ;
18364 PyObject *swig_obj[1] ;
18365
18366 if (!args) SWIG_fail;
18367 swig_obj[0] = args;
18368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18369 if (!SWIG_IsOK(res1)) {
18370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18371 }
18372 arg1 = reinterpret_cast< wxImage * >(argp1);
18373 {
18374 PyThreadState* __tstate = wxPyBeginAllowThreads();
18375 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18376 wxPyEndAllowThreads(__tstate);
18377 if (PyErr_Occurred()) SWIG_fail;
18378 }
18379 resultobj = result;
18380 return resultobj;
18381 fail:
18382 return NULL;
18383 }
18384
18385
18386 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18387 PyObject *resultobj = 0;
18388 wxImage *arg1 = (wxImage *) 0 ;
18389 buffer arg2 ;
18390 int arg3 ;
18391 void *argp1 = 0 ;
18392 int res1 = 0 ;
18393 Py_ssize_t temp2 ;
18394 PyObject * obj0 = 0 ;
18395 PyObject * obj1 = 0 ;
18396 char * kwnames[] = {
18397 (char *) "self",(char *) "alpha", NULL
18398 };
18399
18400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18402 if (!SWIG_IsOK(res1)) {
18403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18404 }
18405 arg1 = reinterpret_cast< wxImage * >(argp1);
18406 {
18407 if (obj1 != Py_None) {
18408 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18409 arg3 = (int)temp2;
18410 }
18411 }
18412 {
18413 PyThreadState* __tstate = wxPyBeginAllowThreads();
18414 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18415 wxPyEndAllowThreads(__tstate);
18416 if (PyErr_Occurred()) SWIG_fail;
18417 }
18418 resultobj = SWIG_Py_Void();
18419 return resultobj;
18420 fail:
18421 return NULL;
18422 }
18423
18424
18425 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18426 PyObject *resultobj = 0;
18427 wxImage *arg1 = (wxImage *) 0 ;
18428 byte arg2 ;
18429 byte arg3 ;
18430 byte arg4 ;
18431 void *argp1 = 0 ;
18432 int res1 = 0 ;
18433 unsigned char val2 ;
18434 int ecode2 = 0 ;
18435 unsigned char val3 ;
18436 int ecode3 = 0 ;
18437 unsigned char val4 ;
18438 int ecode4 = 0 ;
18439 PyObject * obj0 = 0 ;
18440 PyObject * obj1 = 0 ;
18441 PyObject * obj2 = 0 ;
18442 PyObject * obj3 = 0 ;
18443 char * kwnames[] = {
18444 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18445 };
18446
18447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18449 if (!SWIG_IsOK(res1)) {
18450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18451 }
18452 arg1 = reinterpret_cast< wxImage * >(argp1);
18453 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18454 if (!SWIG_IsOK(ecode2)) {
18455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18456 }
18457 arg2 = static_cast< byte >(val2);
18458 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18459 if (!SWIG_IsOK(ecode3)) {
18460 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18461 }
18462 arg3 = static_cast< byte >(val3);
18463 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18464 if (!SWIG_IsOK(ecode4)) {
18465 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18466 }
18467 arg4 = static_cast< byte >(val4);
18468 {
18469 PyThreadState* __tstate = wxPyBeginAllowThreads();
18470 (arg1)->SetMaskColour(arg2,arg3,arg4);
18471 wxPyEndAllowThreads(__tstate);
18472 if (PyErr_Occurred()) SWIG_fail;
18473 }
18474 resultobj = SWIG_Py_Void();
18475 return resultobj;
18476 fail:
18477 return NULL;
18478 }
18479
18480
18481 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18482 PyObject *resultobj = 0;
18483 wxImage *arg1 = (wxImage *) 0 ;
18484 byte *arg2 = (byte *) 0 ;
18485 byte *arg3 = (byte *) 0 ;
18486 byte *arg4 = (byte *) 0 ;
18487 void *argp1 = 0 ;
18488 int res1 = 0 ;
18489 byte temp2 ;
18490 int res2 = SWIG_TMPOBJ ;
18491 byte temp3 ;
18492 int res3 = SWIG_TMPOBJ ;
18493 byte temp4 ;
18494 int res4 = SWIG_TMPOBJ ;
18495 PyObject *swig_obj[1] ;
18496
18497 arg2 = &temp2;
18498 arg3 = &temp3;
18499 arg4 = &temp4;
18500 if (!args) SWIG_fail;
18501 swig_obj[0] = args;
18502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18503 if (!SWIG_IsOK(res1)) {
18504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18505 }
18506 arg1 = reinterpret_cast< wxImage * >(argp1);
18507 {
18508 PyThreadState* __tstate = wxPyBeginAllowThreads();
18509 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18510 wxPyEndAllowThreads(__tstate);
18511 if (PyErr_Occurred()) SWIG_fail;
18512 }
18513 resultobj = SWIG_Py_Void();
18514 if (SWIG_IsTmpObj(res2)) {
18515 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18516 } else {
18517 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18518 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18519 }
18520 if (SWIG_IsTmpObj(res3)) {
18521 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18522 } else {
18523 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18524 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18525 }
18526 if (SWIG_IsTmpObj(res4)) {
18527 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18528 } else {
18529 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18530 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18531 }
18532 return resultobj;
18533 fail:
18534 return NULL;
18535 }
18536
18537
18538 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18539 PyObject *resultobj = 0;
18540 wxImage *arg1 = (wxImage *) 0 ;
18541 byte result;
18542 void *argp1 = 0 ;
18543 int res1 = 0 ;
18544 PyObject *swig_obj[1] ;
18545
18546 if (!args) SWIG_fail;
18547 swig_obj[0] = args;
18548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18549 if (!SWIG_IsOK(res1)) {
18550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18551 }
18552 arg1 = reinterpret_cast< wxImage * >(argp1);
18553 {
18554 PyThreadState* __tstate = wxPyBeginAllowThreads();
18555 result = (byte)(arg1)->GetMaskRed();
18556 wxPyEndAllowThreads(__tstate);
18557 if (PyErr_Occurred()) SWIG_fail;
18558 }
18559 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18560 return resultobj;
18561 fail:
18562 return NULL;
18563 }
18564
18565
18566 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18567 PyObject *resultobj = 0;
18568 wxImage *arg1 = (wxImage *) 0 ;
18569 byte result;
18570 void *argp1 = 0 ;
18571 int res1 = 0 ;
18572 PyObject *swig_obj[1] ;
18573
18574 if (!args) SWIG_fail;
18575 swig_obj[0] = args;
18576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18577 if (!SWIG_IsOK(res1)) {
18578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18579 }
18580 arg1 = reinterpret_cast< wxImage * >(argp1);
18581 {
18582 PyThreadState* __tstate = wxPyBeginAllowThreads();
18583 result = (byte)(arg1)->GetMaskGreen();
18584 wxPyEndAllowThreads(__tstate);
18585 if (PyErr_Occurred()) SWIG_fail;
18586 }
18587 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18588 return resultobj;
18589 fail:
18590 return NULL;
18591 }
18592
18593
18594 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18595 PyObject *resultobj = 0;
18596 wxImage *arg1 = (wxImage *) 0 ;
18597 byte result;
18598 void *argp1 = 0 ;
18599 int res1 = 0 ;
18600 PyObject *swig_obj[1] ;
18601
18602 if (!args) SWIG_fail;
18603 swig_obj[0] = args;
18604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18605 if (!SWIG_IsOK(res1)) {
18606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18607 }
18608 arg1 = reinterpret_cast< wxImage * >(argp1);
18609 {
18610 PyThreadState* __tstate = wxPyBeginAllowThreads();
18611 result = (byte)(arg1)->GetMaskBlue();
18612 wxPyEndAllowThreads(__tstate);
18613 if (PyErr_Occurred()) SWIG_fail;
18614 }
18615 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18616 return resultobj;
18617 fail:
18618 return NULL;
18619 }
18620
18621
18622 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18623 PyObject *resultobj = 0;
18624 wxImage *arg1 = (wxImage *) 0 ;
18625 bool arg2 = (bool) true ;
18626 void *argp1 = 0 ;
18627 int res1 = 0 ;
18628 bool val2 ;
18629 int ecode2 = 0 ;
18630 PyObject * obj0 = 0 ;
18631 PyObject * obj1 = 0 ;
18632 char * kwnames[] = {
18633 (char *) "self",(char *) "mask", NULL
18634 };
18635
18636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18638 if (!SWIG_IsOK(res1)) {
18639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18640 }
18641 arg1 = reinterpret_cast< wxImage * >(argp1);
18642 if (obj1) {
18643 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18644 if (!SWIG_IsOK(ecode2)) {
18645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18646 }
18647 arg2 = static_cast< bool >(val2);
18648 }
18649 {
18650 PyThreadState* __tstate = wxPyBeginAllowThreads();
18651 (arg1)->SetMask(arg2);
18652 wxPyEndAllowThreads(__tstate);
18653 if (PyErr_Occurred()) SWIG_fail;
18654 }
18655 resultobj = SWIG_Py_Void();
18656 return resultobj;
18657 fail:
18658 return NULL;
18659 }
18660
18661
18662 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18663 PyObject *resultobj = 0;
18664 wxImage *arg1 = (wxImage *) 0 ;
18665 bool result;
18666 void *argp1 = 0 ;
18667 int res1 = 0 ;
18668 PyObject *swig_obj[1] ;
18669
18670 if (!args) SWIG_fail;
18671 swig_obj[0] = args;
18672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18673 if (!SWIG_IsOK(res1)) {
18674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18675 }
18676 arg1 = reinterpret_cast< wxImage * >(argp1);
18677 {
18678 PyThreadState* __tstate = wxPyBeginAllowThreads();
18679 result = (bool)(arg1)->HasMask();
18680 wxPyEndAllowThreads(__tstate);
18681 if (PyErr_Occurred()) SWIG_fail;
18682 }
18683 {
18684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18685 }
18686 return resultobj;
18687 fail:
18688 return NULL;
18689 }
18690
18691
18692 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18693 PyObject *resultobj = 0;
18694 wxImage *arg1 = (wxImage *) 0 ;
18695 double arg2 ;
18696 wxPoint *arg3 = 0 ;
18697 bool arg4 = (bool) true ;
18698 wxPoint *arg5 = (wxPoint *) NULL ;
18699 SwigValueWrapper<wxImage > result;
18700 void *argp1 = 0 ;
18701 int res1 = 0 ;
18702 double val2 ;
18703 int ecode2 = 0 ;
18704 wxPoint temp3 ;
18705 bool val4 ;
18706 int ecode4 = 0 ;
18707 void *argp5 = 0 ;
18708 int res5 = 0 ;
18709 PyObject * obj0 = 0 ;
18710 PyObject * obj1 = 0 ;
18711 PyObject * obj2 = 0 ;
18712 PyObject * obj3 = 0 ;
18713 PyObject * obj4 = 0 ;
18714 char * kwnames[] = {
18715 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18716 };
18717
18718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18720 if (!SWIG_IsOK(res1)) {
18721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18722 }
18723 arg1 = reinterpret_cast< wxImage * >(argp1);
18724 ecode2 = SWIG_AsVal_double(obj1, &val2);
18725 if (!SWIG_IsOK(ecode2)) {
18726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18727 }
18728 arg2 = static_cast< double >(val2);
18729 {
18730 arg3 = &temp3;
18731 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18732 }
18733 if (obj3) {
18734 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18735 if (!SWIG_IsOK(ecode4)) {
18736 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18737 }
18738 arg4 = static_cast< bool >(val4);
18739 }
18740 if (obj4) {
18741 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18742 if (!SWIG_IsOK(res5)) {
18743 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
18744 }
18745 arg5 = reinterpret_cast< wxPoint * >(argp5);
18746 }
18747 {
18748 PyThreadState* __tstate = wxPyBeginAllowThreads();
18749 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18750 wxPyEndAllowThreads(__tstate);
18751 if (PyErr_Occurred()) SWIG_fail;
18752 }
18753 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18754 return resultobj;
18755 fail:
18756 return NULL;
18757 }
18758
18759
18760 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18761 PyObject *resultobj = 0;
18762 wxImage *arg1 = (wxImage *) 0 ;
18763 bool arg2 = (bool) true ;
18764 SwigValueWrapper<wxImage > result;
18765 void *argp1 = 0 ;
18766 int res1 = 0 ;
18767 bool val2 ;
18768 int ecode2 = 0 ;
18769 PyObject * obj0 = 0 ;
18770 PyObject * obj1 = 0 ;
18771 char * kwnames[] = {
18772 (char *) "self",(char *) "clockwise", NULL
18773 };
18774
18775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18777 if (!SWIG_IsOK(res1)) {
18778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18779 }
18780 arg1 = reinterpret_cast< wxImage * >(argp1);
18781 if (obj1) {
18782 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18783 if (!SWIG_IsOK(ecode2)) {
18784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18785 }
18786 arg2 = static_cast< bool >(val2);
18787 }
18788 {
18789 PyThreadState* __tstate = wxPyBeginAllowThreads();
18790 result = (arg1)->Rotate90(arg2);
18791 wxPyEndAllowThreads(__tstate);
18792 if (PyErr_Occurred()) SWIG_fail;
18793 }
18794 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18795 return resultobj;
18796 fail:
18797 return NULL;
18798 }
18799
18800
18801 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18802 PyObject *resultobj = 0;
18803 wxImage *arg1 = (wxImage *) 0 ;
18804 bool arg2 = (bool) true ;
18805 SwigValueWrapper<wxImage > result;
18806 void *argp1 = 0 ;
18807 int res1 = 0 ;
18808 bool val2 ;
18809 int ecode2 = 0 ;
18810 PyObject * obj0 = 0 ;
18811 PyObject * obj1 = 0 ;
18812 char * kwnames[] = {
18813 (char *) "self",(char *) "horizontally", NULL
18814 };
18815
18816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18818 if (!SWIG_IsOK(res1)) {
18819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18820 }
18821 arg1 = reinterpret_cast< wxImage * >(argp1);
18822 if (obj1) {
18823 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18824 if (!SWIG_IsOK(ecode2)) {
18825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18826 }
18827 arg2 = static_cast< bool >(val2);
18828 }
18829 {
18830 PyThreadState* __tstate = wxPyBeginAllowThreads();
18831 result = (arg1)->Mirror(arg2);
18832 wxPyEndAllowThreads(__tstate);
18833 if (PyErr_Occurred()) SWIG_fail;
18834 }
18835 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18836 return resultobj;
18837 fail:
18838 return NULL;
18839 }
18840
18841
18842 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18843 PyObject *resultobj = 0;
18844 wxImage *arg1 = (wxImage *) 0 ;
18845 byte arg2 ;
18846 byte arg3 ;
18847 byte arg4 ;
18848 byte arg5 ;
18849 byte arg6 ;
18850 byte arg7 ;
18851 void *argp1 = 0 ;
18852 int res1 = 0 ;
18853 unsigned char val2 ;
18854 int ecode2 = 0 ;
18855 unsigned char val3 ;
18856 int ecode3 = 0 ;
18857 unsigned char val4 ;
18858 int ecode4 = 0 ;
18859 unsigned char val5 ;
18860 int ecode5 = 0 ;
18861 unsigned char val6 ;
18862 int ecode6 = 0 ;
18863 unsigned char val7 ;
18864 int ecode7 = 0 ;
18865 PyObject * obj0 = 0 ;
18866 PyObject * obj1 = 0 ;
18867 PyObject * obj2 = 0 ;
18868 PyObject * obj3 = 0 ;
18869 PyObject * obj4 = 0 ;
18870 PyObject * obj5 = 0 ;
18871 PyObject * obj6 = 0 ;
18872 char * kwnames[] = {
18873 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18874 };
18875
18876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18878 if (!SWIG_IsOK(res1)) {
18879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18880 }
18881 arg1 = reinterpret_cast< wxImage * >(argp1);
18882 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18883 if (!SWIG_IsOK(ecode2)) {
18884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18885 }
18886 arg2 = static_cast< byte >(val2);
18887 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18888 if (!SWIG_IsOK(ecode3)) {
18889 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18890 }
18891 arg3 = static_cast< byte >(val3);
18892 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18893 if (!SWIG_IsOK(ecode4)) {
18894 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18895 }
18896 arg4 = static_cast< byte >(val4);
18897 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18898 if (!SWIG_IsOK(ecode5)) {
18899 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18900 }
18901 arg5 = static_cast< byte >(val5);
18902 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18903 if (!SWIG_IsOK(ecode6)) {
18904 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18905 }
18906 arg6 = static_cast< byte >(val6);
18907 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18908 if (!SWIG_IsOK(ecode7)) {
18909 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18910 }
18911 arg7 = static_cast< byte >(val7);
18912 {
18913 PyThreadState* __tstate = wxPyBeginAllowThreads();
18914 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18915 wxPyEndAllowThreads(__tstate);
18916 if (PyErr_Occurred()) SWIG_fail;
18917 }
18918 resultobj = SWIG_Py_Void();
18919 return resultobj;
18920 fail:
18921 return NULL;
18922 }
18923
18924
18925 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18926 PyObject *resultobj = 0;
18927 wxImage *arg1 = (wxImage *) 0 ;
18928 double arg2 = (double) 0.299 ;
18929 double arg3 = (double) 0.587 ;
18930 double arg4 = (double) 0.114 ;
18931 SwigValueWrapper<wxImage > result;
18932 void *argp1 = 0 ;
18933 int res1 = 0 ;
18934 double val2 ;
18935 int ecode2 = 0 ;
18936 double val3 ;
18937 int ecode3 = 0 ;
18938 double val4 ;
18939 int ecode4 = 0 ;
18940 PyObject * obj0 = 0 ;
18941 PyObject * obj1 = 0 ;
18942 PyObject * obj2 = 0 ;
18943 PyObject * obj3 = 0 ;
18944 char * kwnames[] = {
18945 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
18946 };
18947
18948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18950 if (!SWIG_IsOK(res1)) {
18951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
18952 }
18953 arg1 = reinterpret_cast< wxImage * >(argp1);
18954 if (obj1) {
18955 ecode2 = SWIG_AsVal_double(obj1, &val2);
18956 if (!SWIG_IsOK(ecode2)) {
18957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
18958 }
18959 arg2 = static_cast< double >(val2);
18960 }
18961 if (obj2) {
18962 ecode3 = SWIG_AsVal_double(obj2, &val3);
18963 if (!SWIG_IsOK(ecode3)) {
18964 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
18965 }
18966 arg3 = static_cast< double >(val3);
18967 }
18968 if (obj3) {
18969 ecode4 = SWIG_AsVal_double(obj3, &val4);
18970 if (!SWIG_IsOK(ecode4)) {
18971 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
18972 }
18973 arg4 = static_cast< double >(val4);
18974 }
18975 {
18976 PyThreadState* __tstate = wxPyBeginAllowThreads();
18977 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
18978 wxPyEndAllowThreads(__tstate);
18979 if (PyErr_Occurred()) SWIG_fail;
18980 }
18981 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18982 return resultobj;
18983 fail:
18984 return NULL;
18985 }
18986
18987
18988 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18989 PyObject *resultobj = 0;
18990 wxImage *arg1 = (wxImage *) 0 ;
18991 byte arg2 ;
18992 byte arg3 ;
18993 byte arg4 ;
18994 SwigValueWrapper<wxImage > result;
18995 void *argp1 = 0 ;
18996 int res1 = 0 ;
18997 unsigned char val2 ;
18998 int ecode2 = 0 ;
18999 unsigned char val3 ;
19000 int ecode3 = 0 ;
19001 unsigned char val4 ;
19002 int ecode4 = 0 ;
19003 PyObject * obj0 = 0 ;
19004 PyObject * obj1 = 0 ;
19005 PyObject * obj2 = 0 ;
19006 PyObject * obj3 = 0 ;
19007 char * kwnames[] = {
19008 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19009 };
19010
19011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19013 if (!SWIG_IsOK(res1)) {
19014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19015 }
19016 arg1 = reinterpret_cast< wxImage * >(argp1);
19017 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19018 if (!SWIG_IsOK(ecode2)) {
19019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19020 }
19021 arg2 = static_cast< byte >(val2);
19022 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19023 if (!SWIG_IsOK(ecode3)) {
19024 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19025 }
19026 arg3 = static_cast< byte >(val3);
19027 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19028 if (!SWIG_IsOK(ecode4)) {
19029 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19030 }
19031 arg4 = static_cast< byte >(val4);
19032 {
19033 PyThreadState* __tstate = wxPyBeginAllowThreads();
19034 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19035 wxPyEndAllowThreads(__tstate);
19036 if (PyErr_Occurred()) SWIG_fail;
19037 }
19038 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19039 return resultobj;
19040 fail:
19041 return NULL;
19042 }
19043
19044
19045 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19046 PyObject *resultobj = 0;
19047 wxImage *arg1 = (wxImage *) 0 ;
19048 wxString *arg2 = 0 ;
19049 wxString *arg3 = 0 ;
19050 void *argp1 = 0 ;
19051 int res1 = 0 ;
19052 bool temp2 = false ;
19053 bool temp3 = false ;
19054 PyObject * obj0 = 0 ;
19055 PyObject * obj1 = 0 ;
19056 PyObject * obj2 = 0 ;
19057 char * kwnames[] = {
19058 (char *) "self",(char *) "name",(char *) "value", NULL
19059 };
19060
19061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19063 if (!SWIG_IsOK(res1)) {
19064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19065 }
19066 arg1 = reinterpret_cast< wxImage * >(argp1);
19067 {
19068 arg2 = wxString_in_helper(obj1);
19069 if (arg2 == NULL) SWIG_fail;
19070 temp2 = true;
19071 }
19072 {
19073 arg3 = wxString_in_helper(obj2);
19074 if (arg3 == NULL) SWIG_fail;
19075 temp3 = true;
19076 }
19077 {
19078 PyThreadState* __tstate = wxPyBeginAllowThreads();
19079 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19080 wxPyEndAllowThreads(__tstate);
19081 if (PyErr_Occurred()) SWIG_fail;
19082 }
19083 resultobj = SWIG_Py_Void();
19084 {
19085 if (temp2)
19086 delete arg2;
19087 }
19088 {
19089 if (temp3)
19090 delete arg3;
19091 }
19092 return resultobj;
19093 fail:
19094 {
19095 if (temp2)
19096 delete arg2;
19097 }
19098 {
19099 if (temp3)
19100 delete arg3;
19101 }
19102 return NULL;
19103 }
19104
19105
19106 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19107 PyObject *resultobj = 0;
19108 wxImage *arg1 = (wxImage *) 0 ;
19109 wxString *arg2 = 0 ;
19110 int arg3 ;
19111 void *argp1 = 0 ;
19112 int res1 = 0 ;
19113 bool temp2 = false ;
19114 int val3 ;
19115 int ecode3 = 0 ;
19116 PyObject * obj0 = 0 ;
19117 PyObject * obj1 = 0 ;
19118 PyObject * obj2 = 0 ;
19119 char * kwnames[] = {
19120 (char *) "self",(char *) "name",(char *) "value", NULL
19121 };
19122
19123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19125 if (!SWIG_IsOK(res1)) {
19126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19127 }
19128 arg1 = reinterpret_cast< wxImage * >(argp1);
19129 {
19130 arg2 = wxString_in_helper(obj1);
19131 if (arg2 == NULL) SWIG_fail;
19132 temp2 = true;
19133 }
19134 ecode3 = SWIG_AsVal_int(obj2, &val3);
19135 if (!SWIG_IsOK(ecode3)) {
19136 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19137 }
19138 arg3 = static_cast< int >(val3);
19139 {
19140 PyThreadState* __tstate = wxPyBeginAllowThreads();
19141 (arg1)->SetOption((wxString const &)*arg2,arg3);
19142 wxPyEndAllowThreads(__tstate);
19143 if (PyErr_Occurred()) SWIG_fail;
19144 }
19145 resultobj = SWIG_Py_Void();
19146 {
19147 if (temp2)
19148 delete arg2;
19149 }
19150 return resultobj;
19151 fail:
19152 {
19153 if (temp2)
19154 delete arg2;
19155 }
19156 return NULL;
19157 }
19158
19159
19160 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19161 PyObject *resultobj = 0;
19162 wxImage *arg1 = (wxImage *) 0 ;
19163 wxString *arg2 = 0 ;
19164 wxString result;
19165 void *argp1 = 0 ;
19166 int res1 = 0 ;
19167 bool temp2 = false ;
19168 PyObject * obj0 = 0 ;
19169 PyObject * obj1 = 0 ;
19170 char * kwnames[] = {
19171 (char *) "self",(char *) "name", NULL
19172 };
19173
19174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19176 if (!SWIG_IsOK(res1)) {
19177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19178 }
19179 arg1 = reinterpret_cast< wxImage * >(argp1);
19180 {
19181 arg2 = wxString_in_helper(obj1);
19182 if (arg2 == NULL) SWIG_fail;
19183 temp2 = true;
19184 }
19185 {
19186 PyThreadState* __tstate = wxPyBeginAllowThreads();
19187 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19188 wxPyEndAllowThreads(__tstate);
19189 if (PyErr_Occurred()) SWIG_fail;
19190 }
19191 {
19192 #if wxUSE_UNICODE
19193 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19194 #else
19195 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19196 #endif
19197 }
19198 {
19199 if (temp2)
19200 delete arg2;
19201 }
19202 return resultobj;
19203 fail:
19204 {
19205 if (temp2)
19206 delete arg2;
19207 }
19208 return NULL;
19209 }
19210
19211
19212 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19213 PyObject *resultobj = 0;
19214 wxImage *arg1 = (wxImage *) 0 ;
19215 wxString *arg2 = 0 ;
19216 int result;
19217 void *argp1 = 0 ;
19218 int res1 = 0 ;
19219 bool temp2 = false ;
19220 PyObject * obj0 = 0 ;
19221 PyObject * obj1 = 0 ;
19222 char * kwnames[] = {
19223 (char *) "self",(char *) "name", NULL
19224 };
19225
19226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19228 if (!SWIG_IsOK(res1)) {
19229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19230 }
19231 arg1 = reinterpret_cast< wxImage * >(argp1);
19232 {
19233 arg2 = wxString_in_helper(obj1);
19234 if (arg2 == NULL) SWIG_fail;
19235 temp2 = true;
19236 }
19237 {
19238 PyThreadState* __tstate = wxPyBeginAllowThreads();
19239 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19240 wxPyEndAllowThreads(__tstate);
19241 if (PyErr_Occurred()) SWIG_fail;
19242 }
19243 resultobj = SWIG_From_int(static_cast< int >(result));
19244 {
19245 if (temp2)
19246 delete arg2;
19247 }
19248 return resultobj;
19249 fail:
19250 {
19251 if (temp2)
19252 delete arg2;
19253 }
19254 return NULL;
19255 }
19256
19257
19258 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19259 PyObject *resultobj = 0;
19260 wxImage *arg1 = (wxImage *) 0 ;
19261 wxString *arg2 = 0 ;
19262 bool result;
19263 void *argp1 = 0 ;
19264 int res1 = 0 ;
19265 bool temp2 = false ;
19266 PyObject * obj0 = 0 ;
19267 PyObject * obj1 = 0 ;
19268 char * kwnames[] = {
19269 (char *) "self",(char *) "name", NULL
19270 };
19271
19272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19274 if (!SWIG_IsOK(res1)) {
19275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19276 }
19277 arg1 = reinterpret_cast< wxImage * >(argp1);
19278 {
19279 arg2 = wxString_in_helper(obj1);
19280 if (arg2 == NULL) SWIG_fail;
19281 temp2 = true;
19282 }
19283 {
19284 PyThreadState* __tstate = wxPyBeginAllowThreads();
19285 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19286 wxPyEndAllowThreads(__tstate);
19287 if (PyErr_Occurred()) SWIG_fail;
19288 }
19289 {
19290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19291 }
19292 {
19293 if (temp2)
19294 delete arg2;
19295 }
19296 return resultobj;
19297 fail:
19298 {
19299 if (temp2)
19300 delete arg2;
19301 }
19302 return NULL;
19303 }
19304
19305
19306 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19307 PyObject *resultobj = 0;
19308 wxImage *arg1 = (wxImage *) 0 ;
19309 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19310 unsigned long result;
19311 void *argp1 = 0 ;
19312 int res1 = 0 ;
19313 unsigned long val2 ;
19314 int ecode2 = 0 ;
19315 PyObject * obj0 = 0 ;
19316 PyObject * obj1 = 0 ;
19317 char * kwnames[] = {
19318 (char *) "self",(char *) "stopafter", NULL
19319 };
19320
19321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19323 if (!SWIG_IsOK(res1)) {
19324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19325 }
19326 arg1 = reinterpret_cast< wxImage * >(argp1);
19327 if (obj1) {
19328 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19329 if (!SWIG_IsOK(ecode2)) {
19330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19331 }
19332 arg2 = static_cast< unsigned long >(val2);
19333 }
19334 {
19335 PyThreadState* __tstate = wxPyBeginAllowThreads();
19336 result = (unsigned long)(arg1)->CountColours(arg2);
19337 wxPyEndAllowThreads(__tstate);
19338 if (PyErr_Occurred()) SWIG_fail;
19339 }
19340 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19341 return resultobj;
19342 fail:
19343 return NULL;
19344 }
19345
19346
19347 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19348 PyObject *resultobj = 0;
19349 wxImage *arg1 = (wxImage *) 0 ;
19350 wxImageHistogram *arg2 = 0 ;
19351 unsigned long result;
19352 void *argp1 = 0 ;
19353 int res1 = 0 ;
19354 void *argp2 = 0 ;
19355 int res2 = 0 ;
19356 PyObject * obj0 = 0 ;
19357 PyObject * obj1 = 0 ;
19358 char * kwnames[] = {
19359 (char *) "self",(char *) "h", NULL
19360 };
19361
19362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19364 if (!SWIG_IsOK(res1)) {
19365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19366 }
19367 arg1 = reinterpret_cast< wxImage * >(argp1);
19368 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19369 if (!SWIG_IsOK(res2)) {
19370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19371 }
19372 if (!argp2) {
19373 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19374 }
19375 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19376 {
19377 PyThreadState* __tstate = wxPyBeginAllowThreads();
19378 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19379 wxPyEndAllowThreads(__tstate);
19380 if (PyErr_Occurred()) SWIG_fail;
19381 }
19382 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19383 return resultobj;
19384 fail:
19385 return NULL;
19386 }
19387
19388
19389 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19390 PyObject *resultobj = 0;
19391 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19392 void *argp1 = 0 ;
19393 int res1 = 0 ;
19394 PyObject * obj0 = 0 ;
19395 char * kwnames[] = {
19396 (char *) "handler", NULL
19397 };
19398
19399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19401 if (!SWIG_IsOK(res1)) {
19402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19403 }
19404 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19405 {
19406 PyThreadState* __tstate = wxPyBeginAllowThreads();
19407 wxImage::AddHandler(arg1);
19408 wxPyEndAllowThreads(__tstate);
19409 if (PyErr_Occurred()) SWIG_fail;
19410 }
19411 resultobj = SWIG_Py_Void();
19412 return resultobj;
19413 fail:
19414 return NULL;
19415 }
19416
19417
19418 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19419 PyObject *resultobj = 0;
19420 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19421 void *argp1 = 0 ;
19422 int res1 = 0 ;
19423 PyObject * obj0 = 0 ;
19424 char * kwnames[] = {
19425 (char *) "handler", NULL
19426 };
19427
19428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19430 if (!SWIG_IsOK(res1)) {
19431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19432 }
19433 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19434 {
19435 PyThreadState* __tstate = wxPyBeginAllowThreads();
19436 wxImage::InsertHandler(arg1);
19437 wxPyEndAllowThreads(__tstate);
19438 if (PyErr_Occurred()) SWIG_fail;
19439 }
19440 resultobj = SWIG_Py_Void();
19441 return resultobj;
19442 fail:
19443 return NULL;
19444 }
19445
19446
19447 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19448 PyObject *resultobj = 0;
19449 wxString *arg1 = 0 ;
19450 bool result;
19451 bool temp1 = false ;
19452 PyObject * obj0 = 0 ;
19453 char * kwnames[] = {
19454 (char *) "name", NULL
19455 };
19456
19457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19458 {
19459 arg1 = wxString_in_helper(obj0);
19460 if (arg1 == NULL) SWIG_fail;
19461 temp1 = true;
19462 }
19463 {
19464 PyThreadState* __tstate = wxPyBeginAllowThreads();
19465 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19466 wxPyEndAllowThreads(__tstate);
19467 if (PyErr_Occurred()) SWIG_fail;
19468 }
19469 {
19470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19471 }
19472 {
19473 if (temp1)
19474 delete arg1;
19475 }
19476 return resultobj;
19477 fail:
19478 {
19479 if (temp1)
19480 delete arg1;
19481 }
19482 return NULL;
19483 }
19484
19485
19486 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19487 PyObject *resultobj = 0;
19488 PyObject *result = 0 ;
19489
19490 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19491 {
19492 PyThreadState* __tstate = wxPyBeginAllowThreads();
19493 result = (PyObject *)wxImage_GetHandlers();
19494 wxPyEndAllowThreads(__tstate);
19495 if (PyErr_Occurred()) SWIG_fail;
19496 }
19497 resultobj = result;
19498 return resultobj;
19499 fail:
19500 return NULL;
19501 }
19502
19503
19504 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19505 PyObject *resultobj = 0;
19506 wxString result;
19507
19508 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19509 {
19510 PyThreadState* __tstate = wxPyBeginAllowThreads();
19511 result = wxImage::GetImageExtWildcard();
19512 wxPyEndAllowThreads(__tstate);
19513 if (PyErr_Occurred()) SWIG_fail;
19514 }
19515 {
19516 #if wxUSE_UNICODE
19517 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19518 #else
19519 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19520 #endif
19521 }
19522 return resultobj;
19523 fail:
19524 return NULL;
19525 }
19526
19527
19528 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19529 PyObject *resultobj = 0;
19530 wxImage *arg1 = (wxImage *) 0 ;
19531 int arg2 = (int) -1 ;
19532 wxBitmap result;
19533 void *argp1 = 0 ;
19534 int res1 = 0 ;
19535 int val2 ;
19536 int ecode2 = 0 ;
19537 PyObject * obj0 = 0 ;
19538 PyObject * obj1 = 0 ;
19539 char * kwnames[] = {
19540 (char *) "self",(char *) "depth", NULL
19541 };
19542
19543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19545 if (!SWIG_IsOK(res1)) {
19546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19547 }
19548 arg1 = reinterpret_cast< wxImage * >(argp1);
19549 if (obj1) {
19550 ecode2 = SWIG_AsVal_int(obj1, &val2);
19551 if (!SWIG_IsOK(ecode2)) {
19552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19553 }
19554 arg2 = static_cast< int >(val2);
19555 }
19556 {
19557 if (!wxPyCheckForApp()) SWIG_fail;
19558 PyThreadState* __tstate = wxPyBeginAllowThreads();
19559 result = wxImage_ConvertToBitmap(arg1,arg2);
19560 wxPyEndAllowThreads(__tstate);
19561 if (PyErr_Occurred()) SWIG_fail;
19562 }
19563 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19564 return resultobj;
19565 fail:
19566 return NULL;
19567 }
19568
19569
19570 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19571 PyObject *resultobj = 0;
19572 wxImage *arg1 = (wxImage *) 0 ;
19573 byte arg2 ;
19574 byte arg3 ;
19575 byte arg4 ;
19576 wxBitmap result;
19577 void *argp1 = 0 ;
19578 int res1 = 0 ;
19579 unsigned char val2 ;
19580 int ecode2 = 0 ;
19581 unsigned char val3 ;
19582 int ecode3 = 0 ;
19583 unsigned char val4 ;
19584 int ecode4 = 0 ;
19585 PyObject * obj0 = 0 ;
19586 PyObject * obj1 = 0 ;
19587 PyObject * obj2 = 0 ;
19588 PyObject * obj3 = 0 ;
19589 char * kwnames[] = {
19590 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19591 };
19592
19593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19595 if (!SWIG_IsOK(res1)) {
19596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19597 }
19598 arg1 = reinterpret_cast< wxImage * >(argp1);
19599 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19600 if (!SWIG_IsOK(ecode2)) {
19601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19602 }
19603 arg2 = static_cast< byte >(val2);
19604 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19605 if (!SWIG_IsOK(ecode3)) {
19606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19607 }
19608 arg3 = static_cast< byte >(val3);
19609 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19610 if (!SWIG_IsOK(ecode4)) {
19611 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19612 }
19613 arg4 = static_cast< byte >(val4);
19614 {
19615 if (!wxPyCheckForApp()) SWIG_fail;
19616 PyThreadState* __tstate = wxPyBeginAllowThreads();
19617 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19618 wxPyEndAllowThreads(__tstate);
19619 if (PyErr_Occurred()) SWIG_fail;
19620 }
19621 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19622 return resultobj;
19623 fail:
19624 return NULL;
19625 }
19626
19627
19628 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19629 PyObject *resultobj = 0;
19630 wxImage *arg1 = (wxImage *) 0 ;
19631 double arg2 ;
19632 void *argp1 = 0 ;
19633 int res1 = 0 ;
19634 double val2 ;
19635 int ecode2 = 0 ;
19636 PyObject * obj0 = 0 ;
19637 PyObject * obj1 = 0 ;
19638 char * kwnames[] = {
19639 (char *) "self",(char *) "angle", NULL
19640 };
19641
19642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19644 if (!SWIG_IsOK(res1)) {
19645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19646 }
19647 arg1 = reinterpret_cast< wxImage * >(argp1);
19648 ecode2 = SWIG_AsVal_double(obj1, &val2);
19649 if (!SWIG_IsOK(ecode2)) {
19650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19651 }
19652 arg2 = static_cast< double >(val2);
19653 {
19654 PyThreadState* __tstate = wxPyBeginAllowThreads();
19655 (arg1)->RotateHue(arg2);
19656 wxPyEndAllowThreads(__tstate);
19657 if (PyErr_Occurred()) SWIG_fail;
19658 }
19659 resultobj = SWIG_Py_Void();
19660 return resultobj;
19661 fail:
19662 return NULL;
19663 }
19664
19665
19666 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19667 PyObject *resultobj = 0;
19668 wxImage_RGBValue arg1 ;
19669 wxImage_HSVValue result;
19670 void *argp1 ;
19671 int res1 = 0 ;
19672 PyObject * obj0 = 0 ;
19673 char * kwnames[] = {
19674 (char *) "rgb", NULL
19675 };
19676
19677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19678 {
19679 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19680 if (!SWIG_IsOK(res1)) {
19681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19682 }
19683 if (!argp1) {
19684 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19685 } else {
19686 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19687 arg1 = *temp;
19688 if (SWIG_IsNewObj(res1)) delete temp;
19689 }
19690 }
19691 {
19692 PyThreadState* __tstate = wxPyBeginAllowThreads();
19693 result = wxImage::RGBtoHSV(arg1);
19694 wxPyEndAllowThreads(__tstate);
19695 if (PyErr_Occurred()) SWIG_fail;
19696 }
19697 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19698 return resultobj;
19699 fail:
19700 return NULL;
19701 }
19702
19703
19704 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19705 PyObject *resultobj = 0;
19706 wxImage_HSVValue arg1 ;
19707 wxImage_RGBValue result;
19708 void *argp1 ;
19709 int res1 = 0 ;
19710 PyObject * obj0 = 0 ;
19711 char * kwnames[] = {
19712 (char *) "hsv", NULL
19713 };
19714
19715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19716 {
19717 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19718 if (!SWIG_IsOK(res1)) {
19719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19720 }
19721 if (!argp1) {
19722 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19723 } else {
19724 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19725 arg1 = *temp;
19726 if (SWIG_IsNewObj(res1)) delete temp;
19727 }
19728 }
19729 {
19730 PyThreadState* __tstate = wxPyBeginAllowThreads();
19731 result = wxImage::HSVtoRGB(arg1);
19732 wxPyEndAllowThreads(__tstate);
19733 if (PyErr_Occurred()) SWIG_fail;
19734 }
19735 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19736 return resultobj;
19737 fail:
19738 return NULL;
19739 }
19740
19741
19742 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19743 PyObject *obj;
19744 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19745 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19746 return SWIG_Py_Void();
19747 }
19748
19749 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19750 return SWIG_Python_InitShadowInstance(args);
19751 }
19752
19753 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19754 PyObject *resultobj = 0;
19755 int arg1 ;
19756 int arg2 ;
19757 buffer arg3 ;
19758 int arg4 ;
19759 buffer arg5 = (buffer) NULL ;
19760 int arg6 = (int) 0 ;
19761 wxImage *result = 0 ;
19762 int val1 ;
19763 int ecode1 = 0 ;
19764 int val2 ;
19765 int ecode2 = 0 ;
19766 Py_ssize_t temp3 ;
19767 Py_ssize_t temp5 ;
19768 PyObject * obj0 = 0 ;
19769 PyObject * obj1 = 0 ;
19770 PyObject * obj2 = 0 ;
19771 PyObject * obj3 = 0 ;
19772 char * kwnames[] = {
19773 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19774 };
19775
19776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19777 ecode1 = SWIG_AsVal_int(obj0, &val1);
19778 if (!SWIG_IsOK(ecode1)) {
19779 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19780 }
19781 arg1 = static_cast< int >(val1);
19782 ecode2 = SWIG_AsVal_int(obj1, &val2);
19783 if (!SWIG_IsOK(ecode2)) {
19784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19785 }
19786 arg2 = static_cast< int >(val2);
19787 {
19788 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19789 arg4 = (int)temp3;
19790 }
19791 if (obj3) {
19792 {
19793 if (obj3 != Py_None) {
19794 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19795 arg6 = (int)temp5;
19796 }
19797 }
19798 }
19799 {
19800 PyThreadState* __tstate = wxPyBeginAllowThreads();
19801 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19802 wxPyEndAllowThreads(__tstate);
19803 if (PyErr_Occurred()) SWIG_fail;
19804 }
19805 {
19806 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19807 }
19808 return resultobj;
19809 fail:
19810 return NULL;
19811 }
19812
19813
19814 SWIGINTERN int NullImage_set(PyObject *) {
19815 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19816 return 1;
19817 }
19818
19819
19820 SWIGINTERN PyObject *NullImage_get(void) {
19821 PyObject *pyobj = 0;
19822
19823 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19824 return pyobj;
19825 }
19826
19827
19828 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19829 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19830 return 1;
19831 }
19832
19833
19834 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19835 PyObject *pyobj = 0;
19836
19837 {
19838 #if wxUSE_UNICODE
19839 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19840 #else
19841 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19842 #endif
19843 }
19844 return pyobj;
19845 }
19846
19847
19848 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19849 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19850 return 1;
19851 }
19852
19853
19854 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19855 PyObject *pyobj = 0;
19856
19857 {
19858 #if wxUSE_UNICODE
19859 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19860 #else
19861 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19862 #endif
19863 }
19864 return pyobj;
19865 }
19866
19867
19868 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19869 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19870 return 1;
19871 }
19872
19873
19874 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19875 PyObject *pyobj = 0;
19876
19877 {
19878 #if wxUSE_UNICODE
19879 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19880 #else
19881 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19882 #endif
19883 }
19884 return pyobj;
19885 }
19886
19887
19888 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19889 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19890 return 1;
19891 }
19892
19893
19894 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19895 PyObject *pyobj = 0;
19896
19897 {
19898 #if wxUSE_UNICODE
19899 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19900 #else
19901 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19902 #endif
19903 }
19904 return pyobj;
19905 }
19906
19907
19908 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19909 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19910 return 1;
19911 }
19912
19913
19914 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19915 PyObject *pyobj = 0;
19916
19917 {
19918 #if wxUSE_UNICODE
19919 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19920 #else
19921 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19922 #endif
19923 }
19924 return pyobj;
19925 }
19926
19927
19928 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
19929 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
19930 return 1;
19931 }
19932
19933
19934 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
19935 PyObject *pyobj = 0;
19936
19937 {
19938 #if wxUSE_UNICODE
19939 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19940 #else
19941 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19942 #endif
19943 }
19944 return pyobj;
19945 }
19946
19947
19948 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
19949 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
19950 return 1;
19951 }
19952
19953
19954 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
19955 PyObject *pyobj = 0;
19956
19957 {
19958 #if wxUSE_UNICODE
19959 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19960 #else
19961 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19962 #endif
19963 }
19964 return pyobj;
19965 }
19966
19967
19968 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
19969 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
19970 return 1;
19971 }
19972
19973
19974 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
19975 PyObject *pyobj = 0;
19976
19977 {
19978 #if wxUSE_UNICODE
19979 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19980 #else
19981 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19982 #endif
19983 }
19984 return pyobj;
19985 }
19986
19987
19988 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
19989 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
19990 return 1;
19991 }
19992
19993
19994 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
19995 PyObject *pyobj = 0;
19996
19997 {
19998 #if wxUSE_UNICODE
19999 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20000 #else
20001 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20002 #endif
20003 }
20004 return pyobj;
20005 }
20006
20007
20008 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
20009 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
20010 return 1;
20011 }
20012
20013
20014 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20015 PyObject *pyobj = 0;
20016
20017 {
20018 #if wxUSE_UNICODE
20019 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20020 #else
20021 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20022 #endif
20023 }
20024 return pyobj;
20025 }
20026
20027
20028 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20029 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20030 return 1;
20031 }
20032
20033
20034 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20035 PyObject *pyobj = 0;
20036
20037 {
20038 #if wxUSE_UNICODE
20039 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20040 #else
20041 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20042 #endif
20043 }
20044 return pyobj;
20045 }
20046
20047
20048 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20049 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20050 return 1;
20051 }
20052
20053
20054 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20055 PyObject *pyobj = 0;
20056
20057 {
20058 #if wxUSE_UNICODE
20059 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20060 #else
20061 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20062 #endif
20063 }
20064 return pyobj;
20065 }
20066
20067
20068 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20069 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20070 return 1;
20071 }
20072
20073
20074 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20075 PyObject *pyobj = 0;
20076
20077 {
20078 #if wxUSE_UNICODE
20079 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20080 #else
20081 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20082 #endif
20083 }
20084 return pyobj;
20085 }
20086
20087
20088 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20089 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20090 return 1;
20091 }
20092
20093
20094 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20095 PyObject *pyobj = 0;
20096
20097 {
20098 #if wxUSE_UNICODE
20099 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20100 #else
20101 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20102 #endif
20103 }
20104 return pyobj;
20105 }
20106
20107
20108 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20109 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20110 return 1;
20111 }
20112
20113
20114 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20115 PyObject *pyobj = 0;
20116
20117 {
20118 #if wxUSE_UNICODE
20119 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20120 #else
20121 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20122 #endif
20123 }
20124 return pyobj;
20125 }
20126
20127
20128 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20129 PyObject *resultobj = 0;
20130 wxBMPHandler *result = 0 ;
20131
20132 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20133 {
20134 PyThreadState* __tstate = wxPyBeginAllowThreads();
20135 result = (wxBMPHandler *)new wxBMPHandler();
20136 wxPyEndAllowThreads(__tstate);
20137 if (PyErr_Occurred()) SWIG_fail;
20138 }
20139 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20140 return resultobj;
20141 fail:
20142 return NULL;
20143 }
20144
20145
20146 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20147 PyObject *obj;
20148 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20149 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20150 return SWIG_Py_Void();
20151 }
20152
20153 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20154 return SWIG_Python_InitShadowInstance(args);
20155 }
20156
20157 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20158 PyObject *resultobj = 0;
20159 wxICOHandler *result = 0 ;
20160
20161 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20162 {
20163 PyThreadState* __tstate = wxPyBeginAllowThreads();
20164 result = (wxICOHandler *)new wxICOHandler();
20165 wxPyEndAllowThreads(__tstate);
20166 if (PyErr_Occurred()) SWIG_fail;
20167 }
20168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20169 return resultobj;
20170 fail:
20171 return NULL;
20172 }
20173
20174
20175 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20176 PyObject *obj;
20177 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20178 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20179 return SWIG_Py_Void();
20180 }
20181
20182 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20183 return SWIG_Python_InitShadowInstance(args);
20184 }
20185
20186 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20187 PyObject *resultobj = 0;
20188 wxCURHandler *result = 0 ;
20189
20190 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20191 {
20192 PyThreadState* __tstate = wxPyBeginAllowThreads();
20193 result = (wxCURHandler *)new wxCURHandler();
20194 wxPyEndAllowThreads(__tstate);
20195 if (PyErr_Occurred()) SWIG_fail;
20196 }
20197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20198 return resultobj;
20199 fail:
20200 return NULL;
20201 }
20202
20203
20204 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20205 PyObject *obj;
20206 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20207 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20208 return SWIG_Py_Void();
20209 }
20210
20211 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20212 return SWIG_Python_InitShadowInstance(args);
20213 }
20214
20215 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20216 PyObject *resultobj = 0;
20217 wxANIHandler *result = 0 ;
20218
20219 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20220 {
20221 PyThreadState* __tstate = wxPyBeginAllowThreads();
20222 result = (wxANIHandler *)new wxANIHandler();
20223 wxPyEndAllowThreads(__tstate);
20224 if (PyErr_Occurred()) SWIG_fail;
20225 }
20226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20227 return resultobj;
20228 fail:
20229 return NULL;
20230 }
20231
20232
20233 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20234 PyObject *obj;
20235 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20236 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20237 return SWIG_Py_Void();
20238 }
20239
20240 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20241 return SWIG_Python_InitShadowInstance(args);
20242 }
20243
20244 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20245 PyObject *resultobj = 0;
20246 wxPNGHandler *result = 0 ;
20247
20248 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20249 {
20250 PyThreadState* __tstate = wxPyBeginAllowThreads();
20251 result = (wxPNGHandler *)new wxPNGHandler();
20252 wxPyEndAllowThreads(__tstate);
20253 if (PyErr_Occurred()) SWIG_fail;
20254 }
20255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20256 return resultobj;
20257 fail:
20258 return NULL;
20259 }
20260
20261
20262 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20263 PyObject *obj;
20264 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20265 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20266 return SWIG_Py_Void();
20267 }
20268
20269 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20270 return SWIG_Python_InitShadowInstance(args);
20271 }
20272
20273 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20274 PyObject *resultobj = 0;
20275 wxGIFHandler *result = 0 ;
20276
20277 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20278 {
20279 PyThreadState* __tstate = wxPyBeginAllowThreads();
20280 result = (wxGIFHandler *)new wxGIFHandler();
20281 wxPyEndAllowThreads(__tstate);
20282 if (PyErr_Occurred()) SWIG_fail;
20283 }
20284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20285 return resultobj;
20286 fail:
20287 return NULL;
20288 }
20289
20290
20291 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20292 PyObject *obj;
20293 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20294 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20295 return SWIG_Py_Void();
20296 }
20297
20298 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20299 return SWIG_Python_InitShadowInstance(args);
20300 }
20301
20302 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20303 PyObject *resultobj = 0;
20304 wxPCXHandler *result = 0 ;
20305
20306 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20307 {
20308 PyThreadState* __tstate = wxPyBeginAllowThreads();
20309 result = (wxPCXHandler *)new wxPCXHandler();
20310 wxPyEndAllowThreads(__tstate);
20311 if (PyErr_Occurred()) SWIG_fail;
20312 }
20313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20314 return resultobj;
20315 fail:
20316 return NULL;
20317 }
20318
20319
20320 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20321 PyObject *obj;
20322 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20323 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20324 return SWIG_Py_Void();
20325 }
20326
20327 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20328 return SWIG_Python_InitShadowInstance(args);
20329 }
20330
20331 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20332 PyObject *resultobj = 0;
20333 wxJPEGHandler *result = 0 ;
20334
20335 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20336 {
20337 PyThreadState* __tstate = wxPyBeginAllowThreads();
20338 result = (wxJPEGHandler *)new wxJPEGHandler();
20339 wxPyEndAllowThreads(__tstate);
20340 if (PyErr_Occurred()) SWIG_fail;
20341 }
20342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20343 return resultobj;
20344 fail:
20345 return NULL;
20346 }
20347
20348
20349 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20350 PyObject *obj;
20351 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20352 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20353 return SWIG_Py_Void();
20354 }
20355
20356 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20357 return SWIG_Python_InitShadowInstance(args);
20358 }
20359
20360 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20361 PyObject *resultobj = 0;
20362 wxPNMHandler *result = 0 ;
20363
20364 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20365 {
20366 PyThreadState* __tstate = wxPyBeginAllowThreads();
20367 result = (wxPNMHandler *)new wxPNMHandler();
20368 wxPyEndAllowThreads(__tstate);
20369 if (PyErr_Occurred()) SWIG_fail;
20370 }
20371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20372 return resultobj;
20373 fail:
20374 return NULL;
20375 }
20376
20377
20378 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20379 PyObject *obj;
20380 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20381 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20382 return SWIG_Py_Void();
20383 }
20384
20385 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20386 return SWIG_Python_InitShadowInstance(args);
20387 }
20388
20389 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20390 PyObject *resultobj = 0;
20391 wxXPMHandler *result = 0 ;
20392
20393 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20394 {
20395 PyThreadState* __tstate = wxPyBeginAllowThreads();
20396 result = (wxXPMHandler *)new wxXPMHandler();
20397 wxPyEndAllowThreads(__tstate);
20398 if (PyErr_Occurred()) SWIG_fail;
20399 }
20400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20401 return resultobj;
20402 fail:
20403 return NULL;
20404 }
20405
20406
20407 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20408 PyObject *obj;
20409 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20410 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20411 return SWIG_Py_Void();
20412 }
20413
20414 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20415 return SWIG_Python_InitShadowInstance(args);
20416 }
20417
20418 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20419 PyObject *resultobj = 0;
20420 wxTIFFHandler *result = 0 ;
20421
20422 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20423 {
20424 PyThreadState* __tstate = wxPyBeginAllowThreads();
20425 result = (wxTIFFHandler *)new wxTIFFHandler();
20426 wxPyEndAllowThreads(__tstate);
20427 if (PyErr_Occurred()) SWIG_fail;
20428 }
20429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20430 return resultobj;
20431 fail:
20432 return NULL;
20433 }
20434
20435
20436 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20437 PyObject *obj;
20438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20439 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20440 return SWIG_Py_Void();
20441 }
20442
20443 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20444 return SWIG_Python_InitShadowInstance(args);
20445 }
20446
20447 SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20448 PyObject *resultobj = 0;
20449 wxTGAHandler *result = 0 ;
20450
20451 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
20452 {
20453 PyThreadState* __tstate = wxPyBeginAllowThreads();
20454 result = (wxTGAHandler *)new wxTGAHandler();
20455 wxPyEndAllowThreads(__tstate);
20456 if (PyErr_Occurred()) SWIG_fail;
20457 }
20458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
20459 return resultobj;
20460 fail:
20461 return NULL;
20462 }
20463
20464
20465 SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20466 PyObject *obj;
20467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20468 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
20469 return SWIG_Py_Void();
20470 }
20471
20472 SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20473 return SWIG_Python_InitShadowInstance(args);
20474 }
20475
20476 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20477 PyObject *resultobj = 0;
20478 wxImage *arg1 = 0 ;
20479 wxImage *arg2 = 0 ;
20480 int arg3 = (int) 236 ;
20481 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20482 bool result;
20483 void *argp1 = 0 ;
20484 int res1 = 0 ;
20485 void *argp2 = 0 ;
20486 int res2 = 0 ;
20487 int val3 ;
20488 int ecode3 = 0 ;
20489 int val4 ;
20490 int ecode4 = 0 ;
20491 PyObject * obj0 = 0 ;
20492 PyObject * obj1 = 0 ;
20493 PyObject * obj2 = 0 ;
20494 PyObject * obj3 = 0 ;
20495 char * kwnames[] = {
20496 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20497 };
20498
20499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20500 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20501 if (!SWIG_IsOK(res1)) {
20502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20503 }
20504 if (!argp1) {
20505 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20506 }
20507 arg1 = reinterpret_cast< wxImage * >(argp1);
20508 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20509 if (!SWIG_IsOK(res2)) {
20510 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20511 }
20512 if (!argp2) {
20513 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20514 }
20515 arg2 = reinterpret_cast< wxImage * >(argp2);
20516 if (obj2) {
20517 ecode3 = SWIG_AsVal_int(obj2, &val3);
20518 if (!SWIG_IsOK(ecode3)) {
20519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20520 }
20521 arg3 = static_cast< int >(val3);
20522 }
20523 if (obj3) {
20524 ecode4 = SWIG_AsVal_int(obj3, &val4);
20525 if (!SWIG_IsOK(ecode4)) {
20526 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20527 }
20528 arg4 = static_cast< int >(val4);
20529 }
20530 {
20531 PyThreadState* __tstate = wxPyBeginAllowThreads();
20532 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20533 wxPyEndAllowThreads(__tstate);
20534 if (PyErr_Occurred()) SWIG_fail;
20535 }
20536 {
20537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20538 }
20539 return resultobj;
20540 fail:
20541 return NULL;
20542 }
20543
20544
20545 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20546 PyObject *obj;
20547 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20548 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20549 return SWIG_Py_Void();
20550 }
20551
20552 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20553 PyObject *resultobj = 0;
20554 wxEvtHandler *result = 0 ;
20555
20556 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20557 {
20558 PyThreadState* __tstate = wxPyBeginAllowThreads();
20559 result = (wxEvtHandler *)new wxEvtHandler();
20560 wxPyEndAllowThreads(__tstate);
20561 if (PyErr_Occurred()) SWIG_fail;
20562 }
20563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20564 return resultobj;
20565 fail:
20566 return NULL;
20567 }
20568
20569
20570 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20571 PyObject *resultobj = 0;
20572 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20573 wxEvtHandler *result = 0 ;
20574 void *argp1 = 0 ;
20575 int res1 = 0 ;
20576 PyObject *swig_obj[1] ;
20577
20578 if (!args) SWIG_fail;
20579 swig_obj[0] = args;
20580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20581 if (!SWIG_IsOK(res1)) {
20582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20583 }
20584 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20585 {
20586 PyThreadState* __tstate = wxPyBeginAllowThreads();
20587 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20588 wxPyEndAllowThreads(__tstate);
20589 if (PyErr_Occurred()) SWIG_fail;
20590 }
20591 {
20592 resultobj = wxPyMake_wxObject(result, 0);
20593 }
20594 return resultobj;
20595 fail:
20596 return NULL;
20597 }
20598
20599
20600 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20601 PyObject *resultobj = 0;
20602 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20603 wxEvtHandler *result = 0 ;
20604 void *argp1 = 0 ;
20605 int res1 = 0 ;
20606 PyObject *swig_obj[1] ;
20607
20608 if (!args) SWIG_fail;
20609 swig_obj[0] = args;
20610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20611 if (!SWIG_IsOK(res1)) {
20612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20613 }
20614 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20615 {
20616 PyThreadState* __tstate = wxPyBeginAllowThreads();
20617 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20618 wxPyEndAllowThreads(__tstate);
20619 if (PyErr_Occurred()) SWIG_fail;
20620 }
20621 {
20622 resultobj = wxPyMake_wxObject(result, 0);
20623 }
20624 return resultobj;
20625 fail:
20626 return NULL;
20627 }
20628
20629
20630 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20631 PyObject *resultobj = 0;
20632 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20633 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20634 void *argp1 = 0 ;
20635 int res1 = 0 ;
20636 void *argp2 = 0 ;
20637 int res2 = 0 ;
20638 PyObject * obj0 = 0 ;
20639 PyObject * obj1 = 0 ;
20640 char * kwnames[] = {
20641 (char *) "self",(char *) "handler", NULL
20642 };
20643
20644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20646 if (!SWIG_IsOK(res1)) {
20647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20648 }
20649 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20650 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20651 if (!SWIG_IsOK(res2)) {
20652 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20653 }
20654 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20655 {
20656 PyThreadState* __tstate = wxPyBeginAllowThreads();
20657 (arg1)->SetNextHandler(arg2);
20658 wxPyEndAllowThreads(__tstate);
20659 if (PyErr_Occurred()) SWIG_fail;
20660 }
20661 resultobj = SWIG_Py_Void();
20662 return resultobj;
20663 fail:
20664 return NULL;
20665 }
20666
20667
20668 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20669 PyObject *resultobj = 0;
20670 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20671 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20672 void *argp1 = 0 ;
20673 int res1 = 0 ;
20674 void *argp2 = 0 ;
20675 int res2 = 0 ;
20676 PyObject * obj0 = 0 ;
20677 PyObject * obj1 = 0 ;
20678 char * kwnames[] = {
20679 (char *) "self",(char *) "handler", NULL
20680 };
20681
20682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20684 if (!SWIG_IsOK(res1)) {
20685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20686 }
20687 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20688 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20689 if (!SWIG_IsOK(res2)) {
20690 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20691 }
20692 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20693 {
20694 PyThreadState* __tstate = wxPyBeginAllowThreads();
20695 (arg1)->SetPreviousHandler(arg2);
20696 wxPyEndAllowThreads(__tstate);
20697 if (PyErr_Occurred()) SWIG_fail;
20698 }
20699 resultobj = SWIG_Py_Void();
20700 return resultobj;
20701 fail:
20702 return NULL;
20703 }
20704
20705
20706 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20707 PyObject *resultobj = 0;
20708 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20709 bool result;
20710 void *argp1 = 0 ;
20711 int res1 = 0 ;
20712 PyObject *swig_obj[1] ;
20713
20714 if (!args) SWIG_fail;
20715 swig_obj[0] = args;
20716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20717 if (!SWIG_IsOK(res1)) {
20718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20719 }
20720 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20721 {
20722 PyThreadState* __tstate = wxPyBeginAllowThreads();
20723 result = (bool)(arg1)->GetEvtHandlerEnabled();
20724 wxPyEndAllowThreads(__tstate);
20725 if (PyErr_Occurred()) SWIG_fail;
20726 }
20727 {
20728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20729 }
20730 return resultobj;
20731 fail:
20732 return NULL;
20733 }
20734
20735
20736 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20737 PyObject *resultobj = 0;
20738 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20739 bool arg2 ;
20740 void *argp1 = 0 ;
20741 int res1 = 0 ;
20742 bool val2 ;
20743 int ecode2 = 0 ;
20744 PyObject * obj0 = 0 ;
20745 PyObject * obj1 = 0 ;
20746 char * kwnames[] = {
20747 (char *) "self",(char *) "enabled", NULL
20748 };
20749
20750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20752 if (!SWIG_IsOK(res1)) {
20753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20754 }
20755 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20756 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20757 if (!SWIG_IsOK(ecode2)) {
20758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20759 }
20760 arg2 = static_cast< bool >(val2);
20761 {
20762 PyThreadState* __tstate = wxPyBeginAllowThreads();
20763 (arg1)->SetEvtHandlerEnabled(arg2);
20764 wxPyEndAllowThreads(__tstate);
20765 if (PyErr_Occurred()) SWIG_fail;
20766 }
20767 resultobj = SWIG_Py_Void();
20768 return resultobj;
20769 fail:
20770 return NULL;
20771 }
20772
20773
20774 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20775 PyObject *resultobj = 0;
20776 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20777 wxEvent *arg2 = 0 ;
20778 bool result;
20779 void *argp1 = 0 ;
20780 int res1 = 0 ;
20781 void *argp2 = 0 ;
20782 int res2 = 0 ;
20783 PyObject * obj0 = 0 ;
20784 PyObject * obj1 = 0 ;
20785 char * kwnames[] = {
20786 (char *) "self",(char *) "event", NULL
20787 };
20788
20789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20791 if (!SWIG_IsOK(res1)) {
20792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20793 }
20794 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20795 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20796 if (!SWIG_IsOK(res2)) {
20797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20798 }
20799 if (!argp2) {
20800 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20801 }
20802 arg2 = reinterpret_cast< wxEvent * >(argp2);
20803 {
20804 PyThreadState* __tstate = wxPyBeginAllowThreads();
20805 result = (bool)(arg1)->ProcessEvent(*arg2);
20806 wxPyEndAllowThreads(__tstate);
20807 if (PyErr_Occurred()) SWIG_fail;
20808 }
20809 {
20810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20811 }
20812 return resultobj;
20813 fail:
20814 return NULL;
20815 }
20816
20817
20818 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20819 PyObject *resultobj = 0;
20820 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20821 wxEvent *arg2 = 0 ;
20822 void *argp1 = 0 ;
20823 int res1 = 0 ;
20824 void *argp2 = 0 ;
20825 int res2 = 0 ;
20826 PyObject * obj0 = 0 ;
20827 PyObject * obj1 = 0 ;
20828 char * kwnames[] = {
20829 (char *) "self",(char *) "event", NULL
20830 };
20831
20832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20834 if (!SWIG_IsOK(res1)) {
20835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20836 }
20837 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20838 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20839 if (!SWIG_IsOK(res2)) {
20840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20841 }
20842 if (!argp2) {
20843 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20844 }
20845 arg2 = reinterpret_cast< wxEvent * >(argp2);
20846 {
20847 PyThreadState* __tstate = wxPyBeginAllowThreads();
20848 (arg1)->AddPendingEvent(*arg2);
20849 wxPyEndAllowThreads(__tstate);
20850 if (PyErr_Occurred()) SWIG_fail;
20851 }
20852 resultobj = SWIG_Py_Void();
20853 return resultobj;
20854 fail:
20855 return NULL;
20856 }
20857
20858
20859 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20860 PyObject *resultobj = 0;
20861 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20862 void *argp1 = 0 ;
20863 int res1 = 0 ;
20864 PyObject *swig_obj[1] ;
20865
20866 if (!args) SWIG_fail;
20867 swig_obj[0] = args;
20868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20869 if (!SWIG_IsOK(res1)) {
20870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20871 }
20872 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20873 {
20874 PyThreadState* __tstate = wxPyBeginAllowThreads();
20875 (arg1)->ProcessPendingEvents();
20876 wxPyEndAllowThreads(__tstate);
20877 if (PyErr_Occurred()) SWIG_fail;
20878 }
20879 resultobj = SWIG_Py_Void();
20880 return resultobj;
20881 fail:
20882 return NULL;
20883 }
20884
20885
20886 SWIGINTERN PyObject *_wrap_EvtHandler_AllowReentrance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20887 PyObject *resultobj = 0;
20888 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20889 bool arg2 = (bool) true ;
20890 void *argp1 = 0 ;
20891 int res1 = 0 ;
20892 bool val2 ;
20893 int ecode2 = 0 ;
20894 PyObject * obj0 = 0 ;
20895 PyObject * obj1 = 0 ;
20896 char * kwnames[] = {
20897 (char *) "self",(char *) "allow", NULL
20898 };
20899
20900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EvtHandler_AllowReentrance",kwnames,&obj0,&obj1)) SWIG_fail;
20901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20902 if (!SWIG_IsOK(res1)) {
20903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20904 }
20905 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20906 if (obj1) {
20907 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20908 if (!SWIG_IsOK(ecode2)) {
20909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "2"" of type '" "bool""'");
20910 }
20911 arg2 = static_cast< bool >(val2);
20912 }
20913 {
20914 PyThreadState* __tstate = wxPyBeginAllowThreads();
20915 (arg1)->AllowReentrance(arg2);
20916 wxPyEndAllowThreads(__tstate);
20917 if (PyErr_Occurred()) SWIG_fail;
20918 }
20919 resultobj = SWIG_Py_Void();
20920 return resultobj;
20921 fail:
20922 return NULL;
20923 }
20924
20925
20926 SWIGINTERN PyObject *_wrap_EvtHandler_IsReentranceAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20927 PyObject *resultobj = 0;
20928 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20929 bool result;
20930 void *argp1 = 0 ;
20931 int res1 = 0 ;
20932 PyObject *swig_obj[1] ;
20933
20934 if (!args) SWIG_fail;
20935 swig_obj[0] = args;
20936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20937 if (!SWIG_IsOK(res1)) {
20938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsReentranceAllowed" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20939 }
20940 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20941 {
20942 PyThreadState* __tstate = wxPyBeginAllowThreads();
20943 result = (bool)(arg1)->IsReentranceAllowed();
20944 wxPyEndAllowThreads(__tstate);
20945 if (PyErr_Occurred()) SWIG_fail;
20946 }
20947 {
20948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20949 }
20950 return resultobj;
20951 fail:
20952 return NULL;
20953 }
20954
20955
20956 SWIGINTERN PyObject *_wrap_EvtHandler_IsEventHandlingInProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20957 PyObject *resultobj = 0;
20958 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20959 bool result;
20960 void *argp1 = 0 ;
20961 int res1 = 0 ;
20962 PyObject *swig_obj[1] ;
20963
20964 if (!args) SWIG_fail;
20965 swig_obj[0] = args;
20966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20967 if (!SWIG_IsOK(res1)) {
20968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsEventHandlingInProgress" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20969 }
20970 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20971 {
20972 PyThreadState* __tstate = wxPyBeginAllowThreads();
20973 result = (bool)(arg1)->IsEventHandlingInProgress();
20974 wxPyEndAllowThreads(__tstate);
20975 if (PyErr_Occurred()) SWIG_fail;
20976 }
20977 {
20978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20979 }
20980 return resultobj;
20981 fail:
20982 return NULL;
20983 }
20984
20985
20986 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20987 PyObject *resultobj = 0;
20988 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20989 int arg2 ;
20990 int arg3 ;
20991 int arg4 ;
20992 PyObject *arg5 = (PyObject *) 0 ;
20993 void *argp1 = 0 ;
20994 int res1 = 0 ;
20995 int val2 ;
20996 int ecode2 = 0 ;
20997 int val3 ;
20998 int ecode3 = 0 ;
20999 int val4 ;
21000 int ecode4 = 0 ;
21001 PyObject * obj0 = 0 ;
21002 PyObject * obj1 = 0 ;
21003 PyObject * obj2 = 0 ;
21004 PyObject * obj3 = 0 ;
21005 PyObject * obj4 = 0 ;
21006 char * kwnames[] = {
21007 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
21008 };
21009
21010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21012 if (!SWIG_IsOK(res1)) {
21013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21014 }
21015 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21016 ecode2 = SWIG_AsVal_int(obj1, &val2);
21017 if (!SWIG_IsOK(ecode2)) {
21018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
21019 }
21020 arg2 = static_cast< int >(val2);
21021 ecode3 = SWIG_AsVal_int(obj2, &val3);
21022 if (!SWIG_IsOK(ecode3)) {
21023 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
21024 }
21025 arg3 = static_cast< int >(val3);
21026 ecode4 = SWIG_AsVal_int(obj3, &val4);
21027 if (!SWIG_IsOK(ecode4)) {
21028 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
21029 }
21030 arg4 = static_cast< int >(val4);
21031 arg5 = obj4;
21032 {
21033 PyThreadState* __tstate = wxPyBeginAllowThreads();
21034 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
21035 wxPyEndAllowThreads(__tstate);
21036 if (PyErr_Occurred()) SWIG_fail;
21037 }
21038 resultobj = SWIG_Py_Void();
21039 return resultobj;
21040 fail:
21041 return NULL;
21042 }
21043
21044
21045 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21046 PyObject *resultobj = 0;
21047 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21048 int arg2 ;
21049 int arg3 = (int) -1 ;
21050 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
21051 bool result;
21052 void *argp1 = 0 ;
21053 int res1 = 0 ;
21054 int val2 ;
21055 int ecode2 = 0 ;
21056 int val3 ;
21057 int ecode3 = 0 ;
21058 int val4 ;
21059 int ecode4 = 0 ;
21060 PyObject * obj0 = 0 ;
21061 PyObject * obj1 = 0 ;
21062 PyObject * obj2 = 0 ;
21063 PyObject * obj3 = 0 ;
21064 char * kwnames[] = {
21065 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
21066 };
21067
21068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21070 if (!SWIG_IsOK(res1)) {
21071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21072 }
21073 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21074 ecode2 = SWIG_AsVal_int(obj1, &val2);
21075 if (!SWIG_IsOK(ecode2)) {
21076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
21077 }
21078 arg2 = static_cast< int >(val2);
21079 if (obj2) {
21080 ecode3 = SWIG_AsVal_int(obj2, &val3);
21081 if (!SWIG_IsOK(ecode3)) {
21082 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
21083 }
21084 arg3 = static_cast< int >(val3);
21085 }
21086 if (obj3) {
21087 ecode4 = SWIG_AsVal_int(obj3, &val4);
21088 if (!SWIG_IsOK(ecode4)) {
21089 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
21090 }
21091 arg4 = static_cast< wxEventType >(val4);
21092 }
21093 {
21094 PyThreadState* __tstate = wxPyBeginAllowThreads();
21095 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
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_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21109 PyObject *resultobj = 0;
21110 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21111 PyObject *arg2 = (PyObject *) 0 ;
21112 bool arg3 = (bool) true ;
21113 void *argp1 = 0 ;
21114 int res1 = 0 ;
21115 bool val3 ;
21116 int ecode3 = 0 ;
21117 PyObject * obj0 = 0 ;
21118 PyObject * obj1 = 0 ;
21119 PyObject * obj2 = 0 ;
21120 char * kwnames[] = {
21121 (char *) "self",(char *) "_self",(char *) "incref", NULL
21122 };
21123
21124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21126 if (!SWIG_IsOK(res1)) {
21127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21128 }
21129 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21130 arg2 = obj1;
21131 if (obj2) {
21132 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21133 if (!SWIG_IsOK(ecode3)) {
21134 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21135 }
21136 arg3 = static_cast< bool >(val3);
21137 }
21138 {
21139 PyThreadState* __tstate = wxPyBeginAllowThreads();
21140 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21141 wxPyEndAllowThreads(__tstate);
21142 if (PyErr_Occurred()) SWIG_fail;
21143 }
21144 resultobj = SWIG_Py_Void();
21145 return resultobj;
21146 fail:
21147 return NULL;
21148 }
21149
21150
21151 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21152 PyObject *obj;
21153 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21154 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21155 return SWIG_Py_Void();
21156 }
21157
21158 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21159 return SWIG_Python_InitShadowInstance(args);
21160 }
21161
21162 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21163 PyObject *resultobj = 0;
21164 wxEventType result;
21165
21166 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21167 {
21168 PyThreadState* __tstate = wxPyBeginAllowThreads();
21169 result = (wxEventType)wxNewEventType();
21170 wxPyEndAllowThreads(__tstate);
21171 if (PyErr_Occurred()) SWIG_fail;
21172 }
21173 resultobj = SWIG_From_int(static_cast< int >(result));
21174 return resultobj;
21175 fail:
21176 return NULL;
21177 }
21178
21179
21180 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21181 PyObject *resultobj = 0;
21182 wxEvent *arg1 = (wxEvent *) 0 ;
21183 void *argp1 = 0 ;
21184 int res1 = 0 ;
21185 PyObject *swig_obj[1] ;
21186
21187 if (!args) SWIG_fail;
21188 swig_obj[0] = args;
21189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21190 if (!SWIG_IsOK(res1)) {
21191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21192 }
21193 arg1 = reinterpret_cast< wxEvent * >(argp1);
21194 {
21195 PyThreadState* __tstate = wxPyBeginAllowThreads();
21196 delete arg1;
21197
21198 wxPyEndAllowThreads(__tstate);
21199 if (PyErr_Occurred()) SWIG_fail;
21200 }
21201 resultobj = SWIG_Py_Void();
21202 return resultobj;
21203 fail:
21204 return NULL;
21205 }
21206
21207
21208 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21209 PyObject *resultobj = 0;
21210 wxEvent *arg1 = (wxEvent *) 0 ;
21211 wxEventType arg2 ;
21212 void *argp1 = 0 ;
21213 int res1 = 0 ;
21214 int val2 ;
21215 int ecode2 = 0 ;
21216 PyObject * obj0 = 0 ;
21217 PyObject * obj1 = 0 ;
21218 char * kwnames[] = {
21219 (char *) "self",(char *) "typ", NULL
21220 };
21221
21222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21224 if (!SWIG_IsOK(res1)) {
21225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21226 }
21227 arg1 = reinterpret_cast< wxEvent * >(argp1);
21228 ecode2 = SWIG_AsVal_int(obj1, &val2);
21229 if (!SWIG_IsOK(ecode2)) {
21230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21231 }
21232 arg2 = static_cast< wxEventType >(val2);
21233 {
21234 PyThreadState* __tstate = wxPyBeginAllowThreads();
21235 (arg1)->SetEventType(arg2);
21236 wxPyEndAllowThreads(__tstate);
21237 if (PyErr_Occurred()) SWIG_fail;
21238 }
21239 resultobj = SWIG_Py_Void();
21240 return resultobj;
21241 fail:
21242 return NULL;
21243 }
21244
21245
21246 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21247 PyObject *resultobj = 0;
21248 wxEvent *arg1 = (wxEvent *) 0 ;
21249 wxEventType result;
21250 void *argp1 = 0 ;
21251 int res1 = 0 ;
21252 PyObject *swig_obj[1] ;
21253
21254 if (!args) SWIG_fail;
21255 swig_obj[0] = args;
21256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21257 if (!SWIG_IsOK(res1)) {
21258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21259 }
21260 arg1 = reinterpret_cast< wxEvent * >(argp1);
21261 {
21262 PyThreadState* __tstate = wxPyBeginAllowThreads();
21263 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21264 wxPyEndAllowThreads(__tstate);
21265 if (PyErr_Occurred()) SWIG_fail;
21266 }
21267 resultobj = SWIG_From_int(static_cast< int >(result));
21268 return resultobj;
21269 fail:
21270 return NULL;
21271 }
21272
21273
21274 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21275 PyObject *resultobj = 0;
21276 wxEvent *arg1 = (wxEvent *) 0 ;
21277 wxObject *result = 0 ;
21278 void *argp1 = 0 ;
21279 int res1 = 0 ;
21280 PyObject *swig_obj[1] ;
21281
21282 if (!args) SWIG_fail;
21283 swig_obj[0] = args;
21284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21285 if (!SWIG_IsOK(res1)) {
21286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21287 }
21288 arg1 = reinterpret_cast< wxEvent * >(argp1);
21289 {
21290 PyThreadState* __tstate = wxPyBeginAllowThreads();
21291 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21292 wxPyEndAllowThreads(__tstate);
21293 if (PyErr_Occurred()) SWIG_fail;
21294 }
21295 {
21296 resultobj = wxPyMake_wxObject(result, (bool)0);
21297 }
21298 return resultobj;
21299 fail:
21300 return NULL;
21301 }
21302
21303
21304 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21305 PyObject *resultobj = 0;
21306 wxEvent *arg1 = (wxEvent *) 0 ;
21307 wxObject *arg2 = (wxObject *) 0 ;
21308 void *argp1 = 0 ;
21309 int res1 = 0 ;
21310 void *argp2 = 0 ;
21311 int res2 = 0 ;
21312 PyObject * obj0 = 0 ;
21313 PyObject * obj1 = 0 ;
21314 char * kwnames[] = {
21315 (char *) "self",(char *) "obj", NULL
21316 };
21317
21318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21320 if (!SWIG_IsOK(res1)) {
21321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21322 }
21323 arg1 = reinterpret_cast< wxEvent * >(argp1);
21324 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21325 if (!SWIG_IsOK(res2)) {
21326 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21327 }
21328 arg2 = reinterpret_cast< wxObject * >(argp2);
21329 {
21330 PyThreadState* __tstate = wxPyBeginAllowThreads();
21331 (arg1)->SetEventObject(arg2);
21332 wxPyEndAllowThreads(__tstate);
21333 if (PyErr_Occurred()) SWIG_fail;
21334 }
21335 resultobj = SWIG_Py_Void();
21336 return resultobj;
21337 fail:
21338 return NULL;
21339 }
21340
21341
21342 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21343 PyObject *resultobj = 0;
21344 wxEvent *arg1 = (wxEvent *) 0 ;
21345 long result;
21346 void *argp1 = 0 ;
21347 int res1 = 0 ;
21348 PyObject *swig_obj[1] ;
21349
21350 if (!args) SWIG_fail;
21351 swig_obj[0] = args;
21352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21353 if (!SWIG_IsOK(res1)) {
21354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21355 }
21356 arg1 = reinterpret_cast< wxEvent * >(argp1);
21357 {
21358 PyThreadState* __tstate = wxPyBeginAllowThreads();
21359 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21360 wxPyEndAllowThreads(__tstate);
21361 if (PyErr_Occurred()) SWIG_fail;
21362 }
21363 resultobj = SWIG_From_long(static_cast< long >(result));
21364 return resultobj;
21365 fail:
21366 return NULL;
21367 }
21368
21369
21370 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21371 PyObject *resultobj = 0;
21372 wxEvent *arg1 = (wxEvent *) 0 ;
21373 long arg2 = (long) 0 ;
21374 void *argp1 = 0 ;
21375 int res1 = 0 ;
21376 long val2 ;
21377 int ecode2 = 0 ;
21378 PyObject * obj0 = 0 ;
21379 PyObject * obj1 = 0 ;
21380 char * kwnames[] = {
21381 (char *) "self",(char *) "ts", NULL
21382 };
21383
21384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21386 if (!SWIG_IsOK(res1)) {
21387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21388 }
21389 arg1 = reinterpret_cast< wxEvent * >(argp1);
21390 if (obj1) {
21391 ecode2 = SWIG_AsVal_long(obj1, &val2);
21392 if (!SWIG_IsOK(ecode2)) {
21393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21394 }
21395 arg2 = static_cast< long >(val2);
21396 }
21397 {
21398 PyThreadState* __tstate = wxPyBeginAllowThreads();
21399 (arg1)->SetTimestamp(arg2);
21400 wxPyEndAllowThreads(__tstate);
21401 if (PyErr_Occurred()) SWIG_fail;
21402 }
21403 resultobj = SWIG_Py_Void();
21404 return resultobj;
21405 fail:
21406 return NULL;
21407 }
21408
21409
21410 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21411 PyObject *resultobj = 0;
21412 wxEvent *arg1 = (wxEvent *) 0 ;
21413 int result;
21414 void *argp1 = 0 ;
21415 int res1 = 0 ;
21416 PyObject *swig_obj[1] ;
21417
21418 if (!args) SWIG_fail;
21419 swig_obj[0] = args;
21420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21421 if (!SWIG_IsOK(res1)) {
21422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21423 }
21424 arg1 = reinterpret_cast< wxEvent * >(argp1);
21425 {
21426 PyThreadState* __tstate = wxPyBeginAllowThreads();
21427 result = (int)((wxEvent const *)arg1)->GetId();
21428 wxPyEndAllowThreads(__tstate);
21429 if (PyErr_Occurred()) SWIG_fail;
21430 }
21431 resultobj = SWIG_From_int(static_cast< int >(result));
21432 return resultobj;
21433 fail:
21434 return NULL;
21435 }
21436
21437
21438 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21439 PyObject *resultobj = 0;
21440 wxEvent *arg1 = (wxEvent *) 0 ;
21441 int arg2 ;
21442 void *argp1 = 0 ;
21443 int res1 = 0 ;
21444 int val2 ;
21445 int ecode2 = 0 ;
21446 PyObject * obj0 = 0 ;
21447 PyObject * obj1 = 0 ;
21448 char * kwnames[] = {
21449 (char *) "self",(char *) "Id", NULL
21450 };
21451
21452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21454 if (!SWIG_IsOK(res1)) {
21455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21456 }
21457 arg1 = reinterpret_cast< wxEvent * >(argp1);
21458 ecode2 = SWIG_AsVal_int(obj1, &val2);
21459 if (!SWIG_IsOK(ecode2)) {
21460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21461 }
21462 arg2 = static_cast< int >(val2);
21463 {
21464 PyThreadState* __tstate = wxPyBeginAllowThreads();
21465 (arg1)->SetId(arg2);
21466 wxPyEndAllowThreads(__tstate);
21467 if (PyErr_Occurred()) SWIG_fail;
21468 }
21469 resultobj = SWIG_Py_Void();
21470 return resultobj;
21471 fail:
21472 return NULL;
21473 }
21474
21475
21476 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21477 PyObject *resultobj = 0;
21478 wxEvent *arg1 = (wxEvent *) 0 ;
21479 bool result;
21480 void *argp1 = 0 ;
21481 int res1 = 0 ;
21482 PyObject *swig_obj[1] ;
21483
21484 if (!args) SWIG_fail;
21485 swig_obj[0] = args;
21486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21487 if (!SWIG_IsOK(res1)) {
21488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21489 }
21490 arg1 = reinterpret_cast< wxEvent * >(argp1);
21491 {
21492 PyThreadState* __tstate = wxPyBeginAllowThreads();
21493 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21494 wxPyEndAllowThreads(__tstate);
21495 if (PyErr_Occurred()) SWIG_fail;
21496 }
21497 {
21498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21499 }
21500 return resultobj;
21501 fail:
21502 return NULL;
21503 }
21504
21505
21506 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21507 PyObject *resultobj = 0;
21508 wxEvent *arg1 = (wxEvent *) 0 ;
21509 bool arg2 = (bool) true ;
21510 void *argp1 = 0 ;
21511 int res1 = 0 ;
21512 bool val2 ;
21513 int ecode2 = 0 ;
21514 PyObject * obj0 = 0 ;
21515 PyObject * obj1 = 0 ;
21516 char * kwnames[] = {
21517 (char *) "self",(char *) "skip", NULL
21518 };
21519
21520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21522 if (!SWIG_IsOK(res1)) {
21523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21524 }
21525 arg1 = reinterpret_cast< wxEvent * >(argp1);
21526 if (obj1) {
21527 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21528 if (!SWIG_IsOK(ecode2)) {
21529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21530 }
21531 arg2 = static_cast< bool >(val2);
21532 }
21533 {
21534 PyThreadState* __tstate = wxPyBeginAllowThreads();
21535 (arg1)->Skip(arg2);
21536 wxPyEndAllowThreads(__tstate);
21537 if (PyErr_Occurred()) SWIG_fail;
21538 }
21539 resultobj = SWIG_Py_Void();
21540 return resultobj;
21541 fail:
21542 return NULL;
21543 }
21544
21545
21546 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21547 PyObject *resultobj = 0;
21548 wxEvent *arg1 = (wxEvent *) 0 ;
21549 bool result;
21550 void *argp1 = 0 ;
21551 int res1 = 0 ;
21552 PyObject *swig_obj[1] ;
21553
21554 if (!args) SWIG_fail;
21555 swig_obj[0] = args;
21556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21557 if (!SWIG_IsOK(res1)) {
21558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21559 }
21560 arg1 = reinterpret_cast< wxEvent * >(argp1);
21561 {
21562 PyThreadState* __tstate = wxPyBeginAllowThreads();
21563 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21564 wxPyEndAllowThreads(__tstate);
21565 if (PyErr_Occurred()) SWIG_fail;
21566 }
21567 {
21568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21569 }
21570 return resultobj;
21571 fail:
21572 return NULL;
21573 }
21574
21575
21576 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21577 PyObject *resultobj = 0;
21578 wxEvent *arg1 = (wxEvent *) 0 ;
21579 bool result;
21580 void *argp1 = 0 ;
21581 int res1 = 0 ;
21582 PyObject *swig_obj[1] ;
21583
21584 if (!args) SWIG_fail;
21585 swig_obj[0] = args;
21586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21587 if (!SWIG_IsOK(res1)) {
21588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21589 }
21590 arg1 = reinterpret_cast< wxEvent * >(argp1);
21591 {
21592 PyThreadState* __tstate = wxPyBeginAllowThreads();
21593 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21594 wxPyEndAllowThreads(__tstate);
21595 if (PyErr_Occurred()) SWIG_fail;
21596 }
21597 {
21598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21599 }
21600 return resultobj;
21601 fail:
21602 return NULL;
21603 }
21604
21605
21606 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21607 PyObject *resultobj = 0;
21608 wxEvent *arg1 = (wxEvent *) 0 ;
21609 int result;
21610 void *argp1 = 0 ;
21611 int res1 = 0 ;
21612 PyObject *swig_obj[1] ;
21613
21614 if (!args) SWIG_fail;
21615 swig_obj[0] = args;
21616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21617 if (!SWIG_IsOK(res1)) {
21618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21619 }
21620 arg1 = reinterpret_cast< wxEvent * >(argp1);
21621 {
21622 PyThreadState* __tstate = wxPyBeginAllowThreads();
21623 result = (int)(arg1)->StopPropagation();
21624 wxPyEndAllowThreads(__tstate);
21625 if (PyErr_Occurred()) SWIG_fail;
21626 }
21627 resultobj = SWIG_From_int(static_cast< int >(result));
21628 return resultobj;
21629 fail:
21630 return NULL;
21631 }
21632
21633
21634 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21635 PyObject *resultobj = 0;
21636 wxEvent *arg1 = (wxEvent *) 0 ;
21637 int arg2 ;
21638 void *argp1 = 0 ;
21639 int res1 = 0 ;
21640 int val2 ;
21641 int ecode2 = 0 ;
21642 PyObject * obj0 = 0 ;
21643 PyObject * obj1 = 0 ;
21644 char * kwnames[] = {
21645 (char *) "self",(char *) "propagationLevel", NULL
21646 };
21647
21648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21650 if (!SWIG_IsOK(res1)) {
21651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21652 }
21653 arg1 = reinterpret_cast< wxEvent * >(argp1);
21654 ecode2 = SWIG_AsVal_int(obj1, &val2);
21655 if (!SWIG_IsOK(ecode2)) {
21656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21657 }
21658 arg2 = static_cast< int >(val2);
21659 {
21660 PyThreadState* __tstate = wxPyBeginAllowThreads();
21661 (arg1)->ResumePropagation(arg2);
21662 wxPyEndAllowThreads(__tstate);
21663 if (PyErr_Occurred()) SWIG_fail;
21664 }
21665 resultobj = SWIG_Py_Void();
21666 return resultobj;
21667 fail:
21668 return NULL;
21669 }
21670
21671
21672 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21673 PyObject *resultobj = 0;
21674 wxEvent *arg1 = (wxEvent *) 0 ;
21675 wxEvent *result = 0 ;
21676 void *argp1 = 0 ;
21677 int res1 = 0 ;
21678 PyObject *swig_obj[1] ;
21679
21680 if (!args) SWIG_fail;
21681 swig_obj[0] = args;
21682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21683 if (!SWIG_IsOK(res1)) {
21684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21685 }
21686 arg1 = reinterpret_cast< wxEvent * >(argp1);
21687 {
21688 PyThreadState* __tstate = wxPyBeginAllowThreads();
21689 result = (wxEvent *)(arg1)->Clone();
21690 wxPyEndAllowThreads(__tstate);
21691 if (PyErr_Occurred()) SWIG_fail;
21692 }
21693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21694 return resultobj;
21695 fail:
21696 return NULL;
21697 }
21698
21699
21700 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21701 PyObject *obj;
21702 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21703 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21704 return SWIG_Py_Void();
21705 }
21706
21707 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21708 PyObject *resultobj = 0;
21709 wxEvent *arg1 = 0 ;
21710 wxPropagationDisabler *result = 0 ;
21711 void *argp1 = 0 ;
21712 int res1 = 0 ;
21713 PyObject * obj0 = 0 ;
21714 char * kwnames[] = {
21715 (char *) "event", NULL
21716 };
21717
21718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21719 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21720 if (!SWIG_IsOK(res1)) {
21721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21722 }
21723 if (!argp1) {
21724 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21725 }
21726 arg1 = reinterpret_cast< wxEvent * >(argp1);
21727 {
21728 PyThreadState* __tstate = wxPyBeginAllowThreads();
21729 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21730 wxPyEndAllowThreads(__tstate);
21731 if (PyErr_Occurred()) SWIG_fail;
21732 }
21733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21734 return resultobj;
21735 fail:
21736 return NULL;
21737 }
21738
21739
21740 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21741 PyObject *resultobj = 0;
21742 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21743 void *argp1 = 0 ;
21744 int res1 = 0 ;
21745 PyObject *swig_obj[1] ;
21746
21747 if (!args) SWIG_fail;
21748 swig_obj[0] = args;
21749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21750 if (!SWIG_IsOK(res1)) {
21751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21752 }
21753 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21754 {
21755 PyThreadState* __tstate = wxPyBeginAllowThreads();
21756 delete arg1;
21757
21758 wxPyEndAllowThreads(__tstate);
21759 if (PyErr_Occurred()) SWIG_fail;
21760 }
21761 resultobj = SWIG_Py_Void();
21762 return resultobj;
21763 fail:
21764 return NULL;
21765 }
21766
21767
21768 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21769 PyObject *obj;
21770 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21771 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21772 return SWIG_Py_Void();
21773 }
21774
21775 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21776 return SWIG_Python_InitShadowInstance(args);
21777 }
21778
21779 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21780 PyObject *resultobj = 0;
21781 wxEvent *arg1 = 0 ;
21782 wxPropagateOnce *result = 0 ;
21783 void *argp1 = 0 ;
21784 int res1 = 0 ;
21785 PyObject * obj0 = 0 ;
21786 char * kwnames[] = {
21787 (char *) "event", NULL
21788 };
21789
21790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21791 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21792 if (!SWIG_IsOK(res1)) {
21793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21794 }
21795 if (!argp1) {
21796 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21797 }
21798 arg1 = reinterpret_cast< wxEvent * >(argp1);
21799 {
21800 PyThreadState* __tstate = wxPyBeginAllowThreads();
21801 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21802 wxPyEndAllowThreads(__tstate);
21803 if (PyErr_Occurred()) SWIG_fail;
21804 }
21805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21806 return resultobj;
21807 fail:
21808 return NULL;
21809 }
21810
21811
21812 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21813 PyObject *resultobj = 0;
21814 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21815 void *argp1 = 0 ;
21816 int res1 = 0 ;
21817 PyObject *swig_obj[1] ;
21818
21819 if (!args) SWIG_fail;
21820 swig_obj[0] = args;
21821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21822 if (!SWIG_IsOK(res1)) {
21823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21824 }
21825 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21826 {
21827 PyThreadState* __tstate = wxPyBeginAllowThreads();
21828 delete arg1;
21829
21830 wxPyEndAllowThreads(__tstate);
21831 if (PyErr_Occurred()) SWIG_fail;
21832 }
21833 resultobj = SWIG_Py_Void();
21834 return resultobj;
21835 fail:
21836 return NULL;
21837 }
21838
21839
21840 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21841 PyObject *obj;
21842 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21843 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21844 return SWIG_Py_Void();
21845 }
21846
21847 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21848 return SWIG_Python_InitShadowInstance(args);
21849 }
21850
21851 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21852 PyObject *resultobj = 0;
21853 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21854 int arg2 = (int) 0 ;
21855 wxCommandEvent *result = 0 ;
21856 int val1 ;
21857 int ecode1 = 0 ;
21858 int val2 ;
21859 int ecode2 = 0 ;
21860 PyObject * obj0 = 0 ;
21861 PyObject * obj1 = 0 ;
21862 char * kwnames[] = {
21863 (char *) "commandType",(char *) "winid", NULL
21864 };
21865
21866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21867 if (obj0) {
21868 ecode1 = SWIG_AsVal_int(obj0, &val1);
21869 if (!SWIG_IsOK(ecode1)) {
21870 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21871 }
21872 arg1 = static_cast< wxEventType >(val1);
21873 }
21874 if (obj1) {
21875 ecode2 = SWIG_AsVal_int(obj1, &val2);
21876 if (!SWIG_IsOK(ecode2)) {
21877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21878 }
21879 arg2 = static_cast< int >(val2);
21880 }
21881 {
21882 PyThreadState* __tstate = wxPyBeginAllowThreads();
21883 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21884 wxPyEndAllowThreads(__tstate);
21885 if (PyErr_Occurred()) SWIG_fail;
21886 }
21887 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21888 return resultobj;
21889 fail:
21890 return NULL;
21891 }
21892
21893
21894 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21895 PyObject *resultobj = 0;
21896 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21897 int result;
21898 void *argp1 = 0 ;
21899 int res1 = 0 ;
21900 PyObject *swig_obj[1] ;
21901
21902 if (!args) SWIG_fail;
21903 swig_obj[0] = args;
21904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21905 if (!SWIG_IsOK(res1)) {
21906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21907 }
21908 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21909 {
21910 PyThreadState* __tstate = wxPyBeginAllowThreads();
21911 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21912 wxPyEndAllowThreads(__tstate);
21913 if (PyErr_Occurred()) SWIG_fail;
21914 }
21915 resultobj = SWIG_From_int(static_cast< int >(result));
21916 return resultobj;
21917 fail:
21918 return NULL;
21919 }
21920
21921
21922 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21923 PyObject *resultobj = 0;
21924 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21925 wxString *arg2 = 0 ;
21926 void *argp1 = 0 ;
21927 int res1 = 0 ;
21928 bool temp2 = false ;
21929 PyObject * obj0 = 0 ;
21930 PyObject * obj1 = 0 ;
21931 char * kwnames[] = {
21932 (char *) "self",(char *) "s", NULL
21933 };
21934
21935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21937 if (!SWIG_IsOK(res1)) {
21938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21939 }
21940 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21941 {
21942 arg2 = wxString_in_helper(obj1);
21943 if (arg2 == NULL) SWIG_fail;
21944 temp2 = true;
21945 }
21946 {
21947 PyThreadState* __tstate = wxPyBeginAllowThreads();
21948 (arg1)->SetString((wxString const &)*arg2);
21949 wxPyEndAllowThreads(__tstate);
21950 if (PyErr_Occurred()) SWIG_fail;
21951 }
21952 resultobj = SWIG_Py_Void();
21953 {
21954 if (temp2)
21955 delete arg2;
21956 }
21957 return resultobj;
21958 fail:
21959 {
21960 if (temp2)
21961 delete arg2;
21962 }
21963 return NULL;
21964 }
21965
21966
21967 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21968 PyObject *resultobj = 0;
21969 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21970 wxString result;
21971 void *argp1 = 0 ;
21972 int res1 = 0 ;
21973 PyObject *swig_obj[1] ;
21974
21975 if (!args) SWIG_fail;
21976 swig_obj[0] = args;
21977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21978 if (!SWIG_IsOK(res1)) {
21979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21980 }
21981 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21982 {
21983 PyThreadState* __tstate = wxPyBeginAllowThreads();
21984 result = ((wxCommandEvent const *)arg1)->GetString();
21985 wxPyEndAllowThreads(__tstate);
21986 if (PyErr_Occurred()) SWIG_fail;
21987 }
21988 {
21989 #if wxUSE_UNICODE
21990 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21991 #else
21992 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21993 #endif
21994 }
21995 return resultobj;
21996 fail:
21997 return NULL;
21998 }
21999
22000
22001 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22002 PyObject *resultobj = 0;
22003 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22004 bool result;
22005 void *argp1 = 0 ;
22006 int res1 = 0 ;
22007 PyObject *swig_obj[1] ;
22008
22009 if (!args) SWIG_fail;
22010 swig_obj[0] = args;
22011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22012 if (!SWIG_IsOK(res1)) {
22013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22014 }
22015 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22016 {
22017 PyThreadState* __tstate = wxPyBeginAllowThreads();
22018 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
22019 wxPyEndAllowThreads(__tstate);
22020 if (PyErr_Occurred()) SWIG_fail;
22021 }
22022 {
22023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22024 }
22025 return resultobj;
22026 fail:
22027 return NULL;
22028 }
22029
22030
22031 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22032 PyObject *resultobj = 0;
22033 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22034 bool result;
22035 void *argp1 = 0 ;
22036 int res1 = 0 ;
22037 PyObject *swig_obj[1] ;
22038
22039 if (!args) SWIG_fail;
22040 swig_obj[0] = args;
22041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22042 if (!SWIG_IsOK(res1)) {
22043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22044 }
22045 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22046 {
22047 PyThreadState* __tstate = wxPyBeginAllowThreads();
22048 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
22049 wxPyEndAllowThreads(__tstate);
22050 if (PyErr_Occurred()) SWIG_fail;
22051 }
22052 {
22053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22054 }
22055 return resultobj;
22056 fail:
22057 return NULL;
22058 }
22059
22060
22061 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22062 PyObject *resultobj = 0;
22063 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22064 long arg2 ;
22065 void *argp1 = 0 ;
22066 int res1 = 0 ;
22067 long val2 ;
22068 int ecode2 = 0 ;
22069 PyObject * obj0 = 0 ;
22070 PyObject * obj1 = 0 ;
22071 char * kwnames[] = {
22072 (char *) "self",(char *) "extraLong", NULL
22073 };
22074
22075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
22076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22077 if (!SWIG_IsOK(res1)) {
22078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22079 }
22080 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22081 ecode2 = SWIG_AsVal_long(obj1, &val2);
22082 if (!SWIG_IsOK(ecode2)) {
22083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
22084 }
22085 arg2 = static_cast< long >(val2);
22086 {
22087 PyThreadState* __tstate = wxPyBeginAllowThreads();
22088 (arg1)->SetExtraLong(arg2);
22089 wxPyEndAllowThreads(__tstate);
22090 if (PyErr_Occurred()) SWIG_fail;
22091 }
22092 resultobj = SWIG_Py_Void();
22093 return resultobj;
22094 fail:
22095 return NULL;
22096 }
22097
22098
22099 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22100 PyObject *resultobj = 0;
22101 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22102 long result;
22103 void *argp1 = 0 ;
22104 int res1 = 0 ;
22105 PyObject *swig_obj[1] ;
22106
22107 if (!args) SWIG_fail;
22108 swig_obj[0] = args;
22109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22110 if (!SWIG_IsOK(res1)) {
22111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22112 }
22113 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22114 {
22115 PyThreadState* __tstate = wxPyBeginAllowThreads();
22116 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22117 wxPyEndAllowThreads(__tstate);
22118 if (PyErr_Occurred()) SWIG_fail;
22119 }
22120 resultobj = SWIG_From_long(static_cast< long >(result));
22121 return resultobj;
22122 fail:
22123 return NULL;
22124 }
22125
22126
22127 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22128 PyObject *resultobj = 0;
22129 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22130 int arg2 ;
22131 void *argp1 = 0 ;
22132 int res1 = 0 ;
22133 int val2 ;
22134 int ecode2 = 0 ;
22135 PyObject * obj0 = 0 ;
22136 PyObject * obj1 = 0 ;
22137 char * kwnames[] = {
22138 (char *) "self",(char *) "i", NULL
22139 };
22140
22141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22143 if (!SWIG_IsOK(res1)) {
22144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22145 }
22146 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22147 ecode2 = SWIG_AsVal_int(obj1, &val2);
22148 if (!SWIG_IsOK(ecode2)) {
22149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22150 }
22151 arg2 = static_cast< int >(val2);
22152 {
22153 PyThreadState* __tstate = wxPyBeginAllowThreads();
22154 (arg1)->SetInt(arg2);
22155 wxPyEndAllowThreads(__tstate);
22156 if (PyErr_Occurred()) SWIG_fail;
22157 }
22158 resultobj = SWIG_Py_Void();
22159 return resultobj;
22160 fail:
22161 return NULL;
22162 }
22163
22164
22165 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22166 PyObject *resultobj = 0;
22167 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22168 int result;
22169 void *argp1 = 0 ;
22170 int res1 = 0 ;
22171 PyObject *swig_obj[1] ;
22172
22173 if (!args) SWIG_fail;
22174 swig_obj[0] = args;
22175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22176 if (!SWIG_IsOK(res1)) {
22177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22178 }
22179 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22180 {
22181 PyThreadState* __tstate = wxPyBeginAllowThreads();
22182 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22183 wxPyEndAllowThreads(__tstate);
22184 if (PyErr_Occurred()) SWIG_fail;
22185 }
22186 resultobj = SWIG_From_int(static_cast< int >(result));
22187 return resultobj;
22188 fail:
22189 return NULL;
22190 }
22191
22192
22193 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22194 PyObject *resultobj = 0;
22195 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22196 PyObject *result = 0 ;
22197 void *argp1 = 0 ;
22198 int res1 = 0 ;
22199 PyObject *swig_obj[1] ;
22200
22201 if (!args) SWIG_fail;
22202 swig_obj[0] = args;
22203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22204 if (!SWIG_IsOK(res1)) {
22205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22206 }
22207 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22208 {
22209 PyThreadState* __tstate = wxPyBeginAllowThreads();
22210 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22211 wxPyEndAllowThreads(__tstate);
22212 if (PyErr_Occurred()) SWIG_fail;
22213 }
22214 resultobj = result;
22215 return resultobj;
22216 fail:
22217 return NULL;
22218 }
22219
22220
22221 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22222 PyObject *resultobj = 0;
22223 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22224 PyObject *arg2 = (PyObject *) 0 ;
22225 void *argp1 = 0 ;
22226 int res1 = 0 ;
22227 PyObject * obj0 = 0 ;
22228 PyObject * obj1 = 0 ;
22229 char * kwnames[] = {
22230 (char *) "self",(char *) "clientData", NULL
22231 };
22232
22233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22235 if (!SWIG_IsOK(res1)) {
22236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22237 }
22238 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22239 arg2 = obj1;
22240 {
22241 PyThreadState* __tstate = wxPyBeginAllowThreads();
22242 wxCommandEvent_SetClientData(arg1,arg2);
22243 wxPyEndAllowThreads(__tstate);
22244 if (PyErr_Occurred()) SWIG_fail;
22245 }
22246 resultobj = SWIG_Py_Void();
22247 return resultobj;
22248 fail:
22249 return NULL;
22250 }
22251
22252
22253 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22254 PyObject *resultobj = 0;
22255 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22256 wxEvent *result = 0 ;
22257 void *argp1 = 0 ;
22258 int res1 = 0 ;
22259 PyObject *swig_obj[1] ;
22260
22261 if (!args) SWIG_fail;
22262 swig_obj[0] = args;
22263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22264 if (!SWIG_IsOK(res1)) {
22265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22266 }
22267 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22268 {
22269 PyThreadState* __tstate = wxPyBeginAllowThreads();
22270 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22271 wxPyEndAllowThreads(__tstate);
22272 if (PyErr_Occurred()) SWIG_fail;
22273 }
22274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22275 return resultobj;
22276 fail:
22277 return NULL;
22278 }
22279
22280
22281 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22282 PyObject *obj;
22283 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22284 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22285 return SWIG_Py_Void();
22286 }
22287
22288 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22289 return SWIG_Python_InitShadowInstance(args);
22290 }
22291
22292 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22293 PyObject *resultobj = 0;
22294 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22295 int arg2 = (int) 0 ;
22296 wxNotifyEvent *result = 0 ;
22297 int val1 ;
22298 int ecode1 = 0 ;
22299 int val2 ;
22300 int ecode2 = 0 ;
22301 PyObject * obj0 = 0 ;
22302 PyObject * obj1 = 0 ;
22303 char * kwnames[] = {
22304 (char *) "commandType",(char *) "winid", NULL
22305 };
22306
22307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22308 if (obj0) {
22309 ecode1 = SWIG_AsVal_int(obj0, &val1);
22310 if (!SWIG_IsOK(ecode1)) {
22311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22312 }
22313 arg1 = static_cast< wxEventType >(val1);
22314 }
22315 if (obj1) {
22316 ecode2 = SWIG_AsVal_int(obj1, &val2);
22317 if (!SWIG_IsOK(ecode2)) {
22318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22319 }
22320 arg2 = static_cast< int >(val2);
22321 }
22322 {
22323 PyThreadState* __tstate = wxPyBeginAllowThreads();
22324 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22325 wxPyEndAllowThreads(__tstate);
22326 if (PyErr_Occurred()) SWIG_fail;
22327 }
22328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22329 return resultobj;
22330 fail:
22331 return NULL;
22332 }
22333
22334
22335 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22336 PyObject *resultobj = 0;
22337 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22338 void *argp1 = 0 ;
22339 int res1 = 0 ;
22340 PyObject *swig_obj[1] ;
22341
22342 if (!args) SWIG_fail;
22343 swig_obj[0] = args;
22344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22345 if (!SWIG_IsOK(res1)) {
22346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22347 }
22348 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22349 {
22350 PyThreadState* __tstate = wxPyBeginAllowThreads();
22351 (arg1)->Veto();
22352 wxPyEndAllowThreads(__tstate);
22353 if (PyErr_Occurred()) SWIG_fail;
22354 }
22355 resultobj = SWIG_Py_Void();
22356 return resultobj;
22357 fail:
22358 return NULL;
22359 }
22360
22361
22362 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22363 PyObject *resultobj = 0;
22364 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22365 void *argp1 = 0 ;
22366 int res1 = 0 ;
22367 PyObject *swig_obj[1] ;
22368
22369 if (!args) SWIG_fail;
22370 swig_obj[0] = args;
22371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22372 if (!SWIG_IsOK(res1)) {
22373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22374 }
22375 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22376 {
22377 PyThreadState* __tstate = wxPyBeginAllowThreads();
22378 (arg1)->Allow();
22379 wxPyEndAllowThreads(__tstate);
22380 if (PyErr_Occurred()) SWIG_fail;
22381 }
22382 resultobj = SWIG_Py_Void();
22383 return resultobj;
22384 fail:
22385 return NULL;
22386 }
22387
22388
22389 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22390 PyObject *resultobj = 0;
22391 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22392 bool result;
22393 void *argp1 = 0 ;
22394 int res1 = 0 ;
22395 PyObject *swig_obj[1] ;
22396
22397 if (!args) SWIG_fail;
22398 swig_obj[0] = args;
22399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22400 if (!SWIG_IsOK(res1)) {
22401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22402 }
22403 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22404 {
22405 PyThreadState* __tstate = wxPyBeginAllowThreads();
22406 result = (bool)(arg1)->IsAllowed();
22407 wxPyEndAllowThreads(__tstate);
22408 if (PyErr_Occurred()) SWIG_fail;
22409 }
22410 {
22411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22412 }
22413 return resultobj;
22414 fail:
22415 return NULL;
22416 }
22417
22418
22419 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22420 PyObject *obj;
22421 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22422 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22423 return SWIG_Py_Void();
22424 }
22425
22426 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22427 return SWIG_Python_InitShadowInstance(args);
22428 }
22429
22430 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22431 PyObject *resultobj = 0;
22432 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22433 int arg2 = (int) 0 ;
22434 int arg3 = (int) 0 ;
22435 int arg4 = (int) 0 ;
22436 wxScrollEvent *result = 0 ;
22437 int val1 ;
22438 int ecode1 = 0 ;
22439 int val2 ;
22440 int ecode2 = 0 ;
22441 int val3 ;
22442 int ecode3 = 0 ;
22443 int val4 ;
22444 int ecode4 = 0 ;
22445 PyObject * obj0 = 0 ;
22446 PyObject * obj1 = 0 ;
22447 PyObject * obj2 = 0 ;
22448 PyObject * obj3 = 0 ;
22449 char * kwnames[] = {
22450 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22451 };
22452
22453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22454 if (obj0) {
22455 ecode1 = SWIG_AsVal_int(obj0, &val1);
22456 if (!SWIG_IsOK(ecode1)) {
22457 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22458 }
22459 arg1 = static_cast< wxEventType >(val1);
22460 }
22461 if (obj1) {
22462 ecode2 = SWIG_AsVal_int(obj1, &val2);
22463 if (!SWIG_IsOK(ecode2)) {
22464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22465 }
22466 arg2 = static_cast< int >(val2);
22467 }
22468 if (obj2) {
22469 ecode3 = SWIG_AsVal_int(obj2, &val3);
22470 if (!SWIG_IsOK(ecode3)) {
22471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22472 }
22473 arg3 = static_cast< int >(val3);
22474 }
22475 if (obj3) {
22476 ecode4 = SWIG_AsVal_int(obj3, &val4);
22477 if (!SWIG_IsOK(ecode4)) {
22478 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22479 }
22480 arg4 = static_cast< int >(val4);
22481 }
22482 {
22483 PyThreadState* __tstate = wxPyBeginAllowThreads();
22484 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22485 wxPyEndAllowThreads(__tstate);
22486 if (PyErr_Occurred()) SWIG_fail;
22487 }
22488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22489 return resultobj;
22490 fail:
22491 return NULL;
22492 }
22493
22494
22495 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22496 PyObject *resultobj = 0;
22497 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22498 int result;
22499 void *argp1 = 0 ;
22500 int res1 = 0 ;
22501 PyObject *swig_obj[1] ;
22502
22503 if (!args) SWIG_fail;
22504 swig_obj[0] = args;
22505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22506 if (!SWIG_IsOK(res1)) {
22507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22508 }
22509 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22510 {
22511 PyThreadState* __tstate = wxPyBeginAllowThreads();
22512 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22513 wxPyEndAllowThreads(__tstate);
22514 if (PyErr_Occurred()) SWIG_fail;
22515 }
22516 resultobj = SWIG_From_int(static_cast< int >(result));
22517 return resultobj;
22518 fail:
22519 return NULL;
22520 }
22521
22522
22523 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22524 PyObject *resultobj = 0;
22525 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22526 int result;
22527 void *argp1 = 0 ;
22528 int res1 = 0 ;
22529 PyObject *swig_obj[1] ;
22530
22531 if (!args) SWIG_fail;
22532 swig_obj[0] = args;
22533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22534 if (!SWIG_IsOK(res1)) {
22535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22536 }
22537 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22538 {
22539 PyThreadState* __tstate = wxPyBeginAllowThreads();
22540 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22541 wxPyEndAllowThreads(__tstate);
22542 if (PyErr_Occurred()) SWIG_fail;
22543 }
22544 resultobj = SWIG_From_int(static_cast< int >(result));
22545 return resultobj;
22546 fail:
22547 return NULL;
22548 }
22549
22550
22551 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22552 PyObject *resultobj = 0;
22553 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22554 int arg2 ;
22555 void *argp1 = 0 ;
22556 int res1 = 0 ;
22557 int val2 ;
22558 int ecode2 = 0 ;
22559 PyObject * obj0 = 0 ;
22560 PyObject * obj1 = 0 ;
22561 char * kwnames[] = {
22562 (char *) "self",(char *) "orient", NULL
22563 };
22564
22565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22567 if (!SWIG_IsOK(res1)) {
22568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22569 }
22570 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22571 ecode2 = SWIG_AsVal_int(obj1, &val2);
22572 if (!SWIG_IsOK(ecode2)) {
22573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22574 }
22575 arg2 = static_cast< int >(val2);
22576 {
22577 PyThreadState* __tstate = wxPyBeginAllowThreads();
22578 (arg1)->SetOrientation(arg2);
22579 wxPyEndAllowThreads(__tstate);
22580 if (PyErr_Occurred()) SWIG_fail;
22581 }
22582 resultobj = SWIG_Py_Void();
22583 return resultobj;
22584 fail:
22585 return NULL;
22586 }
22587
22588
22589 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22590 PyObject *resultobj = 0;
22591 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22592 int arg2 ;
22593 void *argp1 = 0 ;
22594 int res1 = 0 ;
22595 int val2 ;
22596 int ecode2 = 0 ;
22597 PyObject * obj0 = 0 ;
22598 PyObject * obj1 = 0 ;
22599 char * kwnames[] = {
22600 (char *) "self",(char *) "pos", NULL
22601 };
22602
22603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22605 if (!SWIG_IsOK(res1)) {
22606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22607 }
22608 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22609 ecode2 = SWIG_AsVal_int(obj1, &val2);
22610 if (!SWIG_IsOK(ecode2)) {
22611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22612 }
22613 arg2 = static_cast< int >(val2);
22614 {
22615 PyThreadState* __tstate = wxPyBeginAllowThreads();
22616 (arg1)->SetPosition(arg2);
22617 wxPyEndAllowThreads(__tstate);
22618 if (PyErr_Occurred()) SWIG_fail;
22619 }
22620 resultobj = SWIG_Py_Void();
22621 return resultobj;
22622 fail:
22623 return NULL;
22624 }
22625
22626
22627 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22628 PyObject *obj;
22629 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22630 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22631 return SWIG_Py_Void();
22632 }
22633
22634 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22635 return SWIG_Python_InitShadowInstance(args);
22636 }
22637
22638 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22639 PyObject *resultobj = 0;
22640 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22641 int arg2 = (int) 0 ;
22642 int arg3 = (int) 0 ;
22643 wxScrollWinEvent *result = 0 ;
22644 int val1 ;
22645 int ecode1 = 0 ;
22646 int val2 ;
22647 int ecode2 = 0 ;
22648 int val3 ;
22649 int ecode3 = 0 ;
22650 PyObject * obj0 = 0 ;
22651 PyObject * obj1 = 0 ;
22652 PyObject * obj2 = 0 ;
22653 char * kwnames[] = {
22654 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22655 };
22656
22657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22658 if (obj0) {
22659 ecode1 = SWIG_AsVal_int(obj0, &val1);
22660 if (!SWIG_IsOK(ecode1)) {
22661 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22662 }
22663 arg1 = static_cast< wxEventType >(val1);
22664 }
22665 if (obj1) {
22666 ecode2 = SWIG_AsVal_int(obj1, &val2);
22667 if (!SWIG_IsOK(ecode2)) {
22668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22669 }
22670 arg2 = static_cast< int >(val2);
22671 }
22672 if (obj2) {
22673 ecode3 = SWIG_AsVal_int(obj2, &val3);
22674 if (!SWIG_IsOK(ecode3)) {
22675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22676 }
22677 arg3 = static_cast< int >(val3);
22678 }
22679 {
22680 PyThreadState* __tstate = wxPyBeginAllowThreads();
22681 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22682 wxPyEndAllowThreads(__tstate);
22683 if (PyErr_Occurred()) SWIG_fail;
22684 }
22685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22686 return resultobj;
22687 fail:
22688 return NULL;
22689 }
22690
22691
22692 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22693 PyObject *resultobj = 0;
22694 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22695 int result;
22696 void *argp1 = 0 ;
22697 int res1 = 0 ;
22698 PyObject *swig_obj[1] ;
22699
22700 if (!args) SWIG_fail;
22701 swig_obj[0] = args;
22702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22703 if (!SWIG_IsOK(res1)) {
22704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22705 }
22706 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22707 {
22708 PyThreadState* __tstate = wxPyBeginAllowThreads();
22709 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22710 wxPyEndAllowThreads(__tstate);
22711 if (PyErr_Occurred()) SWIG_fail;
22712 }
22713 resultobj = SWIG_From_int(static_cast< int >(result));
22714 return resultobj;
22715 fail:
22716 return NULL;
22717 }
22718
22719
22720 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22721 PyObject *resultobj = 0;
22722 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22723 int result;
22724 void *argp1 = 0 ;
22725 int res1 = 0 ;
22726 PyObject *swig_obj[1] ;
22727
22728 if (!args) SWIG_fail;
22729 swig_obj[0] = args;
22730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22731 if (!SWIG_IsOK(res1)) {
22732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22733 }
22734 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22735 {
22736 PyThreadState* __tstate = wxPyBeginAllowThreads();
22737 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22738 wxPyEndAllowThreads(__tstate);
22739 if (PyErr_Occurred()) SWIG_fail;
22740 }
22741 resultobj = SWIG_From_int(static_cast< int >(result));
22742 return resultobj;
22743 fail:
22744 return NULL;
22745 }
22746
22747
22748 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22749 PyObject *resultobj = 0;
22750 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22751 int arg2 ;
22752 void *argp1 = 0 ;
22753 int res1 = 0 ;
22754 int val2 ;
22755 int ecode2 = 0 ;
22756 PyObject * obj0 = 0 ;
22757 PyObject * obj1 = 0 ;
22758 char * kwnames[] = {
22759 (char *) "self",(char *) "orient", NULL
22760 };
22761
22762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22764 if (!SWIG_IsOK(res1)) {
22765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22766 }
22767 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22768 ecode2 = SWIG_AsVal_int(obj1, &val2);
22769 if (!SWIG_IsOK(ecode2)) {
22770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22771 }
22772 arg2 = static_cast< int >(val2);
22773 {
22774 PyThreadState* __tstate = wxPyBeginAllowThreads();
22775 (arg1)->SetOrientation(arg2);
22776 wxPyEndAllowThreads(__tstate);
22777 if (PyErr_Occurred()) SWIG_fail;
22778 }
22779 resultobj = SWIG_Py_Void();
22780 return resultobj;
22781 fail:
22782 return NULL;
22783 }
22784
22785
22786 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22787 PyObject *resultobj = 0;
22788 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22789 int arg2 ;
22790 void *argp1 = 0 ;
22791 int res1 = 0 ;
22792 int val2 ;
22793 int ecode2 = 0 ;
22794 PyObject * obj0 = 0 ;
22795 PyObject * obj1 = 0 ;
22796 char * kwnames[] = {
22797 (char *) "self",(char *) "pos", NULL
22798 };
22799
22800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22802 if (!SWIG_IsOK(res1)) {
22803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22804 }
22805 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22806 ecode2 = SWIG_AsVal_int(obj1, &val2);
22807 if (!SWIG_IsOK(ecode2)) {
22808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22809 }
22810 arg2 = static_cast< int >(val2);
22811 {
22812 PyThreadState* __tstate = wxPyBeginAllowThreads();
22813 (arg1)->SetPosition(arg2);
22814 wxPyEndAllowThreads(__tstate);
22815 if (PyErr_Occurred()) SWIG_fail;
22816 }
22817 resultobj = SWIG_Py_Void();
22818 return resultobj;
22819 fail:
22820 return NULL;
22821 }
22822
22823
22824 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22825 PyObject *obj;
22826 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22827 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22828 return SWIG_Py_Void();
22829 }
22830
22831 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22832 return SWIG_Python_InitShadowInstance(args);
22833 }
22834
22835 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22836 PyObject *resultobj = 0;
22837 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22838 wxMouseEvent *result = 0 ;
22839 int val1 ;
22840 int ecode1 = 0 ;
22841 PyObject * obj0 = 0 ;
22842 char * kwnames[] = {
22843 (char *) "mouseType", NULL
22844 };
22845
22846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22847 if (obj0) {
22848 ecode1 = SWIG_AsVal_int(obj0, &val1);
22849 if (!SWIG_IsOK(ecode1)) {
22850 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22851 }
22852 arg1 = static_cast< wxEventType >(val1);
22853 }
22854 {
22855 PyThreadState* __tstate = wxPyBeginAllowThreads();
22856 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22857 wxPyEndAllowThreads(__tstate);
22858 if (PyErr_Occurred()) SWIG_fail;
22859 }
22860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22861 return resultobj;
22862 fail:
22863 return NULL;
22864 }
22865
22866
22867 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22868 PyObject *resultobj = 0;
22869 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22870 bool result;
22871 void *argp1 = 0 ;
22872 int res1 = 0 ;
22873 PyObject *swig_obj[1] ;
22874
22875 if (!args) SWIG_fail;
22876 swig_obj[0] = args;
22877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22878 if (!SWIG_IsOK(res1)) {
22879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22880 }
22881 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22882 {
22883 PyThreadState* __tstate = wxPyBeginAllowThreads();
22884 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22885 wxPyEndAllowThreads(__tstate);
22886 if (PyErr_Occurred()) SWIG_fail;
22887 }
22888 {
22889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22890 }
22891 return resultobj;
22892 fail:
22893 return NULL;
22894 }
22895
22896
22897 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22898 PyObject *resultobj = 0;
22899 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22900 int arg2 = (int) wxMOUSE_BTN_ANY ;
22901 bool result;
22902 void *argp1 = 0 ;
22903 int res1 = 0 ;
22904 int val2 ;
22905 int ecode2 = 0 ;
22906 PyObject * obj0 = 0 ;
22907 PyObject * obj1 = 0 ;
22908 char * kwnames[] = {
22909 (char *) "self",(char *) "but", NULL
22910 };
22911
22912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22914 if (!SWIG_IsOK(res1)) {
22915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22916 }
22917 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22918 if (obj1) {
22919 ecode2 = SWIG_AsVal_int(obj1, &val2);
22920 if (!SWIG_IsOK(ecode2)) {
22921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22922 }
22923 arg2 = static_cast< int >(val2);
22924 }
22925 {
22926 PyThreadState* __tstate = wxPyBeginAllowThreads();
22927 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22928 wxPyEndAllowThreads(__tstate);
22929 if (PyErr_Occurred()) SWIG_fail;
22930 }
22931 {
22932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22933 }
22934 return resultobj;
22935 fail:
22936 return NULL;
22937 }
22938
22939
22940 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22941 PyObject *resultobj = 0;
22942 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22943 int arg2 = (int) wxMOUSE_BTN_ANY ;
22944 bool result;
22945 void *argp1 = 0 ;
22946 int res1 = 0 ;
22947 int val2 ;
22948 int ecode2 = 0 ;
22949 PyObject * obj0 = 0 ;
22950 PyObject * obj1 = 0 ;
22951 char * kwnames[] = {
22952 (char *) "self",(char *) "but", NULL
22953 };
22954
22955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22957 if (!SWIG_IsOK(res1)) {
22958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22959 }
22960 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22961 if (obj1) {
22962 ecode2 = SWIG_AsVal_int(obj1, &val2);
22963 if (!SWIG_IsOK(ecode2)) {
22964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22965 }
22966 arg2 = static_cast< int >(val2);
22967 }
22968 {
22969 PyThreadState* __tstate = wxPyBeginAllowThreads();
22970 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22971 wxPyEndAllowThreads(__tstate);
22972 if (PyErr_Occurred()) SWIG_fail;
22973 }
22974 {
22975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22976 }
22977 return resultobj;
22978 fail:
22979 return NULL;
22980 }
22981
22982
22983 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22984 PyObject *resultobj = 0;
22985 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22986 int arg2 = (int) wxMOUSE_BTN_ANY ;
22987 bool result;
22988 void *argp1 = 0 ;
22989 int res1 = 0 ;
22990 int val2 ;
22991 int ecode2 = 0 ;
22992 PyObject * obj0 = 0 ;
22993 PyObject * obj1 = 0 ;
22994 char * kwnames[] = {
22995 (char *) "self",(char *) "but", NULL
22996 };
22997
22998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23000 if (!SWIG_IsOK(res1)) {
23001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23002 }
23003 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23004 if (obj1) {
23005 ecode2 = SWIG_AsVal_int(obj1, &val2);
23006 if (!SWIG_IsOK(ecode2)) {
23007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
23008 }
23009 arg2 = static_cast< int >(val2);
23010 }
23011 {
23012 PyThreadState* __tstate = wxPyBeginAllowThreads();
23013 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
23014 wxPyEndAllowThreads(__tstate);
23015 if (PyErr_Occurred()) SWIG_fail;
23016 }
23017 {
23018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23019 }
23020 return resultobj;
23021 fail:
23022 return NULL;
23023 }
23024
23025
23026 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23027 PyObject *resultobj = 0;
23028 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23029 int arg2 ;
23030 bool result;
23031 void *argp1 = 0 ;
23032 int res1 = 0 ;
23033 int val2 ;
23034 int ecode2 = 0 ;
23035 PyObject * obj0 = 0 ;
23036 PyObject * obj1 = 0 ;
23037 char * kwnames[] = {
23038 (char *) "self",(char *) "button", NULL
23039 };
23040
23041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
23042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23043 if (!SWIG_IsOK(res1)) {
23044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23045 }
23046 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23047 ecode2 = SWIG_AsVal_int(obj1, &val2);
23048 if (!SWIG_IsOK(ecode2)) {
23049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
23050 }
23051 arg2 = static_cast< int >(val2);
23052 {
23053 PyThreadState* __tstate = wxPyBeginAllowThreads();
23054 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
23055 wxPyEndAllowThreads(__tstate);
23056 if (PyErr_Occurred()) SWIG_fail;
23057 }
23058 {
23059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23060 }
23061 return resultobj;
23062 fail:
23063 return NULL;
23064 }
23065
23066
23067 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23068 PyObject *resultobj = 0;
23069 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23070 int arg2 ;
23071 bool result;
23072 void *argp1 = 0 ;
23073 int res1 = 0 ;
23074 int val2 ;
23075 int ecode2 = 0 ;
23076 PyObject * obj0 = 0 ;
23077 PyObject * obj1 = 0 ;
23078 char * kwnames[] = {
23079 (char *) "self",(char *) "but", NULL
23080 };
23081
23082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
23083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23084 if (!SWIG_IsOK(res1)) {
23085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23086 }
23087 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23088 ecode2 = SWIG_AsVal_int(obj1, &val2);
23089 if (!SWIG_IsOK(ecode2)) {
23090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
23091 }
23092 arg2 = static_cast< int >(val2);
23093 {
23094 PyThreadState* __tstate = wxPyBeginAllowThreads();
23095 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
23096 wxPyEndAllowThreads(__tstate);
23097 if (PyErr_Occurred()) SWIG_fail;
23098 }
23099 {
23100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23101 }
23102 return resultobj;
23103 fail:
23104 return NULL;
23105 }
23106
23107
23108 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23109 PyObject *resultobj = 0;
23110 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23111 int result;
23112 void *argp1 = 0 ;
23113 int res1 = 0 ;
23114 PyObject *swig_obj[1] ;
23115
23116 if (!args) SWIG_fail;
23117 swig_obj[0] = args;
23118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23119 if (!SWIG_IsOK(res1)) {
23120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23121 }
23122 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23123 {
23124 PyThreadState* __tstate = wxPyBeginAllowThreads();
23125 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23126 wxPyEndAllowThreads(__tstate);
23127 if (PyErr_Occurred()) SWIG_fail;
23128 }
23129 resultobj = SWIG_From_int(static_cast< int >(result));
23130 return resultobj;
23131 fail:
23132 return NULL;
23133 }
23134
23135
23136 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23137 PyObject *resultobj = 0;
23138 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23139 bool result;
23140 void *argp1 = 0 ;
23141 int res1 = 0 ;
23142 PyObject *swig_obj[1] ;
23143
23144 if (!args) SWIG_fail;
23145 swig_obj[0] = args;
23146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23147 if (!SWIG_IsOK(res1)) {
23148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23149 }
23150 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23151 {
23152 PyThreadState* __tstate = wxPyBeginAllowThreads();
23153 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23154 wxPyEndAllowThreads(__tstate);
23155 if (PyErr_Occurred()) SWIG_fail;
23156 }
23157 {
23158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23159 }
23160 return resultobj;
23161 fail:
23162 return NULL;
23163 }
23164
23165
23166 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23167 PyObject *resultobj = 0;
23168 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23169 bool result;
23170 void *argp1 = 0 ;
23171 int res1 = 0 ;
23172 PyObject *swig_obj[1] ;
23173
23174 if (!args) SWIG_fail;
23175 swig_obj[0] = args;
23176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23177 if (!SWIG_IsOK(res1)) {
23178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23179 }
23180 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23181 {
23182 PyThreadState* __tstate = wxPyBeginAllowThreads();
23183 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23184 wxPyEndAllowThreads(__tstate);
23185 if (PyErr_Occurred()) SWIG_fail;
23186 }
23187 {
23188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23189 }
23190 return resultobj;
23191 fail:
23192 return NULL;
23193 }
23194
23195
23196 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23197 PyObject *resultobj = 0;
23198 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23199 bool result;
23200 void *argp1 = 0 ;
23201 int res1 = 0 ;
23202 PyObject *swig_obj[1] ;
23203
23204 if (!args) SWIG_fail;
23205 swig_obj[0] = args;
23206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23207 if (!SWIG_IsOK(res1)) {
23208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23209 }
23210 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23211 {
23212 PyThreadState* __tstate = wxPyBeginAllowThreads();
23213 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23214 wxPyEndAllowThreads(__tstate);
23215 if (PyErr_Occurred()) SWIG_fail;
23216 }
23217 {
23218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23219 }
23220 return resultobj;
23221 fail:
23222 return NULL;
23223 }
23224
23225
23226 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23227 PyObject *resultobj = 0;
23228 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23229 bool result;
23230 void *argp1 = 0 ;
23231 int res1 = 0 ;
23232 PyObject *swig_obj[1] ;
23233
23234 if (!args) SWIG_fail;
23235 swig_obj[0] = args;
23236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23237 if (!SWIG_IsOK(res1)) {
23238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23239 }
23240 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23241 {
23242 PyThreadState* __tstate = wxPyBeginAllowThreads();
23243 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23244 wxPyEndAllowThreads(__tstate);
23245 if (PyErr_Occurred()) SWIG_fail;
23246 }
23247 {
23248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23249 }
23250 return resultobj;
23251 fail:
23252 return NULL;
23253 }
23254
23255
23256 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23257 PyObject *resultobj = 0;
23258 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23259 bool result;
23260 void *argp1 = 0 ;
23261 int res1 = 0 ;
23262 PyObject *swig_obj[1] ;
23263
23264 if (!args) SWIG_fail;
23265 swig_obj[0] = args;
23266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23267 if (!SWIG_IsOK(res1)) {
23268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23269 }
23270 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23271 {
23272 PyThreadState* __tstate = wxPyBeginAllowThreads();
23273 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23274 wxPyEndAllowThreads(__tstate);
23275 if (PyErr_Occurred()) SWIG_fail;
23276 }
23277 {
23278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23279 }
23280 return resultobj;
23281 fail:
23282 return NULL;
23283 }
23284
23285
23286 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23287 PyObject *resultobj = 0;
23288 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23289 bool result;
23290 void *argp1 = 0 ;
23291 int res1 = 0 ;
23292 PyObject *swig_obj[1] ;
23293
23294 if (!args) SWIG_fail;
23295 swig_obj[0] = args;
23296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23297 if (!SWIG_IsOK(res1)) {
23298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23299 }
23300 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23301 {
23302 PyThreadState* __tstate = wxPyBeginAllowThreads();
23303 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23304 wxPyEndAllowThreads(__tstate);
23305 if (PyErr_Occurred()) SWIG_fail;
23306 }
23307 {
23308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23309 }
23310 return resultobj;
23311 fail:
23312 return NULL;
23313 }
23314
23315
23316 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23317 PyObject *resultobj = 0;
23318 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23319 bool result;
23320 void *argp1 = 0 ;
23321 int res1 = 0 ;
23322 PyObject *swig_obj[1] ;
23323
23324 if (!args) SWIG_fail;
23325 swig_obj[0] = args;
23326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23327 if (!SWIG_IsOK(res1)) {
23328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23329 }
23330 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23331 {
23332 PyThreadState* __tstate = wxPyBeginAllowThreads();
23333 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23334 wxPyEndAllowThreads(__tstate);
23335 if (PyErr_Occurred()) SWIG_fail;
23336 }
23337 {
23338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23339 }
23340 return resultobj;
23341 fail:
23342 return NULL;
23343 }
23344
23345
23346 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23347 PyObject *resultobj = 0;
23348 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23349 bool result;
23350 void *argp1 = 0 ;
23351 int res1 = 0 ;
23352 PyObject *swig_obj[1] ;
23353
23354 if (!args) SWIG_fail;
23355 swig_obj[0] = args;
23356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23357 if (!SWIG_IsOK(res1)) {
23358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23359 }
23360 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23361 {
23362 PyThreadState* __tstate = wxPyBeginAllowThreads();
23363 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23364 wxPyEndAllowThreads(__tstate);
23365 if (PyErr_Occurred()) SWIG_fail;
23366 }
23367 {
23368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23369 }
23370 return resultobj;
23371 fail:
23372 return NULL;
23373 }
23374
23375
23376 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23377 PyObject *resultobj = 0;
23378 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23379 bool result;
23380 void *argp1 = 0 ;
23381 int res1 = 0 ;
23382 PyObject *swig_obj[1] ;
23383
23384 if (!args) SWIG_fail;
23385 swig_obj[0] = args;
23386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23387 if (!SWIG_IsOK(res1)) {
23388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23389 }
23390 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23391 {
23392 PyThreadState* __tstate = wxPyBeginAllowThreads();
23393 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23394 wxPyEndAllowThreads(__tstate);
23395 if (PyErr_Occurred()) SWIG_fail;
23396 }
23397 {
23398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23399 }
23400 return resultobj;
23401 fail:
23402 return NULL;
23403 }
23404
23405
23406 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23407 PyObject *resultobj = 0;
23408 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23409 bool result;
23410 void *argp1 = 0 ;
23411 int res1 = 0 ;
23412 PyObject *swig_obj[1] ;
23413
23414 if (!args) SWIG_fail;
23415 swig_obj[0] = args;
23416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23417 if (!SWIG_IsOK(res1)) {
23418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23419 }
23420 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23421 {
23422 PyThreadState* __tstate = wxPyBeginAllowThreads();
23423 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23424 wxPyEndAllowThreads(__tstate);
23425 if (PyErr_Occurred()) SWIG_fail;
23426 }
23427 {
23428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23429 }
23430 return resultobj;
23431 fail:
23432 return NULL;
23433 }
23434
23435
23436 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23437 PyObject *resultobj = 0;
23438 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23439 bool result;
23440 void *argp1 = 0 ;
23441 int res1 = 0 ;
23442 PyObject *swig_obj[1] ;
23443
23444 if (!args) SWIG_fail;
23445 swig_obj[0] = args;
23446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23447 if (!SWIG_IsOK(res1)) {
23448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23449 }
23450 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23451 {
23452 PyThreadState* __tstate = wxPyBeginAllowThreads();
23453 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23454 wxPyEndAllowThreads(__tstate);
23455 if (PyErr_Occurred()) SWIG_fail;
23456 }
23457 {
23458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23459 }
23460 return resultobj;
23461 fail:
23462 return NULL;
23463 }
23464
23465
23466 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23467 PyObject *resultobj = 0;
23468 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23469 bool result;
23470 void *argp1 = 0 ;
23471 int res1 = 0 ;
23472 PyObject *swig_obj[1] ;
23473
23474 if (!args) SWIG_fail;
23475 swig_obj[0] = args;
23476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23477 if (!SWIG_IsOK(res1)) {
23478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23479 }
23480 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23481 {
23482 PyThreadState* __tstate = wxPyBeginAllowThreads();
23483 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23484 wxPyEndAllowThreads(__tstate);
23485 if (PyErr_Occurred()) SWIG_fail;
23486 }
23487 {
23488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23489 }
23490 return resultobj;
23491 fail:
23492 return NULL;
23493 }
23494
23495
23496 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23497 PyObject *resultobj = 0;
23498 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23499 bool result;
23500 void *argp1 = 0 ;
23501 int res1 = 0 ;
23502 PyObject *swig_obj[1] ;
23503
23504 if (!args) SWIG_fail;
23505 swig_obj[0] = args;
23506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23507 if (!SWIG_IsOK(res1)) {
23508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23509 }
23510 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23511 {
23512 PyThreadState* __tstate = wxPyBeginAllowThreads();
23513 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23514 wxPyEndAllowThreads(__tstate);
23515 if (PyErr_Occurred()) SWIG_fail;
23516 }
23517 {
23518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23519 }
23520 return resultobj;
23521 fail:
23522 return NULL;
23523 }
23524
23525
23526 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23527 PyObject *resultobj = 0;
23528 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23529 bool result;
23530 void *argp1 = 0 ;
23531 int res1 = 0 ;
23532 PyObject *swig_obj[1] ;
23533
23534 if (!args) SWIG_fail;
23535 swig_obj[0] = args;
23536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23537 if (!SWIG_IsOK(res1)) {
23538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23539 }
23540 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23541 {
23542 PyThreadState* __tstate = wxPyBeginAllowThreads();
23543 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23544 wxPyEndAllowThreads(__tstate);
23545 if (PyErr_Occurred()) SWIG_fail;
23546 }
23547 {
23548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23549 }
23550 return resultobj;
23551 fail:
23552 return NULL;
23553 }
23554
23555
23556 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23557 PyObject *resultobj = 0;
23558 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23559 bool result;
23560 void *argp1 = 0 ;
23561 int res1 = 0 ;
23562 PyObject *swig_obj[1] ;
23563
23564 if (!args) SWIG_fail;
23565 swig_obj[0] = args;
23566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23567 if (!SWIG_IsOK(res1)) {
23568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23569 }
23570 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23571 {
23572 PyThreadState* __tstate = wxPyBeginAllowThreads();
23573 result = (bool)(arg1)->LeftIsDown();
23574 wxPyEndAllowThreads(__tstate);
23575 if (PyErr_Occurred()) SWIG_fail;
23576 }
23577 {
23578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23579 }
23580 return resultobj;
23581 fail:
23582 return NULL;
23583 }
23584
23585
23586 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23587 PyObject *resultobj = 0;
23588 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23589 bool result;
23590 void *argp1 = 0 ;
23591 int res1 = 0 ;
23592 PyObject *swig_obj[1] ;
23593
23594 if (!args) SWIG_fail;
23595 swig_obj[0] = args;
23596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23597 if (!SWIG_IsOK(res1)) {
23598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23599 }
23600 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23601 {
23602 PyThreadState* __tstate = wxPyBeginAllowThreads();
23603 result = (bool)(arg1)->MiddleIsDown();
23604 wxPyEndAllowThreads(__tstate);
23605 if (PyErr_Occurred()) SWIG_fail;
23606 }
23607 {
23608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23609 }
23610 return resultobj;
23611 fail:
23612 return NULL;
23613 }
23614
23615
23616 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23617 PyObject *resultobj = 0;
23618 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23619 bool result;
23620 void *argp1 = 0 ;
23621 int res1 = 0 ;
23622 PyObject *swig_obj[1] ;
23623
23624 if (!args) SWIG_fail;
23625 swig_obj[0] = args;
23626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23627 if (!SWIG_IsOK(res1)) {
23628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23629 }
23630 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23631 {
23632 PyThreadState* __tstate = wxPyBeginAllowThreads();
23633 result = (bool)(arg1)->RightIsDown();
23634 wxPyEndAllowThreads(__tstate);
23635 if (PyErr_Occurred()) SWIG_fail;
23636 }
23637 {
23638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23639 }
23640 return resultobj;
23641 fail:
23642 return NULL;
23643 }
23644
23645
23646 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23647 PyObject *resultobj = 0;
23648 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23649 bool result;
23650 void *argp1 = 0 ;
23651 int res1 = 0 ;
23652 PyObject *swig_obj[1] ;
23653
23654 if (!args) SWIG_fail;
23655 swig_obj[0] = args;
23656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23657 if (!SWIG_IsOK(res1)) {
23658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23659 }
23660 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23661 {
23662 PyThreadState* __tstate = wxPyBeginAllowThreads();
23663 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23664 wxPyEndAllowThreads(__tstate);
23665 if (PyErr_Occurred()) SWIG_fail;
23666 }
23667 {
23668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23669 }
23670 return resultobj;
23671 fail:
23672 return NULL;
23673 }
23674
23675
23676 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23677 PyObject *resultobj = 0;
23678 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23679 bool result;
23680 void *argp1 = 0 ;
23681 int res1 = 0 ;
23682 PyObject *swig_obj[1] ;
23683
23684 if (!args) SWIG_fail;
23685 swig_obj[0] = args;
23686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23687 if (!SWIG_IsOK(res1)) {
23688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23689 }
23690 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23691 {
23692 PyThreadState* __tstate = wxPyBeginAllowThreads();
23693 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23694 wxPyEndAllowThreads(__tstate);
23695 if (PyErr_Occurred()) SWIG_fail;
23696 }
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_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23707 PyObject *resultobj = 0;
23708 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23709 bool result;
23710 void *argp1 = 0 ;
23711 int res1 = 0 ;
23712 PyObject *swig_obj[1] ;
23713
23714 if (!args) SWIG_fail;
23715 swig_obj[0] = args;
23716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23717 if (!SWIG_IsOK(res1)) {
23718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23719 }
23720 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23721 {
23722 PyThreadState* __tstate = wxPyBeginAllowThreads();
23723 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23724 wxPyEndAllowThreads(__tstate);
23725 if (PyErr_Occurred()) SWIG_fail;
23726 }
23727 {
23728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23729 }
23730 return resultobj;
23731 fail:
23732 return NULL;
23733 }
23734
23735
23736 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23737 PyObject *resultobj = 0;
23738 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23739 bool 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_wxMouseEvent, 0 | 0 );
23747 if (!SWIG_IsOK(res1)) {
23748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23749 }
23750 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23751 {
23752 PyThreadState* __tstate = wxPyBeginAllowThreads();
23753 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23754 wxPyEndAllowThreads(__tstate);
23755 if (PyErr_Occurred()) SWIG_fail;
23756 }
23757 {
23758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23759 }
23760 return resultobj;
23761 fail:
23762 return NULL;
23763 }
23764
23765
23766 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23767 PyObject *resultobj = 0;
23768 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23769 wxPoint result;
23770 void *argp1 = 0 ;
23771 int res1 = 0 ;
23772 PyObject *swig_obj[1] ;
23773
23774 if (!args) SWIG_fail;
23775 swig_obj[0] = args;
23776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23777 if (!SWIG_IsOK(res1)) {
23778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23779 }
23780 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23781 {
23782 PyThreadState* __tstate = wxPyBeginAllowThreads();
23783 result = (arg1)->GetPosition();
23784 wxPyEndAllowThreads(__tstate);
23785 if (PyErr_Occurred()) SWIG_fail;
23786 }
23787 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23788 return resultobj;
23789 fail:
23790 return NULL;
23791 }
23792
23793
23794 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23795 PyObject *resultobj = 0;
23796 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23797 long *arg2 = (long *) 0 ;
23798 long *arg3 = (long *) 0 ;
23799 void *argp1 = 0 ;
23800 int res1 = 0 ;
23801 long temp2 ;
23802 int res2 = SWIG_TMPOBJ ;
23803 long temp3 ;
23804 int res3 = SWIG_TMPOBJ ;
23805 PyObject *swig_obj[1] ;
23806
23807 arg2 = &temp2;
23808 arg3 = &temp3;
23809 if (!args) SWIG_fail;
23810 swig_obj[0] = args;
23811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23812 if (!SWIG_IsOK(res1)) {
23813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23814 }
23815 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23816 {
23817 PyThreadState* __tstate = wxPyBeginAllowThreads();
23818 (arg1)->GetPosition(arg2,arg3);
23819 wxPyEndAllowThreads(__tstate);
23820 if (PyErr_Occurred()) SWIG_fail;
23821 }
23822 resultobj = SWIG_Py_Void();
23823 if (SWIG_IsTmpObj(res2)) {
23824 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23825 } else {
23826 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23827 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23828 }
23829 if (SWIG_IsTmpObj(res3)) {
23830 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23831 } else {
23832 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23833 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23834 }
23835 return resultobj;
23836 fail:
23837 return NULL;
23838 }
23839
23840
23841 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23842 PyObject *resultobj = 0;
23843 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23844 wxDC *arg2 = 0 ;
23845 wxPoint result;
23846 void *argp1 = 0 ;
23847 int res1 = 0 ;
23848 void *argp2 = 0 ;
23849 int res2 = 0 ;
23850 PyObject * obj0 = 0 ;
23851 PyObject * obj1 = 0 ;
23852 char * kwnames[] = {
23853 (char *) "self",(char *) "dc", NULL
23854 };
23855
23856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23858 if (!SWIG_IsOK(res1)) {
23859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23860 }
23861 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23862 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23863 if (!SWIG_IsOK(res2)) {
23864 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23865 }
23866 if (!argp2) {
23867 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23868 }
23869 arg2 = reinterpret_cast< wxDC * >(argp2);
23870 {
23871 PyThreadState* __tstate = wxPyBeginAllowThreads();
23872 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23873 wxPyEndAllowThreads(__tstate);
23874 if (PyErr_Occurred()) SWIG_fail;
23875 }
23876 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23877 return resultobj;
23878 fail:
23879 return NULL;
23880 }
23881
23882
23883 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23884 PyObject *resultobj = 0;
23885 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23886 int result;
23887 void *argp1 = 0 ;
23888 int res1 = 0 ;
23889 PyObject *swig_obj[1] ;
23890
23891 if (!args) SWIG_fail;
23892 swig_obj[0] = args;
23893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23894 if (!SWIG_IsOK(res1)) {
23895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23896 }
23897 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23898 {
23899 PyThreadState* __tstate = wxPyBeginAllowThreads();
23900 result = (int)((wxMouseEvent const *)arg1)->GetX();
23901 wxPyEndAllowThreads(__tstate);
23902 if (PyErr_Occurred()) SWIG_fail;
23903 }
23904 resultobj = SWIG_From_int(static_cast< int >(result));
23905 return resultobj;
23906 fail:
23907 return NULL;
23908 }
23909
23910
23911 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23912 PyObject *resultobj = 0;
23913 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23914 int result;
23915 void *argp1 = 0 ;
23916 int res1 = 0 ;
23917 PyObject *swig_obj[1] ;
23918
23919 if (!args) SWIG_fail;
23920 swig_obj[0] = args;
23921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23922 if (!SWIG_IsOK(res1)) {
23923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23924 }
23925 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23926 {
23927 PyThreadState* __tstate = wxPyBeginAllowThreads();
23928 result = (int)((wxMouseEvent const *)arg1)->GetY();
23929 wxPyEndAllowThreads(__tstate);
23930 if (PyErr_Occurred()) SWIG_fail;
23931 }
23932 resultobj = SWIG_From_int(static_cast< int >(result));
23933 return resultobj;
23934 fail:
23935 return NULL;
23936 }
23937
23938
23939 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23940 PyObject *resultobj = 0;
23941 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23942 int result;
23943 void *argp1 = 0 ;
23944 int res1 = 0 ;
23945 PyObject *swig_obj[1] ;
23946
23947 if (!args) SWIG_fail;
23948 swig_obj[0] = args;
23949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23950 if (!SWIG_IsOK(res1)) {
23951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23952 }
23953 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23954 {
23955 PyThreadState* __tstate = wxPyBeginAllowThreads();
23956 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23957 wxPyEndAllowThreads(__tstate);
23958 if (PyErr_Occurred()) SWIG_fail;
23959 }
23960 resultobj = SWIG_From_int(static_cast< int >(result));
23961 return resultobj;
23962 fail:
23963 return NULL;
23964 }
23965
23966
23967 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23968 PyObject *resultobj = 0;
23969 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23970 int result;
23971 void *argp1 = 0 ;
23972 int res1 = 0 ;
23973 PyObject *swig_obj[1] ;
23974
23975 if (!args) SWIG_fail;
23976 swig_obj[0] = args;
23977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23978 if (!SWIG_IsOK(res1)) {
23979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23980 }
23981 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23982 {
23983 PyThreadState* __tstate = wxPyBeginAllowThreads();
23984 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23985 wxPyEndAllowThreads(__tstate);
23986 if (PyErr_Occurred()) SWIG_fail;
23987 }
23988 resultobj = SWIG_From_int(static_cast< int >(result));
23989 return resultobj;
23990 fail:
23991 return NULL;
23992 }
23993
23994
23995 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23996 PyObject *resultobj = 0;
23997 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23998 int result;
23999 void *argp1 = 0 ;
24000 int res1 = 0 ;
24001 PyObject *swig_obj[1] ;
24002
24003 if (!args) SWIG_fail;
24004 swig_obj[0] = args;
24005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24006 if (!SWIG_IsOK(res1)) {
24007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24008 }
24009 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24010 {
24011 PyThreadState* __tstate = wxPyBeginAllowThreads();
24012 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
24013 wxPyEndAllowThreads(__tstate);
24014 if (PyErr_Occurred()) SWIG_fail;
24015 }
24016 resultobj = SWIG_From_int(static_cast< int >(result));
24017 return resultobj;
24018 fail:
24019 return NULL;
24020 }
24021
24022
24023 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24024 PyObject *resultobj = 0;
24025 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24026 bool result;
24027 void *argp1 = 0 ;
24028 int res1 = 0 ;
24029 PyObject *swig_obj[1] ;
24030
24031 if (!args) SWIG_fail;
24032 swig_obj[0] = args;
24033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24034 if (!SWIG_IsOK(res1)) {
24035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24036 }
24037 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24038 {
24039 PyThreadState* __tstate = wxPyBeginAllowThreads();
24040 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
24041 wxPyEndAllowThreads(__tstate);
24042 if (PyErr_Occurred()) SWIG_fail;
24043 }
24044 {
24045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24046 }
24047 return resultobj;
24048 fail:
24049 return NULL;
24050 }
24051
24052
24053 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24054 PyObject *resultobj = 0;
24055 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24056 int arg2 ;
24057 void *argp1 = 0 ;
24058 int res1 = 0 ;
24059 int val2 ;
24060 int ecode2 = 0 ;
24061 PyObject *swig_obj[2] ;
24062
24063 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
24064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24065 if (!SWIG_IsOK(res1)) {
24066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24067 }
24068 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24069 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24070 if (!SWIG_IsOK(ecode2)) {
24071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
24072 }
24073 arg2 = static_cast< int >(val2);
24074 if (arg1) (arg1)->m_x = arg2;
24075
24076 resultobj = SWIG_Py_Void();
24077 return resultobj;
24078 fail:
24079 return NULL;
24080 }
24081
24082
24083 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24084 PyObject *resultobj = 0;
24085 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24086 int result;
24087 void *argp1 = 0 ;
24088 int res1 = 0 ;
24089 PyObject *swig_obj[1] ;
24090
24091 if (!args) SWIG_fail;
24092 swig_obj[0] = args;
24093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24094 if (!SWIG_IsOK(res1)) {
24095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24096 }
24097 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24098 result = (int) ((arg1)->m_x);
24099 resultobj = SWIG_From_int(static_cast< int >(result));
24100 return resultobj;
24101 fail:
24102 return NULL;
24103 }
24104
24105
24106 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24107 PyObject *resultobj = 0;
24108 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24109 int arg2 ;
24110 void *argp1 = 0 ;
24111 int res1 = 0 ;
24112 int val2 ;
24113 int ecode2 = 0 ;
24114 PyObject *swig_obj[2] ;
24115
24116 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24118 if (!SWIG_IsOK(res1)) {
24119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24120 }
24121 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24122 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24123 if (!SWIG_IsOK(ecode2)) {
24124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24125 }
24126 arg2 = static_cast< int >(val2);
24127 if (arg1) (arg1)->m_y = arg2;
24128
24129 resultobj = SWIG_Py_Void();
24130 return resultobj;
24131 fail:
24132 return NULL;
24133 }
24134
24135
24136 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24137 PyObject *resultobj = 0;
24138 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24139 int result;
24140 void *argp1 = 0 ;
24141 int res1 = 0 ;
24142 PyObject *swig_obj[1] ;
24143
24144 if (!args) SWIG_fail;
24145 swig_obj[0] = args;
24146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24147 if (!SWIG_IsOK(res1)) {
24148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24149 }
24150 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24151 result = (int) ((arg1)->m_y);
24152 resultobj = SWIG_From_int(static_cast< int >(result));
24153 return resultobj;
24154 fail:
24155 return NULL;
24156 }
24157
24158
24159 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24160 PyObject *resultobj = 0;
24161 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24162 bool arg2 ;
24163 void *argp1 = 0 ;
24164 int res1 = 0 ;
24165 bool val2 ;
24166 int ecode2 = 0 ;
24167 PyObject *swig_obj[2] ;
24168
24169 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24171 if (!SWIG_IsOK(res1)) {
24172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24173 }
24174 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24175 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24176 if (!SWIG_IsOK(ecode2)) {
24177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24178 }
24179 arg2 = static_cast< bool >(val2);
24180 if (arg1) (arg1)->m_leftDown = arg2;
24181
24182 resultobj = SWIG_Py_Void();
24183 return resultobj;
24184 fail:
24185 return NULL;
24186 }
24187
24188
24189 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24190 PyObject *resultobj = 0;
24191 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24192 bool result;
24193 void *argp1 = 0 ;
24194 int res1 = 0 ;
24195 PyObject *swig_obj[1] ;
24196
24197 if (!args) SWIG_fail;
24198 swig_obj[0] = args;
24199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24200 if (!SWIG_IsOK(res1)) {
24201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24202 }
24203 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24204 result = (bool) ((arg1)->m_leftDown);
24205 {
24206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24207 }
24208 return resultobj;
24209 fail:
24210 return NULL;
24211 }
24212
24213
24214 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24215 PyObject *resultobj = 0;
24216 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24217 bool arg2 ;
24218 void *argp1 = 0 ;
24219 int res1 = 0 ;
24220 bool val2 ;
24221 int ecode2 = 0 ;
24222 PyObject *swig_obj[2] ;
24223
24224 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24226 if (!SWIG_IsOK(res1)) {
24227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24228 }
24229 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24230 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24231 if (!SWIG_IsOK(ecode2)) {
24232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24233 }
24234 arg2 = static_cast< bool >(val2);
24235 if (arg1) (arg1)->m_middleDown = arg2;
24236
24237 resultobj = SWIG_Py_Void();
24238 return resultobj;
24239 fail:
24240 return NULL;
24241 }
24242
24243
24244 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24245 PyObject *resultobj = 0;
24246 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24247 bool result;
24248 void *argp1 = 0 ;
24249 int res1 = 0 ;
24250 PyObject *swig_obj[1] ;
24251
24252 if (!args) SWIG_fail;
24253 swig_obj[0] = args;
24254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24255 if (!SWIG_IsOK(res1)) {
24256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24257 }
24258 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24259 result = (bool) ((arg1)->m_middleDown);
24260 {
24261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24262 }
24263 return resultobj;
24264 fail:
24265 return NULL;
24266 }
24267
24268
24269 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24270 PyObject *resultobj = 0;
24271 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24272 bool arg2 ;
24273 void *argp1 = 0 ;
24274 int res1 = 0 ;
24275 bool val2 ;
24276 int ecode2 = 0 ;
24277 PyObject *swig_obj[2] ;
24278
24279 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24281 if (!SWIG_IsOK(res1)) {
24282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24283 }
24284 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24285 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24286 if (!SWIG_IsOK(ecode2)) {
24287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24288 }
24289 arg2 = static_cast< bool >(val2);
24290 if (arg1) (arg1)->m_rightDown = arg2;
24291
24292 resultobj = SWIG_Py_Void();
24293 return resultobj;
24294 fail:
24295 return NULL;
24296 }
24297
24298
24299 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24300 PyObject *resultobj = 0;
24301 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24302 bool result;
24303 void *argp1 = 0 ;
24304 int res1 = 0 ;
24305 PyObject *swig_obj[1] ;
24306
24307 if (!args) SWIG_fail;
24308 swig_obj[0] = args;
24309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24310 if (!SWIG_IsOK(res1)) {
24311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24312 }
24313 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24314 result = (bool) ((arg1)->m_rightDown);
24315 {
24316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24317 }
24318 return resultobj;
24319 fail:
24320 return NULL;
24321 }
24322
24323
24324 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24325 PyObject *resultobj = 0;
24326 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24327 bool arg2 ;
24328 void *argp1 = 0 ;
24329 int res1 = 0 ;
24330 bool val2 ;
24331 int ecode2 = 0 ;
24332 PyObject *swig_obj[2] ;
24333
24334 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24336 if (!SWIG_IsOK(res1)) {
24337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24338 }
24339 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24340 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24341 if (!SWIG_IsOK(ecode2)) {
24342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24343 }
24344 arg2 = static_cast< bool >(val2);
24345 if (arg1) (arg1)->m_controlDown = arg2;
24346
24347 resultobj = SWIG_Py_Void();
24348 return resultobj;
24349 fail:
24350 return NULL;
24351 }
24352
24353
24354 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24355 PyObject *resultobj = 0;
24356 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24357 bool result;
24358 void *argp1 = 0 ;
24359 int res1 = 0 ;
24360 PyObject *swig_obj[1] ;
24361
24362 if (!args) SWIG_fail;
24363 swig_obj[0] = args;
24364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24365 if (!SWIG_IsOK(res1)) {
24366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24367 }
24368 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24369 result = (bool) ((arg1)->m_controlDown);
24370 {
24371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24372 }
24373 return resultobj;
24374 fail:
24375 return NULL;
24376 }
24377
24378
24379 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24380 PyObject *resultobj = 0;
24381 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24382 bool arg2 ;
24383 void *argp1 = 0 ;
24384 int res1 = 0 ;
24385 bool val2 ;
24386 int ecode2 = 0 ;
24387 PyObject *swig_obj[2] ;
24388
24389 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24391 if (!SWIG_IsOK(res1)) {
24392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24393 }
24394 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24395 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24396 if (!SWIG_IsOK(ecode2)) {
24397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24398 }
24399 arg2 = static_cast< bool >(val2);
24400 if (arg1) (arg1)->m_shiftDown = arg2;
24401
24402 resultobj = SWIG_Py_Void();
24403 return resultobj;
24404 fail:
24405 return NULL;
24406 }
24407
24408
24409 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24410 PyObject *resultobj = 0;
24411 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24412 bool result;
24413 void *argp1 = 0 ;
24414 int res1 = 0 ;
24415 PyObject *swig_obj[1] ;
24416
24417 if (!args) SWIG_fail;
24418 swig_obj[0] = args;
24419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24420 if (!SWIG_IsOK(res1)) {
24421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24422 }
24423 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24424 result = (bool) ((arg1)->m_shiftDown);
24425 {
24426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24427 }
24428 return resultobj;
24429 fail:
24430 return NULL;
24431 }
24432
24433
24434 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24435 PyObject *resultobj = 0;
24436 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24437 bool arg2 ;
24438 void *argp1 = 0 ;
24439 int res1 = 0 ;
24440 bool val2 ;
24441 int ecode2 = 0 ;
24442 PyObject *swig_obj[2] ;
24443
24444 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24446 if (!SWIG_IsOK(res1)) {
24447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24448 }
24449 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24450 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24451 if (!SWIG_IsOK(ecode2)) {
24452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24453 }
24454 arg2 = static_cast< bool >(val2);
24455 if (arg1) (arg1)->m_altDown = arg2;
24456
24457 resultobj = SWIG_Py_Void();
24458 return resultobj;
24459 fail:
24460 return NULL;
24461 }
24462
24463
24464 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24465 PyObject *resultobj = 0;
24466 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24467 bool result;
24468 void *argp1 = 0 ;
24469 int res1 = 0 ;
24470 PyObject *swig_obj[1] ;
24471
24472 if (!args) SWIG_fail;
24473 swig_obj[0] = args;
24474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24475 if (!SWIG_IsOK(res1)) {
24476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24477 }
24478 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24479 result = (bool) ((arg1)->m_altDown);
24480 {
24481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24482 }
24483 return resultobj;
24484 fail:
24485 return NULL;
24486 }
24487
24488
24489 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24490 PyObject *resultobj = 0;
24491 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24492 bool arg2 ;
24493 void *argp1 = 0 ;
24494 int res1 = 0 ;
24495 bool val2 ;
24496 int ecode2 = 0 ;
24497 PyObject *swig_obj[2] ;
24498
24499 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24501 if (!SWIG_IsOK(res1)) {
24502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24503 }
24504 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24505 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24506 if (!SWIG_IsOK(ecode2)) {
24507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24508 }
24509 arg2 = static_cast< bool >(val2);
24510 if (arg1) (arg1)->m_metaDown = arg2;
24511
24512 resultobj = SWIG_Py_Void();
24513 return resultobj;
24514 fail:
24515 return NULL;
24516 }
24517
24518
24519 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24520 PyObject *resultobj = 0;
24521 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24522 bool result;
24523 void *argp1 = 0 ;
24524 int res1 = 0 ;
24525 PyObject *swig_obj[1] ;
24526
24527 if (!args) SWIG_fail;
24528 swig_obj[0] = args;
24529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24530 if (!SWIG_IsOK(res1)) {
24531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24532 }
24533 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24534 result = (bool) ((arg1)->m_metaDown);
24535 {
24536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24537 }
24538 return resultobj;
24539 fail:
24540 return NULL;
24541 }
24542
24543
24544 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24545 PyObject *resultobj = 0;
24546 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24547 int arg2 ;
24548 void *argp1 = 0 ;
24549 int res1 = 0 ;
24550 int val2 ;
24551 int ecode2 = 0 ;
24552 PyObject *swig_obj[2] ;
24553
24554 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24556 if (!SWIG_IsOK(res1)) {
24557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24558 }
24559 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24560 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24561 if (!SWIG_IsOK(ecode2)) {
24562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24563 }
24564 arg2 = static_cast< int >(val2);
24565 if (arg1) (arg1)->m_wheelRotation = arg2;
24566
24567 resultobj = SWIG_Py_Void();
24568 return resultobj;
24569 fail:
24570 return NULL;
24571 }
24572
24573
24574 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24575 PyObject *resultobj = 0;
24576 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24577 int result;
24578 void *argp1 = 0 ;
24579 int res1 = 0 ;
24580 PyObject *swig_obj[1] ;
24581
24582 if (!args) SWIG_fail;
24583 swig_obj[0] = args;
24584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24585 if (!SWIG_IsOK(res1)) {
24586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24587 }
24588 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24589 result = (int) ((arg1)->m_wheelRotation);
24590 resultobj = SWIG_From_int(static_cast< int >(result));
24591 return resultobj;
24592 fail:
24593 return NULL;
24594 }
24595
24596
24597 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24598 PyObject *resultobj = 0;
24599 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24600 int arg2 ;
24601 void *argp1 = 0 ;
24602 int res1 = 0 ;
24603 int val2 ;
24604 int ecode2 = 0 ;
24605 PyObject *swig_obj[2] ;
24606
24607 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24609 if (!SWIG_IsOK(res1)) {
24610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24611 }
24612 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24613 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24614 if (!SWIG_IsOK(ecode2)) {
24615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24616 }
24617 arg2 = static_cast< int >(val2);
24618 if (arg1) (arg1)->m_wheelDelta = arg2;
24619
24620 resultobj = SWIG_Py_Void();
24621 return resultobj;
24622 fail:
24623 return NULL;
24624 }
24625
24626
24627 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24628 PyObject *resultobj = 0;
24629 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24630 int result;
24631 void *argp1 = 0 ;
24632 int res1 = 0 ;
24633 PyObject *swig_obj[1] ;
24634
24635 if (!args) SWIG_fail;
24636 swig_obj[0] = args;
24637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24638 if (!SWIG_IsOK(res1)) {
24639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24640 }
24641 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24642 result = (int) ((arg1)->m_wheelDelta);
24643 resultobj = SWIG_From_int(static_cast< int >(result));
24644 return resultobj;
24645 fail:
24646 return NULL;
24647 }
24648
24649
24650 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24651 PyObject *resultobj = 0;
24652 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24653 int arg2 ;
24654 void *argp1 = 0 ;
24655 int res1 = 0 ;
24656 int val2 ;
24657 int ecode2 = 0 ;
24658 PyObject *swig_obj[2] ;
24659
24660 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24662 if (!SWIG_IsOK(res1)) {
24663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24664 }
24665 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24666 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24667 if (!SWIG_IsOK(ecode2)) {
24668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24669 }
24670 arg2 = static_cast< int >(val2);
24671 if (arg1) (arg1)->m_linesPerAction = arg2;
24672
24673 resultobj = SWIG_Py_Void();
24674 return resultobj;
24675 fail:
24676 return NULL;
24677 }
24678
24679
24680 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24681 PyObject *resultobj = 0;
24682 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24683 int result;
24684 void *argp1 = 0 ;
24685 int res1 = 0 ;
24686 PyObject *swig_obj[1] ;
24687
24688 if (!args) SWIG_fail;
24689 swig_obj[0] = args;
24690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24691 if (!SWIG_IsOK(res1)) {
24692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24693 }
24694 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24695 result = (int) ((arg1)->m_linesPerAction);
24696 resultobj = SWIG_From_int(static_cast< int >(result));
24697 return resultobj;
24698 fail:
24699 return NULL;
24700 }
24701
24702
24703 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24704 PyObject *obj;
24705 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24706 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24707 return SWIG_Py_Void();
24708 }
24709
24710 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24711 return SWIG_Python_InitShadowInstance(args);
24712 }
24713
24714 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24715 PyObject *resultobj = 0;
24716 int arg1 = (int) 0 ;
24717 int arg2 = (int) 0 ;
24718 wxSetCursorEvent *result = 0 ;
24719 int val1 ;
24720 int ecode1 = 0 ;
24721 int val2 ;
24722 int ecode2 = 0 ;
24723 PyObject * obj0 = 0 ;
24724 PyObject * obj1 = 0 ;
24725 char * kwnames[] = {
24726 (char *) "x",(char *) "y", NULL
24727 };
24728
24729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24730 if (obj0) {
24731 ecode1 = SWIG_AsVal_int(obj0, &val1);
24732 if (!SWIG_IsOK(ecode1)) {
24733 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24734 }
24735 arg1 = static_cast< int >(val1);
24736 }
24737 if (obj1) {
24738 ecode2 = SWIG_AsVal_int(obj1, &val2);
24739 if (!SWIG_IsOK(ecode2)) {
24740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24741 }
24742 arg2 = static_cast< int >(val2);
24743 }
24744 {
24745 PyThreadState* __tstate = wxPyBeginAllowThreads();
24746 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24747 wxPyEndAllowThreads(__tstate);
24748 if (PyErr_Occurred()) SWIG_fail;
24749 }
24750 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24751 return resultobj;
24752 fail:
24753 return NULL;
24754 }
24755
24756
24757 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24758 PyObject *resultobj = 0;
24759 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24760 int result;
24761 void *argp1 = 0 ;
24762 int res1 = 0 ;
24763 PyObject *swig_obj[1] ;
24764
24765 if (!args) SWIG_fail;
24766 swig_obj[0] = args;
24767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24768 if (!SWIG_IsOK(res1)) {
24769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24770 }
24771 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24772 {
24773 PyThreadState* __tstate = wxPyBeginAllowThreads();
24774 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24775 wxPyEndAllowThreads(__tstate);
24776 if (PyErr_Occurred()) SWIG_fail;
24777 }
24778 resultobj = SWIG_From_int(static_cast< int >(result));
24779 return resultobj;
24780 fail:
24781 return NULL;
24782 }
24783
24784
24785 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24786 PyObject *resultobj = 0;
24787 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24788 int result;
24789 void *argp1 = 0 ;
24790 int res1 = 0 ;
24791 PyObject *swig_obj[1] ;
24792
24793 if (!args) SWIG_fail;
24794 swig_obj[0] = args;
24795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24796 if (!SWIG_IsOK(res1)) {
24797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24798 }
24799 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24800 {
24801 PyThreadState* __tstate = wxPyBeginAllowThreads();
24802 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24803 wxPyEndAllowThreads(__tstate);
24804 if (PyErr_Occurred()) SWIG_fail;
24805 }
24806 resultobj = SWIG_From_int(static_cast< int >(result));
24807 return resultobj;
24808 fail:
24809 return NULL;
24810 }
24811
24812
24813 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24814 PyObject *resultobj = 0;
24815 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24816 wxCursor *arg2 = 0 ;
24817 void *argp1 = 0 ;
24818 int res1 = 0 ;
24819 void *argp2 = 0 ;
24820 int res2 = 0 ;
24821 PyObject * obj0 = 0 ;
24822 PyObject * obj1 = 0 ;
24823 char * kwnames[] = {
24824 (char *) "self",(char *) "cursor", NULL
24825 };
24826
24827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24829 if (!SWIG_IsOK(res1)) {
24830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24831 }
24832 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24833 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24834 if (!SWIG_IsOK(res2)) {
24835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24836 }
24837 if (!argp2) {
24838 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24839 }
24840 arg2 = reinterpret_cast< wxCursor * >(argp2);
24841 {
24842 PyThreadState* __tstate = wxPyBeginAllowThreads();
24843 (arg1)->SetCursor((wxCursor const &)*arg2);
24844 wxPyEndAllowThreads(__tstate);
24845 if (PyErr_Occurred()) SWIG_fail;
24846 }
24847 resultobj = SWIG_Py_Void();
24848 return resultobj;
24849 fail:
24850 return NULL;
24851 }
24852
24853
24854 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24855 PyObject *resultobj = 0;
24856 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24857 wxCursor *result = 0 ;
24858 void *argp1 = 0 ;
24859 int res1 = 0 ;
24860 PyObject *swig_obj[1] ;
24861
24862 if (!args) SWIG_fail;
24863 swig_obj[0] = args;
24864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24865 if (!SWIG_IsOK(res1)) {
24866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24867 }
24868 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24869 {
24870 PyThreadState* __tstate = wxPyBeginAllowThreads();
24871 {
24872 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24873 result = (wxCursor *) &_result_ref;
24874 }
24875 wxPyEndAllowThreads(__tstate);
24876 if (PyErr_Occurred()) SWIG_fail;
24877 }
24878 {
24879 wxCursor* resultptr = new wxCursor(*result);
24880 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24881 }
24882 return resultobj;
24883 fail:
24884 return NULL;
24885 }
24886
24887
24888 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24889 PyObject *resultobj = 0;
24890 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24891 bool result;
24892 void *argp1 = 0 ;
24893 int res1 = 0 ;
24894 PyObject *swig_obj[1] ;
24895
24896 if (!args) SWIG_fail;
24897 swig_obj[0] = args;
24898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24899 if (!SWIG_IsOK(res1)) {
24900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24901 }
24902 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24903 {
24904 PyThreadState* __tstate = wxPyBeginAllowThreads();
24905 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24906 wxPyEndAllowThreads(__tstate);
24907 if (PyErr_Occurred()) SWIG_fail;
24908 }
24909 {
24910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24911 }
24912 return resultobj;
24913 fail:
24914 return NULL;
24915 }
24916
24917
24918 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24919 PyObject *obj;
24920 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24921 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24922 return SWIG_Py_Void();
24923 }
24924
24925 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24926 return SWIG_Python_InitShadowInstance(args);
24927 }
24928
24929 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24930 PyObject *resultobj = 0;
24931 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24932 wxKeyEvent *result = 0 ;
24933 int val1 ;
24934 int ecode1 = 0 ;
24935 PyObject * obj0 = 0 ;
24936 char * kwnames[] = {
24937 (char *) "eventType", NULL
24938 };
24939
24940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24941 if (obj0) {
24942 ecode1 = SWIG_AsVal_int(obj0, &val1);
24943 if (!SWIG_IsOK(ecode1)) {
24944 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24945 }
24946 arg1 = static_cast< wxEventType >(val1);
24947 }
24948 {
24949 PyThreadState* __tstate = wxPyBeginAllowThreads();
24950 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24951 wxPyEndAllowThreads(__tstate);
24952 if (PyErr_Occurred()) SWIG_fail;
24953 }
24954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24955 return resultobj;
24956 fail:
24957 return NULL;
24958 }
24959
24960
24961 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24962 PyObject *resultobj = 0;
24963 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24964 int result;
24965 void *argp1 = 0 ;
24966 int res1 = 0 ;
24967 PyObject *swig_obj[1] ;
24968
24969 if (!args) SWIG_fail;
24970 swig_obj[0] = args;
24971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24972 if (!SWIG_IsOK(res1)) {
24973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24974 }
24975 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24976 {
24977 PyThreadState* __tstate = wxPyBeginAllowThreads();
24978 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24979 wxPyEndAllowThreads(__tstate);
24980 if (PyErr_Occurred()) SWIG_fail;
24981 }
24982 resultobj = SWIG_From_int(static_cast< int >(result));
24983 return resultobj;
24984 fail:
24985 return NULL;
24986 }
24987
24988
24989 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24990 PyObject *resultobj = 0;
24991 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24992 bool result;
24993 void *argp1 = 0 ;
24994 int res1 = 0 ;
24995 PyObject *swig_obj[1] ;
24996
24997 if (!args) SWIG_fail;
24998 swig_obj[0] = args;
24999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25000 if (!SWIG_IsOK(res1)) {
25001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25002 }
25003 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25004 {
25005 PyThreadState* __tstate = wxPyBeginAllowThreads();
25006 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
25007 wxPyEndAllowThreads(__tstate);
25008 if (PyErr_Occurred()) SWIG_fail;
25009 }
25010 {
25011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25012 }
25013 return resultobj;
25014 fail:
25015 return NULL;
25016 }
25017
25018
25019 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25020 PyObject *resultobj = 0;
25021 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25022 bool result;
25023 void *argp1 = 0 ;
25024 int res1 = 0 ;
25025 PyObject *swig_obj[1] ;
25026
25027 if (!args) SWIG_fail;
25028 swig_obj[0] = args;
25029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25030 if (!SWIG_IsOK(res1)) {
25031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25032 }
25033 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25034 {
25035 PyThreadState* __tstate = wxPyBeginAllowThreads();
25036 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
25037 wxPyEndAllowThreads(__tstate);
25038 if (PyErr_Occurred()) SWIG_fail;
25039 }
25040 {
25041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25042 }
25043 return resultobj;
25044 fail:
25045 return NULL;
25046 }
25047
25048
25049 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25050 PyObject *resultobj = 0;
25051 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25052 bool result;
25053 void *argp1 = 0 ;
25054 int res1 = 0 ;
25055 PyObject *swig_obj[1] ;
25056
25057 if (!args) SWIG_fail;
25058 swig_obj[0] = args;
25059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25060 if (!SWIG_IsOK(res1)) {
25061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25062 }
25063 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25064 {
25065 PyThreadState* __tstate = wxPyBeginAllowThreads();
25066 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
25067 wxPyEndAllowThreads(__tstate);
25068 if (PyErr_Occurred()) SWIG_fail;
25069 }
25070 {
25071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25072 }
25073 return resultobj;
25074 fail:
25075 return NULL;
25076 }
25077
25078
25079 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25080 PyObject *resultobj = 0;
25081 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25082 bool result;
25083 void *argp1 = 0 ;
25084 int res1 = 0 ;
25085 PyObject *swig_obj[1] ;
25086
25087 if (!args) SWIG_fail;
25088 swig_obj[0] = args;
25089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25090 if (!SWIG_IsOK(res1)) {
25091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25092 }
25093 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25094 {
25095 PyThreadState* __tstate = wxPyBeginAllowThreads();
25096 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
25097 wxPyEndAllowThreads(__tstate);
25098 if (PyErr_Occurred()) SWIG_fail;
25099 }
25100 {
25101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25102 }
25103 return resultobj;
25104 fail:
25105 return NULL;
25106 }
25107
25108
25109 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25110 PyObject *resultobj = 0;
25111 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25112 bool result;
25113 void *argp1 = 0 ;
25114 int res1 = 0 ;
25115 PyObject *swig_obj[1] ;
25116
25117 if (!args) SWIG_fail;
25118 swig_obj[0] = args;
25119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25120 if (!SWIG_IsOK(res1)) {
25121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25122 }
25123 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25124 {
25125 PyThreadState* __tstate = wxPyBeginAllowThreads();
25126 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25127 wxPyEndAllowThreads(__tstate);
25128 if (PyErr_Occurred()) SWIG_fail;
25129 }
25130 {
25131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25132 }
25133 return resultobj;
25134 fail:
25135 return NULL;
25136 }
25137
25138
25139 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25140 PyObject *resultobj = 0;
25141 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25142 bool result;
25143 void *argp1 = 0 ;
25144 int res1 = 0 ;
25145 PyObject *swig_obj[1] ;
25146
25147 if (!args) SWIG_fail;
25148 swig_obj[0] = args;
25149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25150 if (!SWIG_IsOK(res1)) {
25151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25152 }
25153 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25154 {
25155 PyThreadState* __tstate = wxPyBeginAllowThreads();
25156 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25157 wxPyEndAllowThreads(__tstate);
25158 if (PyErr_Occurred()) SWIG_fail;
25159 }
25160 {
25161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25162 }
25163 return resultobj;
25164 fail:
25165 return NULL;
25166 }
25167
25168
25169 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25170 PyObject *resultobj = 0;
25171 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25172 int result;
25173 void *argp1 = 0 ;
25174 int res1 = 0 ;
25175 PyObject *swig_obj[1] ;
25176
25177 if (!args) SWIG_fail;
25178 swig_obj[0] = args;
25179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25180 if (!SWIG_IsOK(res1)) {
25181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25182 }
25183 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25184 {
25185 PyThreadState* __tstate = wxPyBeginAllowThreads();
25186 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25187 wxPyEndAllowThreads(__tstate);
25188 if (PyErr_Occurred()) SWIG_fail;
25189 }
25190 resultobj = SWIG_From_int(static_cast< int >(result));
25191 return resultobj;
25192 fail:
25193 return NULL;
25194 }
25195
25196
25197 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25198 PyObject *resultobj = 0;
25199 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25200 int result;
25201 void *argp1 = 0 ;
25202 int res1 = 0 ;
25203 PyObject *swig_obj[1] ;
25204
25205 if (!args) SWIG_fail;
25206 swig_obj[0] = args;
25207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25208 if (!SWIG_IsOK(res1)) {
25209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25210 }
25211 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25212 {
25213 PyThreadState* __tstate = wxPyBeginAllowThreads();
25214 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25215 wxPyEndAllowThreads(__tstate);
25216 if (PyErr_Occurred()) SWIG_fail;
25217 }
25218 resultobj = SWIG_From_int(static_cast< int >(result));
25219 return resultobj;
25220 fail:
25221 return NULL;
25222 }
25223
25224
25225 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25226 PyObject *resultobj = 0;
25227 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25228 int arg2 ;
25229 void *argp1 = 0 ;
25230 int res1 = 0 ;
25231 int val2 ;
25232 int ecode2 = 0 ;
25233 PyObject * obj0 = 0 ;
25234 PyObject * obj1 = 0 ;
25235 char * kwnames[] = {
25236 (char *) "self",(char *) "uniChar", NULL
25237 };
25238
25239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25241 if (!SWIG_IsOK(res1)) {
25242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25243 }
25244 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25245 ecode2 = SWIG_AsVal_int(obj1, &val2);
25246 if (!SWIG_IsOK(ecode2)) {
25247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25248 }
25249 arg2 = static_cast< int >(val2);
25250 {
25251 PyThreadState* __tstate = wxPyBeginAllowThreads();
25252 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25253 wxPyEndAllowThreads(__tstate);
25254 if (PyErr_Occurred()) SWIG_fail;
25255 }
25256 resultobj = SWIG_Py_Void();
25257 return resultobj;
25258 fail:
25259 return NULL;
25260 }
25261
25262
25263 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25264 PyObject *resultobj = 0;
25265 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25266 unsigned int result;
25267 void *argp1 = 0 ;
25268 int res1 = 0 ;
25269 PyObject *swig_obj[1] ;
25270
25271 if (!args) SWIG_fail;
25272 swig_obj[0] = args;
25273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25274 if (!SWIG_IsOK(res1)) {
25275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25276 }
25277 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25278 {
25279 PyThreadState* __tstate = wxPyBeginAllowThreads();
25280 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25281 wxPyEndAllowThreads(__tstate);
25282 if (PyErr_Occurred()) SWIG_fail;
25283 }
25284 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25285 return resultobj;
25286 fail:
25287 return NULL;
25288 }
25289
25290
25291 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25292 PyObject *resultobj = 0;
25293 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25294 unsigned int result;
25295 void *argp1 = 0 ;
25296 int res1 = 0 ;
25297 PyObject *swig_obj[1] ;
25298
25299 if (!args) SWIG_fail;
25300 swig_obj[0] = args;
25301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25302 if (!SWIG_IsOK(res1)) {
25303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25304 }
25305 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25306 {
25307 PyThreadState* __tstate = wxPyBeginAllowThreads();
25308 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25309 wxPyEndAllowThreads(__tstate);
25310 if (PyErr_Occurred()) SWIG_fail;
25311 }
25312 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25313 return resultobj;
25314 fail:
25315 return NULL;
25316 }
25317
25318
25319 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25320 PyObject *resultobj = 0;
25321 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25322 wxPoint result;
25323 void *argp1 = 0 ;
25324 int res1 = 0 ;
25325 PyObject *swig_obj[1] ;
25326
25327 if (!args) SWIG_fail;
25328 swig_obj[0] = args;
25329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25330 if (!SWIG_IsOK(res1)) {
25331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25332 }
25333 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25334 {
25335 PyThreadState* __tstate = wxPyBeginAllowThreads();
25336 result = (arg1)->GetPosition();
25337 wxPyEndAllowThreads(__tstate);
25338 if (PyErr_Occurred()) SWIG_fail;
25339 }
25340 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25341 return resultobj;
25342 fail:
25343 return NULL;
25344 }
25345
25346
25347 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25348 PyObject *resultobj = 0;
25349 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25350 long *arg2 = (long *) 0 ;
25351 long *arg3 = (long *) 0 ;
25352 void *argp1 = 0 ;
25353 int res1 = 0 ;
25354 long temp2 ;
25355 int res2 = SWIG_TMPOBJ ;
25356 long temp3 ;
25357 int res3 = SWIG_TMPOBJ ;
25358 PyObject *swig_obj[1] ;
25359
25360 arg2 = &temp2;
25361 arg3 = &temp3;
25362 if (!args) SWIG_fail;
25363 swig_obj[0] = args;
25364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25365 if (!SWIG_IsOK(res1)) {
25366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25367 }
25368 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25369 {
25370 PyThreadState* __tstate = wxPyBeginAllowThreads();
25371 (arg1)->GetPosition(arg2,arg3);
25372 wxPyEndAllowThreads(__tstate);
25373 if (PyErr_Occurred()) SWIG_fail;
25374 }
25375 resultobj = SWIG_Py_Void();
25376 if (SWIG_IsTmpObj(res2)) {
25377 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25378 } else {
25379 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25380 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25381 }
25382 if (SWIG_IsTmpObj(res3)) {
25383 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25384 } else {
25385 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25386 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25387 }
25388 return resultobj;
25389 fail:
25390 return NULL;
25391 }
25392
25393
25394 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25395 PyObject *resultobj = 0;
25396 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25397 int result;
25398 void *argp1 = 0 ;
25399 int res1 = 0 ;
25400 PyObject *swig_obj[1] ;
25401
25402 if (!args) SWIG_fail;
25403 swig_obj[0] = args;
25404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25405 if (!SWIG_IsOK(res1)) {
25406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25407 }
25408 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25409 {
25410 PyThreadState* __tstate = wxPyBeginAllowThreads();
25411 result = (int)((wxKeyEvent const *)arg1)->GetX();
25412 wxPyEndAllowThreads(__tstate);
25413 if (PyErr_Occurred()) SWIG_fail;
25414 }
25415 resultobj = SWIG_From_int(static_cast< int >(result));
25416 return resultobj;
25417 fail:
25418 return NULL;
25419 }
25420
25421
25422 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25423 PyObject *resultobj = 0;
25424 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25425 int result;
25426 void *argp1 = 0 ;
25427 int res1 = 0 ;
25428 PyObject *swig_obj[1] ;
25429
25430 if (!args) SWIG_fail;
25431 swig_obj[0] = args;
25432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25433 if (!SWIG_IsOK(res1)) {
25434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25435 }
25436 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25437 {
25438 PyThreadState* __tstate = wxPyBeginAllowThreads();
25439 result = (int)((wxKeyEvent const *)arg1)->GetY();
25440 wxPyEndAllowThreads(__tstate);
25441 if (PyErr_Occurred()) SWIG_fail;
25442 }
25443 resultobj = SWIG_From_int(static_cast< int >(result));
25444 return resultobj;
25445 fail:
25446 return NULL;
25447 }
25448
25449
25450 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25451 PyObject *resultobj = 0;
25452 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25453 int arg2 ;
25454 void *argp1 = 0 ;
25455 int res1 = 0 ;
25456 int val2 ;
25457 int ecode2 = 0 ;
25458 PyObject *swig_obj[2] ;
25459
25460 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25462 if (!SWIG_IsOK(res1)) {
25463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25464 }
25465 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25466 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25467 if (!SWIG_IsOK(ecode2)) {
25468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25469 }
25470 arg2 = static_cast< int >(val2);
25471 if (arg1) (arg1)->m_x = arg2;
25472
25473 resultobj = SWIG_Py_Void();
25474 return resultobj;
25475 fail:
25476 return NULL;
25477 }
25478
25479
25480 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25481 PyObject *resultobj = 0;
25482 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25483 int result;
25484 void *argp1 = 0 ;
25485 int res1 = 0 ;
25486 PyObject *swig_obj[1] ;
25487
25488 if (!args) SWIG_fail;
25489 swig_obj[0] = args;
25490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25491 if (!SWIG_IsOK(res1)) {
25492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25493 }
25494 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25495 result = (int) ((arg1)->m_x);
25496 resultobj = SWIG_From_int(static_cast< int >(result));
25497 return resultobj;
25498 fail:
25499 return NULL;
25500 }
25501
25502
25503 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25504 PyObject *resultobj = 0;
25505 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25506 int arg2 ;
25507 void *argp1 = 0 ;
25508 int res1 = 0 ;
25509 int val2 ;
25510 int ecode2 = 0 ;
25511 PyObject *swig_obj[2] ;
25512
25513 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25515 if (!SWIG_IsOK(res1)) {
25516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25517 }
25518 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25519 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25520 if (!SWIG_IsOK(ecode2)) {
25521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25522 }
25523 arg2 = static_cast< int >(val2);
25524 if (arg1) (arg1)->m_y = arg2;
25525
25526 resultobj = SWIG_Py_Void();
25527 return resultobj;
25528 fail:
25529 return NULL;
25530 }
25531
25532
25533 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25534 PyObject *resultobj = 0;
25535 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25536 int result;
25537 void *argp1 = 0 ;
25538 int res1 = 0 ;
25539 PyObject *swig_obj[1] ;
25540
25541 if (!args) SWIG_fail;
25542 swig_obj[0] = args;
25543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25544 if (!SWIG_IsOK(res1)) {
25545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25546 }
25547 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25548 result = (int) ((arg1)->m_y);
25549 resultobj = SWIG_From_int(static_cast< int >(result));
25550 return resultobj;
25551 fail:
25552 return NULL;
25553 }
25554
25555
25556 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25557 PyObject *resultobj = 0;
25558 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25559 long arg2 ;
25560 void *argp1 = 0 ;
25561 int res1 = 0 ;
25562 long val2 ;
25563 int ecode2 = 0 ;
25564 PyObject *swig_obj[2] ;
25565
25566 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25568 if (!SWIG_IsOK(res1)) {
25569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25570 }
25571 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25572 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25573 if (!SWIG_IsOK(ecode2)) {
25574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25575 }
25576 arg2 = static_cast< long >(val2);
25577 if (arg1) (arg1)->m_keyCode = arg2;
25578
25579 resultobj = SWIG_Py_Void();
25580 return resultobj;
25581 fail:
25582 return NULL;
25583 }
25584
25585
25586 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25587 PyObject *resultobj = 0;
25588 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25589 long result;
25590 void *argp1 = 0 ;
25591 int res1 = 0 ;
25592 PyObject *swig_obj[1] ;
25593
25594 if (!args) SWIG_fail;
25595 swig_obj[0] = args;
25596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25597 if (!SWIG_IsOK(res1)) {
25598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25599 }
25600 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25601 result = (long) ((arg1)->m_keyCode);
25602 resultobj = SWIG_From_long(static_cast< long >(result));
25603 return resultobj;
25604 fail:
25605 return NULL;
25606 }
25607
25608
25609 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25610 PyObject *resultobj = 0;
25611 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25612 bool arg2 ;
25613 void *argp1 = 0 ;
25614 int res1 = 0 ;
25615 bool val2 ;
25616 int ecode2 = 0 ;
25617 PyObject *swig_obj[2] ;
25618
25619 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25621 if (!SWIG_IsOK(res1)) {
25622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25623 }
25624 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25625 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25626 if (!SWIG_IsOK(ecode2)) {
25627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25628 }
25629 arg2 = static_cast< bool >(val2);
25630 if (arg1) (arg1)->m_controlDown = arg2;
25631
25632 resultobj = SWIG_Py_Void();
25633 return resultobj;
25634 fail:
25635 return NULL;
25636 }
25637
25638
25639 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25640 PyObject *resultobj = 0;
25641 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25642 bool result;
25643 void *argp1 = 0 ;
25644 int res1 = 0 ;
25645 PyObject *swig_obj[1] ;
25646
25647 if (!args) SWIG_fail;
25648 swig_obj[0] = args;
25649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25650 if (!SWIG_IsOK(res1)) {
25651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25652 }
25653 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25654 result = (bool) ((arg1)->m_controlDown);
25655 {
25656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25657 }
25658 return resultobj;
25659 fail:
25660 return NULL;
25661 }
25662
25663
25664 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25665 PyObject *resultobj = 0;
25666 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25667 bool arg2 ;
25668 void *argp1 = 0 ;
25669 int res1 = 0 ;
25670 bool val2 ;
25671 int ecode2 = 0 ;
25672 PyObject *swig_obj[2] ;
25673
25674 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25676 if (!SWIG_IsOK(res1)) {
25677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25678 }
25679 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25680 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25681 if (!SWIG_IsOK(ecode2)) {
25682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25683 }
25684 arg2 = static_cast< bool >(val2);
25685 if (arg1) (arg1)->m_shiftDown = arg2;
25686
25687 resultobj = SWIG_Py_Void();
25688 return resultobj;
25689 fail:
25690 return NULL;
25691 }
25692
25693
25694 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25695 PyObject *resultobj = 0;
25696 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25697 bool result;
25698 void *argp1 = 0 ;
25699 int res1 = 0 ;
25700 PyObject *swig_obj[1] ;
25701
25702 if (!args) SWIG_fail;
25703 swig_obj[0] = args;
25704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25705 if (!SWIG_IsOK(res1)) {
25706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25707 }
25708 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25709 result = (bool) ((arg1)->m_shiftDown);
25710 {
25711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25712 }
25713 return resultobj;
25714 fail:
25715 return NULL;
25716 }
25717
25718
25719 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25720 PyObject *resultobj = 0;
25721 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25722 bool arg2 ;
25723 void *argp1 = 0 ;
25724 int res1 = 0 ;
25725 bool val2 ;
25726 int ecode2 = 0 ;
25727 PyObject *swig_obj[2] ;
25728
25729 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25731 if (!SWIG_IsOK(res1)) {
25732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25733 }
25734 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25735 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25736 if (!SWIG_IsOK(ecode2)) {
25737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25738 }
25739 arg2 = static_cast< bool >(val2);
25740 if (arg1) (arg1)->m_altDown = arg2;
25741
25742 resultobj = SWIG_Py_Void();
25743 return resultobj;
25744 fail:
25745 return NULL;
25746 }
25747
25748
25749 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25750 PyObject *resultobj = 0;
25751 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25752 bool result;
25753 void *argp1 = 0 ;
25754 int res1 = 0 ;
25755 PyObject *swig_obj[1] ;
25756
25757 if (!args) SWIG_fail;
25758 swig_obj[0] = args;
25759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25760 if (!SWIG_IsOK(res1)) {
25761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25762 }
25763 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25764 result = (bool) ((arg1)->m_altDown);
25765 {
25766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25767 }
25768 return resultobj;
25769 fail:
25770 return NULL;
25771 }
25772
25773
25774 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25775 PyObject *resultobj = 0;
25776 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25777 bool arg2 ;
25778 void *argp1 = 0 ;
25779 int res1 = 0 ;
25780 bool val2 ;
25781 int ecode2 = 0 ;
25782 PyObject *swig_obj[2] ;
25783
25784 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25786 if (!SWIG_IsOK(res1)) {
25787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25788 }
25789 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25790 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25791 if (!SWIG_IsOK(ecode2)) {
25792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25793 }
25794 arg2 = static_cast< bool >(val2);
25795 if (arg1) (arg1)->m_metaDown = arg2;
25796
25797 resultobj = SWIG_Py_Void();
25798 return resultobj;
25799 fail:
25800 return NULL;
25801 }
25802
25803
25804 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25805 PyObject *resultobj = 0;
25806 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25807 bool result;
25808 void *argp1 = 0 ;
25809 int res1 = 0 ;
25810 PyObject *swig_obj[1] ;
25811
25812 if (!args) SWIG_fail;
25813 swig_obj[0] = args;
25814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25815 if (!SWIG_IsOK(res1)) {
25816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25817 }
25818 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25819 result = (bool) ((arg1)->m_metaDown);
25820 {
25821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25822 }
25823 return resultobj;
25824 fail:
25825 return NULL;
25826 }
25827
25828
25829 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25830 PyObject *resultobj = 0;
25831 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25832 bool arg2 ;
25833 void *argp1 = 0 ;
25834 int res1 = 0 ;
25835 bool val2 ;
25836 int ecode2 = 0 ;
25837 PyObject *swig_obj[2] ;
25838
25839 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25841 if (!SWIG_IsOK(res1)) {
25842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25843 }
25844 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25845 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25846 if (!SWIG_IsOK(ecode2)) {
25847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25848 }
25849 arg2 = static_cast< bool >(val2);
25850 if (arg1) (arg1)->m_scanCode = arg2;
25851
25852 resultobj = SWIG_Py_Void();
25853 return resultobj;
25854 fail:
25855 return NULL;
25856 }
25857
25858
25859 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25860 PyObject *resultobj = 0;
25861 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25862 bool result;
25863 void *argp1 = 0 ;
25864 int res1 = 0 ;
25865 PyObject *swig_obj[1] ;
25866
25867 if (!args) SWIG_fail;
25868 swig_obj[0] = args;
25869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25870 if (!SWIG_IsOK(res1)) {
25871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25872 }
25873 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25874 result = (bool) ((arg1)->m_scanCode);
25875 {
25876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25877 }
25878 return resultobj;
25879 fail:
25880 return NULL;
25881 }
25882
25883
25884 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25885 PyObject *resultobj = 0;
25886 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25887 unsigned int arg2 ;
25888 void *argp1 = 0 ;
25889 int res1 = 0 ;
25890 unsigned int val2 ;
25891 int ecode2 = 0 ;
25892 PyObject *swig_obj[2] ;
25893
25894 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25896 if (!SWIG_IsOK(res1)) {
25897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25898 }
25899 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25900 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25901 if (!SWIG_IsOK(ecode2)) {
25902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25903 }
25904 arg2 = static_cast< unsigned int >(val2);
25905 if (arg1) (arg1)->m_rawCode = arg2;
25906
25907 resultobj = SWIG_Py_Void();
25908 return resultobj;
25909 fail:
25910 return NULL;
25911 }
25912
25913
25914 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25915 PyObject *resultobj = 0;
25916 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25917 unsigned int result;
25918 void *argp1 = 0 ;
25919 int res1 = 0 ;
25920 PyObject *swig_obj[1] ;
25921
25922 if (!args) SWIG_fail;
25923 swig_obj[0] = args;
25924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25925 if (!SWIG_IsOK(res1)) {
25926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25927 }
25928 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25929 result = (unsigned int) ((arg1)->m_rawCode);
25930 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25931 return resultobj;
25932 fail:
25933 return NULL;
25934 }
25935
25936
25937 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25938 PyObject *resultobj = 0;
25939 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25940 unsigned int arg2 ;
25941 void *argp1 = 0 ;
25942 int res1 = 0 ;
25943 unsigned int val2 ;
25944 int ecode2 = 0 ;
25945 PyObject *swig_obj[2] ;
25946
25947 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25949 if (!SWIG_IsOK(res1)) {
25950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25951 }
25952 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25953 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25954 if (!SWIG_IsOK(ecode2)) {
25955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25956 }
25957 arg2 = static_cast< unsigned int >(val2);
25958 if (arg1) (arg1)->m_rawFlags = arg2;
25959
25960 resultobj = SWIG_Py_Void();
25961 return resultobj;
25962 fail:
25963 return NULL;
25964 }
25965
25966
25967 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25968 PyObject *resultobj = 0;
25969 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25970 unsigned int result;
25971 void *argp1 = 0 ;
25972 int res1 = 0 ;
25973 PyObject *swig_obj[1] ;
25974
25975 if (!args) SWIG_fail;
25976 swig_obj[0] = args;
25977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25978 if (!SWIG_IsOK(res1)) {
25979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25980 }
25981 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25982 result = (unsigned int) ((arg1)->m_rawFlags);
25983 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25984 return resultobj;
25985 fail:
25986 return NULL;
25987 }
25988
25989
25990 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25991 PyObject *obj;
25992 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25993 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25994 return SWIG_Py_Void();
25995 }
25996
25997 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25998 return SWIG_Python_InitShadowInstance(args);
25999 }
26000
26001 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26002 PyObject *resultobj = 0;
26003 wxSize const &arg1_defvalue = wxDefaultSize ;
26004 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
26005 int arg2 = (int) 0 ;
26006 wxSizeEvent *result = 0 ;
26007 wxSize temp1 ;
26008 int val2 ;
26009 int ecode2 = 0 ;
26010 PyObject * obj0 = 0 ;
26011 PyObject * obj1 = 0 ;
26012 char * kwnames[] = {
26013 (char *) "sz",(char *) "winid", NULL
26014 };
26015
26016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26017 if (obj0) {
26018 {
26019 arg1 = &temp1;
26020 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
26021 }
26022 }
26023 if (obj1) {
26024 ecode2 = SWIG_AsVal_int(obj1, &val2);
26025 if (!SWIG_IsOK(ecode2)) {
26026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
26027 }
26028 arg2 = static_cast< int >(val2);
26029 }
26030 {
26031 PyThreadState* __tstate = wxPyBeginAllowThreads();
26032 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
26033 wxPyEndAllowThreads(__tstate);
26034 if (PyErr_Occurred()) SWIG_fail;
26035 }
26036 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
26037 return resultobj;
26038 fail:
26039 return NULL;
26040 }
26041
26042
26043 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26044 PyObject *resultobj = 0;
26045 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26046 wxSize result;
26047 void *argp1 = 0 ;
26048 int res1 = 0 ;
26049 PyObject *swig_obj[1] ;
26050
26051 if (!args) SWIG_fail;
26052 swig_obj[0] = args;
26053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26054 if (!SWIG_IsOK(res1)) {
26055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26056 }
26057 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26058 {
26059 PyThreadState* __tstate = wxPyBeginAllowThreads();
26060 result = ((wxSizeEvent const *)arg1)->GetSize();
26061 wxPyEndAllowThreads(__tstate);
26062 if (PyErr_Occurred()) SWIG_fail;
26063 }
26064 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
26065 return resultobj;
26066 fail:
26067 return NULL;
26068 }
26069
26070
26071 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26072 PyObject *resultobj = 0;
26073 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26074 wxRect result;
26075 void *argp1 = 0 ;
26076 int res1 = 0 ;
26077 PyObject *swig_obj[1] ;
26078
26079 if (!args) SWIG_fail;
26080 swig_obj[0] = args;
26081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26082 if (!SWIG_IsOK(res1)) {
26083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26084 }
26085 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26086 {
26087 PyThreadState* __tstate = wxPyBeginAllowThreads();
26088 result = ((wxSizeEvent const *)arg1)->GetRect();
26089 wxPyEndAllowThreads(__tstate);
26090 if (PyErr_Occurred()) SWIG_fail;
26091 }
26092 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26093 return resultobj;
26094 fail:
26095 return NULL;
26096 }
26097
26098
26099 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26100 PyObject *resultobj = 0;
26101 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26102 wxRect arg2 ;
26103 void *argp1 = 0 ;
26104 int res1 = 0 ;
26105 void *argp2 ;
26106 int res2 = 0 ;
26107 PyObject * obj0 = 0 ;
26108 PyObject * obj1 = 0 ;
26109 char * kwnames[] = {
26110 (char *) "self",(char *) "rect", NULL
26111 };
26112
26113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26115 if (!SWIG_IsOK(res1)) {
26116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26117 }
26118 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26119 {
26120 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26121 if (!SWIG_IsOK(res2)) {
26122 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26123 }
26124 if (!argp2) {
26125 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26126 } else {
26127 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26128 arg2 = *temp;
26129 if (SWIG_IsNewObj(res2)) delete temp;
26130 }
26131 }
26132 {
26133 PyThreadState* __tstate = wxPyBeginAllowThreads();
26134 (arg1)->SetRect(arg2);
26135 wxPyEndAllowThreads(__tstate);
26136 if (PyErr_Occurred()) SWIG_fail;
26137 }
26138 resultobj = SWIG_Py_Void();
26139 return resultobj;
26140 fail:
26141 return NULL;
26142 }
26143
26144
26145 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26146 PyObject *resultobj = 0;
26147 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26148 wxSize arg2 ;
26149 void *argp1 = 0 ;
26150 int res1 = 0 ;
26151 void *argp2 ;
26152 int res2 = 0 ;
26153 PyObject * obj0 = 0 ;
26154 PyObject * obj1 = 0 ;
26155 char * kwnames[] = {
26156 (char *) "self",(char *) "size", NULL
26157 };
26158
26159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26161 if (!SWIG_IsOK(res1)) {
26162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26163 }
26164 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26165 {
26166 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26167 if (!SWIG_IsOK(res2)) {
26168 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26169 }
26170 if (!argp2) {
26171 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26172 } else {
26173 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26174 arg2 = *temp;
26175 if (SWIG_IsNewObj(res2)) delete temp;
26176 }
26177 }
26178 {
26179 PyThreadState* __tstate = wxPyBeginAllowThreads();
26180 wxSizeEvent_SetSize(arg1,arg2);
26181 wxPyEndAllowThreads(__tstate);
26182 if (PyErr_Occurred()) SWIG_fail;
26183 }
26184 resultobj = SWIG_Py_Void();
26185 return resultobj;
26186 fail:
26187 return NULL;
26188 }
26189
26190
26191 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26192 PyObject *resultobj = 0;
26193 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26194 wxSize *arg2 = (wxSize *) 0 ;
26195 void *argp1 = 0 ;
26196 int res1 = 0 ;
26197 void *argp2 = 0 ;
26198 int res2 = 0 ;
26199 PyObject *swig_obj[2] ;
26200
26201 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26203 if (!SWIG_IsOK(res1)) {
26204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26205 }
26206 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26207 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26208 if (!SWIG_IsOK(res2)) {
26209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26210 }
26211 arg2 = reinterpret_cast< wxSize * >(argp2);
26212 if (arg1) (arg1)->m_size = *arg2;
26213
26214 resultobj = SWIG_Py_Void();
26215 return resultobj;
26216 fail:
26217 return NULL;
26218 }
26219
26220
26221 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26222 PyObject *resultobj = 0;
26223 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26224 wxSize *result = 0 ;
26225 void *argp1 = 0 ;
26226 int res1 = 0 ;
26227 PyObject *swig_obj[1] ;
26228
26229 if (!args) SWIG_fail;
26230 swig_obj[0] = args;
26231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26232 if (!SWIG_IsOK(res1)) {
26233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26234 }
26235 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26236 result = (wxSize *)& ((arg1)->m_size);
26237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26238 return resultobj;
26239 fail:
26240 return NULL;
26241 }
26242
26243
26244 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26245 PyObject *resultobj = 0;
26246 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26247 wxRect *arg2 = (wxRect *) 0 ;
26248 void *argp1 = 0 ;
26249 int res1 = 0 ;
26250 void *argp2 = 0 ;
26251 int res2 = 0 ;
26252 PyObject *swig_obj[2] ;
26253
26254 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26256 if (!SWIG_IsOK(res1)) {
26257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26258 }
26259 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26260 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26261 if (!SWIG_IsOK(res2)) {
26262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26263 }
26264 arg2 = reinterpret_cast< wxRect * >(argp2);
26265 if (arg1) (arg1)->m_rect = *arg2;
26266
26267 resultobj = SWIG_Py_Void();
26268 return resultobj;
26269 fail:
26270 return NULL;
26271 }
26272
26273
26274 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26275 PyObject *resultobj = 0;
26276 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26277 wxRect *result = 0 ;
26278 void *argp1 = 0 ;
26279 int res1 = 0 ;
26280 PyObject *swig_obj[1] ;
26281
26282 if (!args) SWIG_fail;
26283 swig_obj[0] = args;
26284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26285 if (!SWIG_IsOK(res1)) {
26286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26287 }
26288 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26289 result = (wxRect *)& ((arg1)->m_rect);
26290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26291 return resultobj;
26292 fail:
26293 return NULL;
26294 }
26295
26296
26297 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26298 PyObject *obj;
26299 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26300 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26301 return SWIG_Py_Void();
26302 }
26303
26304 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26305 return SWIG_Python_InitShadowInstance(args);
26306 }
26307
26308 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26309 PyObject *resultobj = 0;
26310 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26311 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26312 int arg2 = (int) 0 ;
26313 wxMoveEvent *result = 0 ;
26314 wxPoint temp1 ;
26315 int val2 ;
26316 int ecode2 = 0 ;
26317 PyObject * obj0 = 0 ;
26318 PyObject * obj1 = 0 ;
26319 char * kwnames[] = {
26320 (char *) "pos",(char *) "winid", NULL
26321 };
26322
26323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26324 if (obj0) {
26325 {
26326 arg1 = &temp1;
26327 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26328 }
26329 }
26330 if (obj1) {
26331 ecode2 = SWIG_AsVal_int(obj1, &val2);
26332 if (!SWIG_IsOK(ecode2)) {
26333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26334 }
26335 arg2 = static_cast< int >(val2);
26336 }
26337 {
26338 PyThreadState* __tstate = wxPyBeginAllowThreads();
26339 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26340 wxPyEndAllowThreads(__tstate);
26341 if (PyErr_Occurred()) SWIG_fail;
26342 }
26343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26344 return resultobj;
26345 fail:
26346 return NULL;
26347 }
26348
26349
26350 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26351 PyObject *resultobj = 0;
26352 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26353 wxPoint result;
26354 void *argp1 = 0 ;
26355 int res1 = 0 ;
26356 PyObject *swig_obj[1] ;
26357
26358 if (!args) SWIG_fail;
26359 swig_obj[0] = args;
26360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26361 if (!SWIG_IsOK(res1)) {
26362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26363 }
26364 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26365 {
26366 PyThreadState* __tstate = wxPyBeginAllowThreads();
26367 result = ((wxMoveEvent const *)arg1)->GetPosition();
26368 wxPyEndAllowThreads(__tstate);
26369 if (PyErr_Occurred()) SWIG_fail;
26370 }
26371 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26372 return resultobj;
26373 fail:
26374 return NULL;
26375 }
26376
26377
26378 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26379 PyObject *resultobj = 0;
26380 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26381 wxRect result;
26382 void *argp1 = 0 ;
26383 int res1 = 0 ;
26384 PyObject *swig_obj[1] ;
26385
26386 if (!args) SWIG_fail;
26387 swig_obj[0] = args;
26388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26389 if (!SWIG_IsOK(res1)) {
26390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26391 }
26392 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26393 {
26394 PyThreadState* __tstate = wxPyBeginAllowThreads();
26395 result = ((wxMoveEvent const *)arg1)->GetRect();
26396 wxPyEndAllowThreads(__tstate);
26397 if (PyErr_Occurred()) SWIG_fail;
26398 }
26399 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26400 return resultobj;
26401 fail:
26402 return NULL;
26403 }
26404
26405
26406 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26407 PyObject *resultobj = 0;
26408 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26409 wxRect *arg2 = 0 ;
26410 void *argp1 = 0 ;
26411 int res1 = 0 ;
26412 wxRect temp2 ;
26413 PyObject * obj0 = 0 ;
26414 PyObject * obj1 = 0 ;
26415 char * kwnames[] = {
26416 (char *) "self",(char *) "rect", NULL
26417 };
26418
26419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26421 if (!SWIG_IsOK(res1)) {
26422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26423 }
26424 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26425 {
26426 arg2 = &temp2;
26427 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26428 }
26429 {
26430 PyThreadState* __tstate = wxPyBeginAllowThreads();
26431 (arg1)->SetRect((wxRect const &)*arg2);
26432 wxPyEndAllowThreads(__tstate);
26433 if (PyErr_Occurred()) SWIG_fail;
26434 }
26435 resultobj = SWIG_Py_Void();
26436 return resultobj;
26437 fail:
26438 return NULL;
26439 }
26440
26441
26442 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26443 PyObject *resultobj = 0;
26444 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26445 wxPoint *arg2 = 0 ;
26446 void *argp1 = 0 ;
26447 int res1 = 0 ;
26448 wxPoint temp2 ;
26449 PyObject * obj0 = 0 ;
26450 PyObject * obj1 = 0 ;
26451 char * kwnames[] = {
26452 (char *) "self",(char *) "pos", NULL
26453 };
26454
26455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26457 if (!SWIG_IsOK(res1)) {
26458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26459 }
26460 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26461 {
26462 arg2 = &temp2;
26463 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26464 }
26465 {
26466 PyThreadState* __tstate = wxPyBeginAllowThreads();
26467 (arg1)->SetPosition((wxPoint const &)*arg2);
26468 wxPyEndAllowThreads(__tstate);
26469 if (PyErr_Occurred()) SWIG_fail;
26470 }
26471 resultobj = SWIG_Py_Void();
26472 return resultobj;
26473 fail:
26474 return NULL;
26475 }
26476
26477
26478 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26479 PyObject *obj;
26480 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26481 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26482 return SWIG_Py_Void();
26483 }
26484
26485 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26486 return SWIG_Python_InitShadowInstance(args);
26487 }
26488
26489 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26490 PyObject *resultobj = 0;
26491 int arg1 = (int) 0 ;
26492 wxPaintEvent *result = 0 ;
26493 int val1 ;
26494 int ecode1 = 0 ;
26495 PyObject * obj0 = 0 ;
26496 char * kwnames[] = {
26497 (char *) "Id", NULL
26498 };
26499
26500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26501 if (obj0) {
26502 ecode1 = SWIG_AsVal_int(obj0, &val1);
26503 if (!SWIG_IsOK(ecode1)) {
26504 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26505 }
26506 arg1 = static_cast< int >(val1);
26507 }
26508 {
26509 PyThreadState* __tstate = wxPyBeginAllowThreads();
26510 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26511 wxPyEndAllowThreads(__tstate);
26512 if (PyErr_Occurred()) SWIG_fail;
26513 }
26514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26515 return resultobj;
26516 fail:
26517 return NULL;
26518 }
26519
26520
26521 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26522 PyObject *obj;
26523 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26524 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26525 return SWIG_Py_Void();
26526 }
26527
26528 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26529 return SWIG_Python_InitShadowInstance(args);
26530 }
26531
26532 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26533 PyObject *resultobj = 0;
26534 int arg1 = (int) 0 ;
26535 wxNcPaintEvent *result = 0 ;
26536 int val1 ;
26537 int ecode1 = 0 ;
26538 PyObject * obj0 = 0 ;
26539 char * kwnames[] = {
26540 (char *) "winid", NULL
26541 };
26542
26543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26544 if (obj0) {
26545 ecode1 = SWIG_AsVal_int(obj0, &val1);
26546 if (!SWIG_IsOK(ecode1)) {
26547 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26548 }
26549 arg1 = static_cast< int >(val1);
26550 }
26551 {
26552 PyThreadState* __tstate = wxPyBeginAllowThreads();
26553 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26554 wxPyEndAllowThreads(__tstate);
26555 if (PyErr_Occurred()) SWIG_fail;
26556 }
26557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26558 return resultobj;
26559 fail:
26560 return NULL;
26561 }
26562
26563
26564 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26565 PyObject *obj;
26566 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26567 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26568 return SWIG_Py_Void();
26569 }
26570
26571 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26572 return SWIG_Python_InitShadowInstance(args);
26573 }
26574
26575 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26576 PyObject *resultobj = 0;
26577 int arg1 = (int) 0 ;
26578 wxDC *arg2 = (wxDC *) NULL ;
26579 wxEraseEvent *result = 0 ;
26580 int val1 ;
26581 int ecode1 = 0 ;
26582 void *argp2 = 0 ;
26583 int res2 = 0 ;
26584 PyObject * obj0 = 0 ;
26585 PyObject * obj1 = 0 ;
26586 char * kwnames[] = {
26587 (char *) "Id",(char *) "dc", NULL
26588 };
26589
26590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26591 if (obj0) {
26592 ecode1 = SWIG_AsVal_int(obj0, &val1);
26593 if (!SWIG_IsOK(ecode1)) {
26594 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26595 }
26596 arg1 = static_cast< int >(val1);
26597 }
26598 if (obj1) {
26599 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26600 if (!SWIG_IsOK(res2)) {
26601 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26602 }
26603 arg2 = reinterpret_cast< wxDC * >(argp2);
26604 }
26605 {
26606 PyThreadState* __tstate = wxPyBeginAllowThreads();
26607 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26608 wxPyEndAllowThreads(__tstate);
26609 if (PyErr_Occurred()) SWIG_fail;
26610 }
26611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26612 return resultobj;
26613 fail:
26614 return NULL;
26615 }
26616
26617
26618 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26619 PyObject *resultobj = 0;
26620 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26621 wxDC *result = 0 ;
26622 void *argp1 = 0 ;
26623 int res1 = 0 ;
26624 PyObject *swig_obj[1] ;
26625
26626 if (!args) SWIG_fail;
26627 swig_obj[0] = args;
26628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26629 if (!SWIG_IsOK(res1)) {
26630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26631 }
26632 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26633 {
26634 PyThreadState* __tstate = wxPyBeginAllowThreads();
26635 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26636 wxPyEndAllowThreads(__tstate);
26637 if (PyErr_Occurred()) SWIG_fail;
26638 }
26639 {
26640 resultobj = wxPyMake_wxObject(result, (bool)0);
26641 }
26642 return resultobj;
26643 fail:
26644 return NULL;
26645 }
26646
26647
26648 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26649 PyObject *obj;
26650 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26651 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26652 return SWIG_Py_Void();
26653 }
26654
26655 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26656 return SWIG_Python_InitShadowInstance(args);
26657 }
26658
26659 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26660 PyObject *resultobj = 0;
26661 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26662 int arg2 = (int) 0 ;
26663 wxFocusEvent *result = 0 ;
26664 int val1 ;
26665 int ecode1 = 0 ;
26666 int val2 ;
26667 int ecode2 = 0 ;
26668 PyObject * obj0 = 0 ;
26669 PyObject * obj1 = 0 ;
26670 char * kwnames[] = {
26671 (char *) "type",(char *) "winid", NULL
26672 };
26673
26674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26675 if (obj0) {
26676 ecode1 = SWIG_AsVal_int(obj0, &val1);
26677 if (!SWIG_IsOK(ecode1)) {
26678 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26679 }
26680 arg1 = static_cast< wxEventType >(val1);
26681 }
26682 if (obj1) {
26683 ecode2 = SWIG_AsVal_int(obj1, &val2);
26684 if (!SWIG_IsOK(ecode2)) {
26685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26686 }
26687 arg2 = static_cast< int >(val2);
26688 }
26689 {
26690 PyThreadState* __tstate = wxPyBeginAllowThreads();
26691 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26692 wxPyEndAllowThreads(__tstate);
26693 if (PyErr_Occurred()) SWIG_fail;
26694 }
26695 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26696 return resultobj;
26697 fail:
26698 return NULL;
26699 }
26700
26701
26702 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26703 PyObject *resultobj = 0;
26704 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26705 wxWindow *result = 0 ;
26706 void *argp1 = 0 ;
26707 int res1 = 0 ;
26708 PyObject *swig_obj[1] ;
26709
26710 if (!args) SWIG_fail;
26711 swig_obj[0] = args;
26712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26713 if (!SWIG_IsOK(res1)) {
26714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26715 }
26716 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26717 {
26718 PyThreadState* __tstate = wxPyBeginAllowThreads();
26719 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26720 wxPyEndAllowThreads(__tstate);
26721 if (PyErr_Occurred()) SWIG_fail;
26722 }
26723 {
26724 resultobj = wxPyMake_wxObject(result, (bool)0);
26725 }
26726 return resultobj;
26727 fail:
26728 return NULL;
26729 }
26730
26731
26732 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26733 PyObject *resultobj = 0;
26734 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26735 wxWindow *arg2 = (wxWindow *) 0 ;
26736 void *argp1 = 0 ;
26737 int res1 = 0 ;
26738 void *argp2 = 0 ;
26739 int res2 = 0 ;
26740 PyObject * obj0 = 0 ;
26741 PyObject * obj1 = 0 ;
26742 char * kwnames[] = {
26743 (char *) "self",(char *) "win", NULL
26744 };
26745
26746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26748 if (!SWIG_IsOK(res1)) {
26749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26750 }
26751 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26752 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26753 if (!SWIG_IsOK(res2)) {
26754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26755 }
26756 arg2 = reinterpret_cast< wxWindow * >(argp2);
26757 {
26758 PyThreadState* __tstate = wxPyBeginAllowThreads();
26759 (arg1)->SetWindow(arg2);
26760 wxPyEndAllowThreads(__tstate);
26761 if (PyErr_Occurred()) SWIG_fail;
26762 }
26763 resultobj = SWIG_Py_Void();
26764 return resultobj;
26765 fail:
26766 return NULL;
26767 }
26768
26769
26770 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26771 PyObject *obj;
26772 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26773 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26774 return SWIG_Py_Void();
26775 }
26776
26777 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26778 return SWIG_Python_InitShadowInstance(args);
26779 }
26780
26781 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26782 PyObject *resultobj = 0;
26783 wxWindow *arg1 = (wxWindow *) NULL ;
26784 wxChildFocusEvent *result = 0 ;
26785 void *argp1 = 0 ;
26786 int res1 = 0 ;
26787 PyObject * obj0 = 0 ;
26788 char * kwnames[] = {
26789 (char *) "win", NULL
26790 };
26791
26792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26793 if (obj0) {
26794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26795 if (!SWIG_IsOK(res1)) {
26796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26797 }
26798 arg1 = reinterpret_cast< wxWindow * >(argp1);
26799 }
26800 {
26801 PyThreadState* __tstate = wxPyBeginAllowThreads();
26802 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26803 wxPyEndAllowThreads(__tstate);
26804 if (PyErr_Occurred()) SWIG_fail;
26805 }
26806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26807 return resultobj;
26808 fail:
26809 return NULL;
26810 }
26811
26812
26813 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26814 PyObject *resultobj = 0;
26815 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26816 wxWindow *result = 0 ;
26817 void *argp1 = 0 ;
26818 int res1 = 0 ;
26819 PyObject *swig_obj[1] ;
26820
26821 if (!args) SWIG_fail;
26822 swig_obj[0] = args;
26823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26824 if (!SWIG_IsOK(res1)) {
26825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26826 }
26827 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26828 {
26829 PyThreadState* __tstate = wxPyBeginAllowThreads();
26830 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26831 wxPyEndAllowThreads(__tstate);
26832 if (PyErr_Occurred()) SWIG_fail;
26833 }
26834 {
26835 resultobj = wxPyMake_wxObject(result, (bool)0);
26836 }
26837 return resultobj;
26838 fail:
26839 return NULL;
26840 }
26841
26842
26843 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26844 PyObject *obj;
26845 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26846 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26847 return SWIG_Py_Void();
26848 }
26849
26850 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26851 return SWIG_Python_InitShadowInstance(args);
26852 }
26853
26854 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26855 PyObject *resultobj = 0;
26856 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26857 bool arg2 = (bool) true ;
26858 int arg3 = (int) 0 ;
26859 wxActivateEvent *result = 0 ;
26860 int val1 ;
26861 int ecode1 = 0 ;
26862 bool val2 ;
26863 int ecode2 = 0 ;
26864 int val3 ;
26865 int ecode3 = 0 ;
26866 PyObject * obj0 = 0 ;
26867 PyObject * obj1 = 0 ;
26868 PyObject * obj2 = 0 ;
26869 char * kwnames[] = {
26870 (char *) "type",(char *) "active",(char *) "Id", NULL
26871 };
26872
26873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26874 if (obj0) {
26875 ecode1 = SWIG_AsVal_int(obj0, &val1);
26876 if (!SWIG_IsOK(ecode1)) {
26877 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26878 }
26879 arg1 = static_cast< wxEventType >(val1);
26880 }
26881 if (obj1) {
26882 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26883 if (!SWIG_IsOK(ecode2)) {
26884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26885 }
26886 arg2 = static_cast< bool >(val2);
26887 }
26888 if (obj2) {
26889 ecode3 = SWIG_AsVal_int(obj2, &val3);
26890 if (!SWIG_IsOK(ecode3)) {
26891 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26892 }
26893 arg3 = static_cast< int >(val3);
26894 }
26895 {
26896 PyThreadState* __tstate = wxPyBeginAllowThreads();
26897 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26898 wxPyEndAllowThreads(__tstate);
26899 if (PyErr_Occurred()) SWIG_fail;
26900 }
26901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26902 return resultobj;
26903 fail:
26904 return NULL;
26905 }
26906
26907
26908 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26909 PyObject *resultobj = 0;
26910 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26911 bool result;
26912 void *argp1 = 0 ;
26913 int res1 = 0 ;
26914 PyObject *swig_obj[1] ;
26915
26916 if (!args) SWIG_fail;
26917 swig_obj[0] = args;
26918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26919 if (!SWIG_IsOK(res1)) {
26920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26921 }
26922 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26923 {
26924 PyThreadState* __tstate = wxPyBeginAllowThreads();
26925 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26926 wxPyEndAllowThreads(__tstate);
26927 if (PyErr_Occurred()) SWIG_fail;
26928 }
26929 {
26930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26931 }
26932 return resultobj;
26933 fail:
26934 return NULL;
26935 }
26936
26937
26938 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26939 PyObject *obj;
26940 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26941 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26942 return SWIG_Py_Void();
26943 }
26944
26945 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26946 return SWIG_Python_InitShadowInstance(args);
26947 }
26948
26949 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26950 PyObject *resultobj = 0;
26951 int arg1 = (int) 0 ;
26952 wxInitDialogEvent *result = 0 ;
26953 int val1 ;
26954 int ecode1 = 0 ;
26955 PyObject * obj0 = 0 ;
26956 char * kwnames[] = {
26957 (char *) "Id", NULL
26958 };
26959
26960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26961 if (obj0) {
26962 ecode1 = SWIG_AsVal_int(obj0, &val1);
26963 if (!SWIG_IsOK(ecode1)) {
26964 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26965 }
26966 arg1 = static_cast< int >(val1);
26967 }
26968 {
26969 PyThreadState* __tstate = wxPyBeginAllowThreads();
26970 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26971 wxPyEndAllowThreads(__tstate);
26972 if (PyErr_Occurred()) SWIG_fail;
26973 }
26974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26975 return resultobj;
26976 fail:
26977 return NULL;
26978 }
26979
26980
26981 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26982 PyObject *obj;
26983 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26984 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26985 return SWIG_Py_Void();
26986 }
26987
26988 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26989 return SWIG_Python_InitShadowInstance(args);
26990 }
26991
26992 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26993 PyObject *resultobj = 0;
26994 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26995 int arg2 = (int) 0 ;
26996 wxMenu *arg3 = (wxMenu *) NULL ;
26997 wxMenuEvent *result = 0 ;
26998 int val1 ;
26999 int ecode1 = 0 ;
27000 int val2 ;
27001 int ecode2 = 0 ;
27002 void *argp3 = 0 ;
27003 int res3 = 0 ;
27004 PyObject * obj0 = 0 ;
27005 PyObject * obj1 = 0 ;
27006 PyObject * obj2 = 0 ;
27007 char * kwnames[] = {
27008 (char *) "type",(char *) "winid",(char *) "menu", NULL
27009 };
27010
27011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27012 if (obj0) {
27013 ecode1 = SWIG_AsVal_int(obj0, &val1);
27014 if (!SWIG_IsOK(ecode1)) {
27015 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27016 }
27017 arg1 = static_cast< wxEventType >(val1);
27018 }
27019 if (obj1) {
27020 ecode2 = SWIG_AsVal_int(obj1, &val2);
27021 if (!SWIG_IsOK(ecode2)) {
27022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
27023 }
27024 arg2 = static_cast< int >(val2);
27025 }
27026 if (obj2) {
27027 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
27028 if (!SWIG_IsOK(res3)) {
27029 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
27030 }
27031 arg3 = reinterpret_cast< wxMenu * >(argp3);
27032 }
27033 {
27034 PyThreadState* __tstate = wxPyBeginAllowThreads();
27035 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
27036 wxPyEndAllowThreads(__tstate);
27037 if (PyErr_Occurred()) SWIG_fail;
27038 }
27039 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
27040 return resultobj;
27041 fail:
27042 return NULL;
27043 }
27044
27045
27046 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27047 PyObject *resultobj = 0;
27048 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27049 int result;
27050 void *argp1 = 0 ;
27051 int res1 = 0 ;
27052 PyObject *swig_obj[1] ;
27053
27054 if (!args) SWIG_fail;
27055 swig_obj[0] = args;
27056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27057 if (!SWIG_IsOK(res1)) {
27058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27059 }
27060 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27061 {
27062 PyThreadState* __tstate = wxPyBeginAllowThreads();
27063 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
27064 wxPyEndAllowThreads(__tstate);
27065 if (PyErr_Occurred()) SWIG_fail;
27066 }
27067 resultobj = SWIG_From_int(static_cast< int >(result));
27068 return resultobj;
27069 fail:
27070 return NULL;
27071 }
27072
27073
27074 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27075 PyObject *resultobj = 0;
27076 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27077 bool result;
27078 void *argp1 = 0 ;
27079 int res1 = 0 ;
27080 PyObject *swig_obj[1] ;
27081
27082 if (!args) SWIG_fail;
27083 swig_obj[0] = args;
27084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27085 if (!SWIG_IsOK(res1)) {
27086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27087 }
27088 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27089 {
27090 PyThreadState* __tstate = wxPyBeginAllowThreads();
27091 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
27092 wxPyEndAllowThreads(__tstate);
27093 if (PyErr_Occurred()) SWIG_fail;
27094 }
27095 {
27096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27097 }
27098 return resultobj;
27099 fail:
27100 return NULL;
27101 }
27102
27103
27104 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27105 PyObject *resultobj = 0;
27106 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27107 wxMenu *result = 0 ;
27108 void *argp1 = 0 ;
27109 int res1 = 0 ;
27110 PyObject *swig_obj[1] ;
27111
27112 if (!args) SWIG_fail;
27113 swig_obj[0] = args;
27114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27115 if (!SWIG_IsOK(res1)) {
27116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27117 }
27118 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27119 {
27120 PyThreadState* __tstate = wxPyBeginAllowThreads();
27121 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27122 wxPyEndAllowThreads(__tstate);
27123 if (PyErr_Occurred()) SWIG_fail;
27124 }
27125 {
27126 resultobj = wxPyMake_wxObject(result, (bool)0);
27127 }
27128 return resultobj;
27129 fail:
27130 return NULL;
27131 }
27132
27133
27134 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27135 PyObject *obj;
27136 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27137 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27138 return SWIG_Py_Void();
27139 }
27140
27141 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27142 return SWIG_Python_InitShadowInstance(args);
27143 }
27144
27145 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27146 PyObject *resultobj = 0;
27147 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27148 int arg2 = (int) 0 ;
27149 wxCloseEvent *result = 0 ;
27150 int val1 ;
27151 int ecode1 = 0 ;
27152 int val2 ;
27153 int ecode2 = 0 ;
27154 PyObject * obj0 = 0 ;
27155 PyObject * obj1 = 0 ;
27156 char * kwnames[] = {
27157 (char *) "type",(char *) "winid", NULL
27158 };
27159
27160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27161 if (obj0) {
27162 ecode1 = SWIG_AsVal_int(obj0, &val1);
27163 if (!SWIG_IsOK(ecode1)) {
27164 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27165 }
27166 arg1 = static_cast< wxEventType >(val1);
27167 }
27168 if (obj1) {
27169 ecode2 = SWIG_AsVal_int(obj1, &val2);
27170 if (!SWIG_IsOK(ecode2)) {
27171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27172 }
27173 arg2 = static_cast< int >(val2);
27174 }
27175 {
27176 PyThreadState* __tstate = wxPyBeginAllowThreads();
27177 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27178 wxPyEndAllowThreads(__tstate);
27179 if (PyErr_Occurred()) SWIG_fail;
27180 }
27181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27182 return resultobj;
27183 fail:
27184 return NULL;
27185 }
27186
27187
27188 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27189 PyObject *resultobj = 0;
27190 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27191 bool arg2 ;
27192 void *argp1 = 0 ;
27193 int res1 = 0 ;
27194 bool val2 ;
27195 int ecode2 = 0 ;
27196 PyObject * obj0 = 0 ;
27197 PyObject * obj1 = 0 ;
27198 char * kwnames[] = {
27199 (char *) "self",(char *) "logOff", NULL
27200 };
27201
27202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27204 if (!SWIG_IsOK(res1)) {
27205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27206 }
27207 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27208 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27209 if (!SWIG_IsOK(ecode2)) {
27210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27211 }
27212 arg2 = static_cast< bool >(val2);
27213 {
27214 PyThreadState* __tstate = wxPyBeginAllowThreads();
27215 (arg1)->SetLoggingOff(arg2);
27216 wxPyEndAllowThreads(__tstate);
27217 if (PyErr_Occurred()) SWIG_fail;
27218 }
27219 resultobj = SWIG_Py_Void();
27220 return resultobj;
27221 fail:
27222 return NULL;
27223 }
27224
27225
27226 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27227 PyObject *resultobj = 0;
27228 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27229 bool result;
27230 void *argp1 = 0 ;
27231 int res1 = 0 ;
27232 PyObject *swig_obj[1] ;
27233
27234 if (!args) SWIG_fail;
27235 swig_obj[0] = args;
27236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27237 if (!SWIG_IsOK(res1)) {
27238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27239 }
27240 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27241 {
27242 PyThreadState* __tstate = wxPyBeginAllowThreads();
27243 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27244 wxPyEndAllowThreads(__tstate);
27245 if (PyErr_Occurred()) SWIG_fail;
27246 }
27247 {
27248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27249 }
27250 return resultobj;
27251 fail:
27252 return NULL;
27253 }
27254
27255
27256 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27257 PyObject *resultobj = 0;
27258 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27259 bool arg2 = (bool) true ;
27260 void *argp1 = 0 ;
27261 int res1 = 0 ;
27262 bool val2 ;
27263 int ecode2 = 0 ;
27264 PyObject * obj0 = 0 ;
27265 PyObject * obj1 = 0 ;
27266 char * kwnames[] = {
27267 (char *) "self",(char *) "veto", NULL
27268 };
27269
27270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27272 if (!SWIG_IsOK(res1)) {
27273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27274 }
27275 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27276 if (obj1) {
27277 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27278 if (!SWIG_IsOK(ecode2)) {
27279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27280 }
27281 arg2 = static_cast< bool >(val2);
27282 }
27283 {
27284 PyThreadState* __tstate = wxPyBeginAllowThreads();
27285 (arg1)->Veto(arg2);
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_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27297 PyObject *resultobj = 0;
27298 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27299 bool result;
27300 void *argp1 = 0 ;
27301 int res1 = 0 ;
27302 PyObject *swig_obj[1] ;
27303
27304 if (!args) SWIG_fail;
27305 swig_obj[0] = args;
27306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27307 if (!SWIG_IsOK(res1)) {
27308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27309 }
27310 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27311 {
27312 PyThreadState* __tstate = wxPyBeginAllowThreads();
27313 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27314 wxPyEndAllowThreads(__tstate);
27315 if (PyErr_Occurred()) SWIG_fail;
27316 }
27317 {
27318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27319 }
27320 return resultobj;
27321 fail:
27322 return NULL;
27323 }
27324
27325
27326 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27327 PyObject *resultobj = 0;
27328 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27329 bool arg2 ;
27330 void *argp1 = 0 ;
27331 int res1 = 0 ;
27332 bool val2 ;
27333 int ecode2 = 0 ;
27334 PyObject * obj0 = 0 ;
27335 PyObject * obj1 = 0 ;
27336 char * kwnames[] = {
27337 (char *) "self",(char *) "canVeto", NULL
27338 };
27339
27340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27342 if (!SWIG_IsOK(res1)) {
27343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27344 }
27345 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27346 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27347 if (!SWIG_IsOK(ecode2)) {
27348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27349 }
27350 arg2 = static_cast< bool >(val2);
27351 {
27352 PyThreadState* __tstate = wxPyBeginAllowThreads();
27353 (arg1)->SetCanVeto(arg2);
27354 wxPyEndAllowThreads(__tstate);
27355 if (PyErr_Occurred()) SWIG_fail;
27356 }
27357 resultobj = SWIG_Py_Void();
27358 return resultobj;
27359 fail:
27360 return NULL;
27361 }
27362
27363
27364 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27365 PyObject *resultobj = 0;
27366 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27367 bool result;
27368 void *argp1 = 0 ;
27369 int res1 = 0 ;
27370 PyObject *swig_obj[1] ;
27371
27372 if (!args) SWIG_fail;
27373 swig_obj[0] = args;
27374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27375 if (!SWIG_IsOK(res1)) {
27376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27377 }
27378 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27379 {
27380 PyThreadState* __tstate = wxPyBeginAllowThreads();
27381 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27382 wxPyEndAllowThreads(__tstate);
27383 if (PyErr_Occurred()) SWIG_fail;
27384 }
27385 {
27386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27387 }
27388 return resultobj;
27389 fail:
27390 return NULL;
27391 }
27392
27393
27394 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27395 PyObject *obj;
27396 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27397 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27398 return SWIG_Py_Void();
27399 }
27400
27401 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27402 return SWIG_Python_InitShadowInstance(args);
27403 }
27404
27405 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27406 PyObject *resultobj = 0;
27407 int arg1 = (int) 0 ;
27408 bool arg2 = (bool) false ;
27409 wxShowEvent *result = 0 ;
27410 int val1 ;
27411 int ecode1 = 0 ;
27412 bool val2 ;
27413 int ecode2 = 0 ;
27414 PyObject * obj0 = 0 ;
27415 PyObject * obj1 = 0 ;
27416 char * kwnames[] = {
27417 (char *) "winid",(char *) "show", NULL
27418 };
27419
27420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27421 if (obj0) {
27422 ecode1 = SWIG_AsVal_int(obj0, &val1);
27423 if (!SWIG_IsOK(ecode1)) {
27424 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27425 }
27426 arg1 = static_cast< int >(val1);
27427 }
27428 if (obj1) {
27429 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27430 if (!SWIG_IsOK(ecode2)) {
27431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27432 }
27433 arg2 = static_cast< bool >(val2);
27434 }
27435 {
27436 PyThreadState* __tstate = wxPyBeginAllowThreads();
27437 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27438 wxPyEndAllowThreads(__tstate);
27439 if (PyErr_Occurred()) SWIG_fail;
27440 }
27441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27442 return resultobj;
27443 fail:
27444 return NULL;
27445 }
27446
27447
27448 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27449 PyObject *resultobj = 0;
27450 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27451 bool arg2 ;
27452 void *argp1 = 0 ;
27453 int res1 = 0 ;
27454 bool val2 ;
27455 int ecode2 = 0 ;
27456 PyObject * obj0 = 0 ;
27457 PyObject * obj1 = 0 ;
27458 char * kwnames[] = {
27459 (char *) "self",(char *) "show", NULL
27460 };
27461
27462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27464 if (!SWIG_IsOK(res1)) {
27465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27466 }
27467 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27468 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27469 if (!SWIG_IsOK(ecode2)) {
27470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27471 }
27472 arg2 = static_cast< bool >(val2);
27473 {
27474 PyThreadState* __tstate = wxPyBeginAllowThreads();
27475 (arg1)->SetShow(arg2);
27476 wxPyEndAllowThreads(__tstate);
27477 if (PyErr_Occurred()) SWIG_fail;
27478 }
27479 resultobj = SWIG_Py_Void();
27480 return resultobj;
27481 fail:
27482 return NULL;
27483 }
27484
27485
27486 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27487 PyObject *resultobj = 0;
27488 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27489 bool result;
27490 void *argp1 = 0 ;
27491 int res1 = 0 ;
27492 PyObject *swig_obj[1] ;
27493
27494 if (!args) SWIG_fail;
27495 swig_obj[0] = args;
27496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27497 if (!SWIG_IsOK(res1)) {
27498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27499 }
27500 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27501 {
27502 PyThreadState* __tstate = wxPyBeginAllowThreads();
27503 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27504 wxPyEndAllowThreads(__tstate);
27505 if (PyErr_Occurred()) SWIG_fail;
27506 }
27507 {
27508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27509 }
27510 return resultobj;
27511 fail:
27512 return NULL;
27513 }
27514
27515
27516 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27517 PyObject *obj;
27518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27519 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27520 return SWIG_Py_Void();
27521 }
27522
27523 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27524 return SWIG_Python_InitShadowInstance(args);
27525 }
27526
27527 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27528 PyObject *resultobj = 0;
27529 int arg1 = (int) 0 ;
27530 bool arg2 = (bool) true ;
27531 wxIconizeEvent *result = 0 ;
27532 int val1 ;
27533 int ecode1 = 0 ;
27534 bool val2 ;
27535 int ecode2 = 0 ;
27536 PyObject * obj0 = 0 ;
27537 PyObject * obj1 = 0 ;
27538 char * kwnames[] = {
27539 (char *) "id",(char *) "iconized", NULL
27540 };
27541
27542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27543 if (obj0) {
27544 ecode1 = SWIG_AsVal_int(obj0, &val1);
27545 if (!SWIG_IsOK(ecode1)) {
27546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27547 }
27548 arg1 = static_cast< int >(val1);
27549 }
27550 if (obj1) {
27551 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27552 if (!SWIG_IsOK(ecode2)) {
27553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27554 }
27555 arg2 = static_cast< bool >(val2);
27556 }
27557 {
27558 PyThreadState* __tstate = wxPyBeginAllowThreads();
27559 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27560 wxPyEndAllowThreads(__tstate);
27561 if (PyErr_Occurred()) SWIG_fail;
27562 }
27563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27564 return resultobj;
27565 fail:
27566 return NULL;
27567 }
27568
27569
27570 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27571 PyObject *resultobj = 0;
27572 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27573 bool result;
27574 void *argp1 = 0 ;
27575 int res1 = 0 ;
27576 PyObject *swig_obj[1] ;
27577
27578 if (!args) SWIG_fail;
27579 swig_obj[0] = args;
27580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27581 if (!SWIG_IsOK(res1)) {
27582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27583 }
27584 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27585 {
27586 PyThreadState* __tstate = wxPyBeginAllowThreads();
27587 result = (bool)(arg1)->Iconized();
27588 wxPyEndAllowThreads(__tstate);
27589 if (PyErr_Occurred()) SWIG_fail;
27590 }
27591 {
27592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27593 }
27594 return resultobj;
27595 fail:
27596 return NULL;
27597 }
27598
27599
27600 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27601 PyObject *obj;
27602 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27603 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27604 return SWIG_Py_Void();
27605 }
27606
27607 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27608 return SWIG_Python_InitShadowInstance(args);
27609 }
27610
27611 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27612 PyObject *resultobj = 0;
27613 int arg1 = (int) 0 ;
27614 wxMaximizeEvent *result = 0 ;
27615 int val1 ;
27616 int ecode1 = 0 ;
27617 PyObject * obj0 = 0 ;
27618 char * kwnames[] = {
27619 (char *) "id", NULL
27620 };
27621
27622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27623 if (obj0) {
27624 ecode1 = SWIG_AsVal_int(obj0, &val1);
27625 if (!SWIG_IsOK(ecode1)) {
27626 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27627 }
27628 arg1 = static_cast< int >(val1);
27629 }
27630 {
27631 PyThreadState* __tstate = wxPyBeginAllowThreads();
27632 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27633 wxPyEndAllowThreads(__tstate);
27634 if (PyErr_Occurred()) SWIG_fail;
27635 }
27636 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27637 return resultobj;
27638 fail:
27639 return NULL;
27640 }
27641
27642
27643 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27644 PyObject *obj;
27645 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27646 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27647 return SWIG_Py_Void();
27648 }
27649
27650 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27651 return SWIG_Python_InitShadowInstance(args);
27652 }
27653
27654 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27655 PyObject *resultobj = 0;
27656 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27657 wxPoint result;
27658 void *argp1 = 0 ;
27659 int res1 = 0 ;
27660 PyObject *swig_obj[1] ;
27661
27662 if (!args) SWIG_fail;
27663 swig_obj[0] = args;
27664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27665 if (!SWIG_IsOK(res1)) {
27666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27667 }
27668 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27669 {
27670 PyThreadState* __tstate = wxPyBeginAllowThreads();
27671 result = (arg1)->GetPosition();
27672 wxPyEndAllowThreads(__tstate);
27673 if (PyErr_Occurred()) SWIG_fail;
27674 }
27675 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27676 return resultobj;
27677 fail:
27678 return NULL;
27679 }
27680
27681
27682 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27683 PyObject *resultobj = 0;
27684 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27685 int result;
27686 void *argp1 = 0 ;
27687 int res1 = 0 ;
27688 PyObject *swig_obj[1] ;
27689
27690 if (!args) SWIG_fail;
27691 swig_obj[0] = args;
27692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27693 if (!SWIG_IsOK(res1)) {
27694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27695 }
27696 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27697 {
27698 PyThreadState* __tstate = wxPyBeginAllowThreads();
27699 result = (int)(arg1)->GetNumberOfFiles();
27700 wxPyEndAllowThreads(__tstate);
27701 if (PyErr_Occurred()) SWIG_fail;
27702 }
27703 resultobj = SWIG_From_int(static_cast< int >(result));
27704 return resultobj;
27705 fail:
27706 return NULL;
27707 }
27708
27709
27710 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27711 PyObject *resultobj = 0;
27712 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27713 PyObject *result = 0 ;
27714 void *argp1 = 0 ;
27715 int res1 = 0 ;
27716 PyObject *swig_obj[1] ;
27717
27718 if (!args) SWIG_fail;
27719 swig_obj[0] = args;
27720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27721 if (!SWIG_IsOK(res1)) {
27722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27723 }
27724 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27725 {
27726 PyThreadState* __tstate = wxPyBeginAllowThreads();
27727 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27728 wxPyEndAllowThreads(__tstate);
27729 if (PyErr_Occurred()) SWIG_fail;
27730 }
27731 resultobj = result;
27732 return resultobj;
27733 fail:
27734 return NULL;
27735 }
27736
27737
27738 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27739 PyObject *obj;
27740 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27741 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27742 return SWIG_Py_Void();
27743 }
27744
27745 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27746 PyObject *resultobj = 0;
27747 int arg1 = (int) 0 ;
27748 wxUpdateUIEvent *result = 0 ;
27749 int val1 ;
27750 int ecode1 = 0 ;
27751 PyObject * obj0 = 0 ;
27752 char * kwnames[] = {
27753 (char *) "commandId", NULL
27754 };
27755
27756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27757 if (obj0) {
27758 ecode1 = SWIG_AsVal_int(obj0, &val1);
27759 if (!SWIG_IsOK(ecode1)) {
27760 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27761 }
27762 arg1 = static_cast< int >(val1);
27763 }
27764 {
27765 PyThreadState* __tstate = wxPyBeginAllowThreads();
27766 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27767 wxPyEndAllowThreads(__tstate);
27768 if (PyErr_Occurred()) SWIG_fail;
27769 }
27770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27771 return resultobj;
27772 fail:
27773 return NULL;
27774 }
27775
27776
27777 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27778 PyObject *resultobj = 0;
27779 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27780 bool result;
27781 void *argp1 = 0 ;
27782 int res1 = 0 ;
27783 PyObject *swig_obj[1] ;
27784
27785 if (!args) SWIG_fail;
27786 swig_obj[0] = args;
27787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27788 if (!SWIG_IsOK(res1)) {
27789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27790 }
27791 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27792 {
27793 PyThreadState* __tstate = wxPyBeginAllowThreads();
27794 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27795 wxPyEndAllowThreads(__tstate);
27796 if (PyErr_Occurred()) SWIG_fail;
27797 }
27798 {
27799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27800 }
27801 return resultobj;
27802 fail:
27803 return NULL;
27804 }
27805
27806
27807 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27808 PyObject *resultobj = 0;
27809 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27810 bool result;
27811 void *argp1 = 0 ;
27812 int res1 = 0 ;
27813 PyObject *swig_obj[1] ;
27814
27815 if (!args) SWIG_fail;
27816 swig_obj[0] = args;
27817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27818 if (!SWIG_IsOK(res1)) {
27819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27820 }
27821 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27822 {
27823 PyThreadState* __tstate = wxPyBeginAllowThreads();
27824 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27825 wxPyEndAllowThreads(__tstate);
27826 if (PyErr_Occurred()) SWIG_fail;
27827 }
27828 {
27829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27830 }
27831 return resultobj;
27832 fail:
27833 return NULL;
27834 }
27835
27836
27837 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27838 PyObject *resultobj = 0;
27839 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27840 bool result;
27841 void *argp1 = 0 ;
27842 int res1 = 0 ;
27843 PyObject *swig_obj[1] ;
27844
27845 if (!args) SWIG_fail;
27846 swig_obj[0] = args;
27847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27848 if (!SWIG_IsOK(res1)) {
27849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27850 }
27851 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27852 {
27853 PyThreadState* __tstate = wxPyBeginAllowThreads();
27854 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27855 wxPyEndAllowThreads(__tstate);
27856 if (PyErr_Occurred()) SWIG_fail;
27857 }
27858 {
27859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27860 }
27861 return resultobj;
27862 fail:
27863 return NULL;
27864 }
27865
27866
27867 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27868 PyObject *resultobj = 0;
27869 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27870 wxString result;
27871 void *argp1 = 0 ;
27872 int res1 = 0 ;
27873 PyObject *swig_obj[1] ;
27874
27875 if (!args) SWIG_fail;
27876 swig_obj[0] = args;
27877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27878 if (!SWIG_IsOK(res1)) {
27879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27880 }
27881 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27882 {
27883 PyThreadState* __tstate = wxPyBeginAllowThreads();
27884 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27885 wxPyEndAllowThreads(__tstate);
27886 if (PyErr_Occurred()) SWIG_fail;
27887 }
27888 {
27889 #if wxUSE_UNICODE
27890 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27891 #else
27892 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27893 #endif
27894 }
27895 return resultobj;
27896 fail:
27897 return NULL;
27898 }
27899
27900
27901 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27902 PyObject *resultobj = 0;
27903 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27904 bool result;
27905 void *argp1 = 0 ;
27906 int res1 = 0 ;
27907 PyObject *swig_obj[1] ;
27908
27909 if (!args) SWIG_fail;
27910 swig_obj[0] = args;
27911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27912 if (!SWIG_IsOK(res1)) {
27913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27914 }
27915 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27916 {
27917 PyThreadState* __tstate = wxPyBeginAllowThreads();
27918 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27919 wxPyEndAllowThreads(__tstate);
27920 if (PyErr_Occurred()) SWIG_fail;
27921 }
27922 {
27923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27924 }
27925 return resultobj;
27926 fail:
27927 return NULL;
27928 }
27929
27930
27931 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27932 PyObject *resultobj = 0;
27933 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27934 bool result;
27935 void *argp1 = 0 ;
27936 int res1 = 0 ;
27937 PyObject *swig_obj[1] ;
27938
27939 if (!args) SWIG_fail;
27940 swig_obj[0] = args;
27941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27942 if (!SWIG_IsOK(res1)) {
27943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27944 }
27945 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27946 {
27947 PyThreadState* __tstate = wxPyBeginAllowThreads();
27948 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27949 wxPyEndAllowThreads(__tstate);
27950 if (PyErr_Occurred()) SWIG_fail;
27951 }
27952 {
27953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27954 }
27955 return resultobj;
27956 fail:
27957 return NULL;
27958 }
27959
27960
27961 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27962 PyObject *resultobj = 0;
27963 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27964 bool result;
27965 void *argp1 = 0 ;
27966 int res1 = 0 ;
27967 PyObject *swig_obj[1] ;
27968
27969 if (!args) SWIG_fail;
27970 swig_obj[0] = args;
27971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27972 if (!SWIG_IsOK(res1)) {
27973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27974 }
27975 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27976 {
27977 PyThreadState* __tstate = wxPyBeginAllowThreads();
27978 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27979 wxPyEndAllowThreads(__tstate);
27980 if (PyErr_Occurred()) SWIG_fail;
27981 }
27982 {
27983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27984 }
27985 return resultobj;
27986 fail:
27987 return NULL;
27988 }
27989
27990
27991 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27992 PyObject *resultobj = 0;
27993 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27994 bool result;
27995 void *argp1 = 0 ;
27996 int res1 = 0 ;
27997 PyObject *swig_obj[1] ;
27998
27999 if (!args) SWIG_fail;
28000 swig_obj[0] = args;
28001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28002 if (!SWIG_IsOK(res1)) {
28003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28004 }
28005 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28006 {
28007 PyThreadState* __tstate = wxPyBeginAllowThreads();
28008 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
28009 wxPyEndAllowThreads(__tstate);
28010 if (PyErr_Occurred()) SWIG_fail;
28011 }
28012 {
28013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28014 }
28015 return resultobj;
28016 fail:
28017 return NULL;
28018 }
28019
28020
28021 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28022 PyObject *resultobj = 0;
28023 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28024 bool arg2 ;
28025 void *argp1 = 0 ;
28026 int res1 = 0 ;
28027 bool val2 ;
28028 int ecode2 = 0 ;
28029 PyObject * obj0 = 0 ;
28030 PyObject * obj1 = 0 ;
28031 char * kwnames[] = {
28032 (char *) "self",(char *) "check", NULL
28033 };
28034
28035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
28036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28037 if (!SWIG_IsOK(res1)) {
28038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28039 }
28040 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28041 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28042 if (!SWIG_IsOK(ecode2)) {
28043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
28044 }
28045 arg2 = static_cast< bool >(val2);
28046 {
28047 PyThreadState* __tstate = wxPyBeginAllowThreads();
28048 (arg1)->Check(arg2);
28049 wxPyEndAllowThreads(__tstate);
28050 if (PyErr_Occurred()) SWIG_fail;
28051 }
28052 resultobj = SWIG_Py_Void();
28053 return resultobj;
28054 fail:
28055 return NULL;
28056 }
28057
28058
28059 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28060 PyObject *resultobj = 0;
28061 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28062 bool arg2 ;
28063 void *argp1 = 0 ;
28064 int res1 = 0 ;
28065 bool val2 ;
28066 int ecode2 = 0 ;
28067 PyObject * obj0 = 0 ;
28068 PyObject * obj1 = 0 ;
28069 char * kwnames[] = {
28070 (char *) "self",(char *) "enable", NULL
28071 };
28072
28073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
28074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28075 if (!SWIG_IsOK(res1)) {
28076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28077 }
28078 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28079 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28080 if (!SWIG_IsOK(ecode2)) {
28081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
28082 }
28083 arg2 = static_cast< bool >(val2);
28084 {
28085 PyThreadState* __tstate = wxPyBeginAllowThreads();
28086 (arg1)->Enable(arg2);
28087 wxPyEndAllowThreads(__tstate);
28088 if (PyErr_Occurred()) SWIG_fail;
28089 }
28090 resultobj = SWIG_Py_Void();
28091 return resultobj;
28092 fail:
28093 return NULL;
28094 }
28095
28096
28097 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28098 PyObject *resultobj = 0;
28099 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28100 bool arg2 ;
28101 void *argp1 = 0 ;
28102 int res1 = 0 ;
28103 bool val2 ;
28104 int ecode2 = 0 ;
28105 PyObject * obj0 = 0 ;
28106 PyObject * obj1 = 0 ;
28107 char * kwnames[] = {
28108 (char *) "self",(char *) "show", NULL
28109 };
28110
28111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28113 if (!SWIG_IsOK(res1)) {
28114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28115 }
28116 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28117 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28118 if (!SWIG_IsOK(ecode2)) {
28119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28120 }
28121 arg2 = static_cast< bool >(val2);
28122 {
28123 PyThreadState* __tstate = wxPyBeginAllowThreads();
28124 (arg1)->Show(arg2);
28125 wxPyEndAllowThreads(__tstate);
28126 if (PyErr_Occurred()) SWIG_fail;
28127 }
28128 resultobj = SWIG_Py_Void();
28129 return resultobj;
28130 fail:
28131 return NULL;
28132 }
28133
28134
28135 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28136 PyObject *resultobj = 0;
28137 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28138 wxString *arg2 = 0 ;
28139 void *argp1 = 0 ;
28140 int res1 = 0 ;
28141 bool temp2 = false ;
28142 PyObject * obj0 = 0 ;
28143 PyObject * obj1 = 0 ;
28144 char * kwnames[] = {
28145 (char *) "self",(char *) "text", NULL
28146 };
28147
28148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28150 if (!SWIG_IsOK(res1)) {
28151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28152 }
28153 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28154 {
28155 arg2 = wxString_in_helper(obj1);
28156 if (arg2 == NULL) SWIG_fail;
28157 temp2 = true;
28158 }
28159 {
28160 PyThreadState* __tstate = wxPyBeginAllowThreads();
28161 (arg1)->SetText((wxString const &)*arg2);
28162 wxPyEndAllowThreads(__tstate);
28163 if (PyErr_Occurred()) SWIG_fail;
28164 }
28165 resultobj = SWIG_Py_Void();
28166 {
28167 if (temp2)
28168 delete arg2;
28169 }
28170 return resultobj;
28171 fail:
28172 {
28173 if (temp2)
28174 delete arg2;
28175 }
28176 return NULL;
28177 }
28178
28179
28180 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28181 PyObject *resultobj = 0;
28182 long arg1 ;
28183 long val1 ;
28184 int ecode1 = 0 ;
28185 PyObject * obj0 = 0 ;
28186 char * kwnames[] = {
28187 (char *) "updateInterval", NULL
28188 };
28189
28190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28191 ecode1 = SWIG_AsVal_long(obj0, &val1);
28192 if (!SWIG_IsOK(ecode1)) {
28193 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28194 }
28195 arg1 = static_cast< long >(val1);
28196 {
28197 PyThreadState* __tstate = wxPyBeginAllowThreads();
28198 wxUpdateUIEvent::SetUpdateInterval(arg1);
28199 wxPyEndAllowThreads(__tstate);
28200 if (PyErr_Occurred()) SWIG_fail;
28201 }
28202 resultobj = SWIG_Py_Void();
28203 return resultobj;
28204 fail:
28205 return NULL;
28206 }
28207
28208
28209 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28210 PyObject *resultobj = 0;
28211 long result;
28212
28213 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28214 {
28215 PyThreadState* __tstate = wxPyBeginAllowThreads();
28216 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28217 wxPyEndAllowThreads(__tstate);
28218 if (PyErr_Occurred()) SWIG_fail;
28219 }
28220 resultobj = SWIG_From_long(static_cast< long >(result));
28221 return resultobj;
28222 fail:
28223 return NULL;
28224 }
28225
28226
28227 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28228 PyObject *resultobj = 0;
28229 wxWindow *arg1 = (wxWindow *) 0 ;
28230 bool result;
28231 void *argp1 = 0 ;
28232 int res1 = 0 ;
28233 PyObject * obj0 = 0 ;
28234 char * kwnames[] = {
28235 (char *) "win", NULL
28236 };
28237
28238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28240 if (!SWIG_IsOK(res1)) {
28241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28242 }
28243 arg1 = reinterpret_cast< wxWindow * >(argp1);
28244 {
28245 PyThreadState* __tstate = wxPyBeginAllowThreads();
28246 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28247 wxPyEndAllowThreads(__tstate);
28248 if (PyErr_Occurred()) SWIG_fail;
28249 }
28250 {
28251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28252 }
28253 return resultobj;
28254 fail:
28255 return NULL;
28256 }
28257
28258
28259 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28260 PyObject *resultobj = 0;
28261
28262 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28263 {
28264 PyThreadState* __tstate = wxPyBeginAllowThreads();
28265 wxUpdateUIEvent::ResetUpdateTime();
28266 wxPyEndAllowThreads(__tstate);
28267 if (PyErr_Occurred()) SWIG_fail;
28268 }
28269 resultobj = SWIG_Py_Void();
28270 return resultobj;
28271 fail:
28272 return NULL;
28273 }
28274
28275
28276 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28277 PyObject *resultobj = 0;
28278 wxUpdateUIMode arg1 ;
28279 int val1 ;
28280 int ecode1 = 0 ;
28281 PyObject * obj0 = 0 ;
28282 char * kwnames[] = {
28283 (char *) "mode", NULL
28284 };
28285
28286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28287 ecode1 = SWIG_AsVal_int(obj0, &val1);
28288 if (!SWIG_IsOK(ecode1)) {
28289 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28290 }
28291 arg1 = static_cast< wxUpdateUIMode >(val1);
28292 {
28293 PyThreadState* __tstate = wxPyBeginAllowThreads();
28294 wxUpdateUIEvent::SetMode(arg1);
28295 wxPyEndAllowThreads(__tstate);
28296 if (PyErr_Occurred()) SWIG_fail;
28297 }
28298 resultobj = SWIG_Py_Void();
28299 return resultobj;
28300 fail:
28301 return NULL;
28302 }
28303
28304
28305 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28306 PyObject *resultobj = 0;
28307 wxUpdateUIMode result;
28308
28309 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28310 {
28311 PyThreadState* __tstate = wxPyBeginAllowThreads();
28312 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28313 wxPyEndAllowThreads(__tstate);
28314 if (PyErr_Occurred()) SWIG_fail;
28315 }
28316 resultobj = SWIG_From_int(static_cast< int >(result));
28317 return resultobj;
28318 fail:
28319 return NULL;
28320 }
28321
28322
28323 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28324 PyObject *obj;
28325 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28326 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28327 return SWIG_Py_Void();
28328 }
28329
28330 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28331 return SWIG_Python_InitShadowInstance(args);
28332 }
28333
28334 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28335 PyObject *resultobj = 0;
28336 wxSysColourChangedEvent *result = 0 ;
28337
28338 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28339 {
28340 PyThreadState* __tstate = wxPyBeginAllowThreads();
28341 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28342 wxPyEndAllowThreads(__tstate);
28343 if (PyErr_Occurred()) SWIG_fail;
28344 }
28345 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28346 return resultobj;
28347 fail:
28348 return NULL;
28349 }
28350
28351
28352 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28353 PyObject *obj;
28354 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28355 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28356 return SWIG_Py_Void();
28357 }
28358
28359 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28360 return SWIG_Python_InitShadowInstance(args);
28361 }
28362
28363 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28364 PyObject *resultobj = 0;
28365 int arg1 = (int) 0 ;
28366 wxWindow *arg2 = (wxWindow *) NULL ;
28367 wxMouseCaptureChangedEvent *result = 0 ;
28368 int val1 ;
28369 int ecode1 = 0 ;
28370 void *argp2 = 0 ;
28371 int res2 = 0 ;
28372 PyObject * obj0 = 0 ;
28373 PyObject * obj1 = 0 ;
28374 char * kwnames[] = {
28375 (char *) "winid",(char *) "gainedCapture", NULL
28376 };
28377
28378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28379 if (obj0) {
28380 ecode1 = SWIG_AsVal_int(obj0, &val1);
28381 if (!SWIG_IsOK(ecode1)) {
28382 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28383 }
28384 arg1 = static_cast< int >(val1);
28385 }
28386 if (obj1) {
28387 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28388 if (!SWIG_IsOK(res2)) {
28389 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28390 }
28391 arg2 = reinterpret_cast< wxWindow * >(argp2);
28392 }
28393 {
28394 PyThreadState* __tstate = wxPyBeginAllowThreads();
28395 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28396 wxPyEndAllowThreads(__tstate);
28397 if (PyErr_Occurred()) SWIG_fail;
28398 }
28399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28400 return resultobj;
28401 fail:
28402 return NULL;
28403 }
28404
28405
28406 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28407 PyObject *resultobj = 0;
28408 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28409 wxWindow *result = 0 ;
28410 void *argp1 = 0 ;
28411 int res1 = 0 ;
28412 PyObject *swig_obj[1] ;
28413
28414 if (!args) SWIG_fail;
28415 swig_obj[0] = args;
28416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28417 if (!SWIG_IsOK(res1)) {
28418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28419 }
28420 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28421 {
28422 PyThreadState* __tstate = wxPyBeginAllowThreads();
28423 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28424 wxPyEndAllowThreads(__tstate);
28425 if (PyErr_Occurred()) SWIG_fail;
28426 }
28427 {
28428 resultobj = wxPyMake_wxObject(result, (bool)0);
28429 }
28430 return resultobj;
28431 fail:
28432 return NULL;
28433 }
28434
28435
28436 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28437 PyObject *obj;
28438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28439 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28440 return SWIG_Py_Void();
28441 }
28442
28443 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28444 return SWIG_Python_InitShadowInstance(args);
28445 }
28446
28447 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28448 PyObject *resultobj = 0;
28449 int arg1 = (int) 0 ;
28450 wxMouseCaptureLostEvent *result = 0 ;
28451 int val1 ;
28452 int ecode1 = 0 ;
28453 PyObject * obj0 = 0 ;
28454 char * kwnames[] = {
28455 (char *) "winid", NULL
28456 };
28457
28458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28459 if (obj0) {
28460 ecode1 = SWIG_AsVal_int(obj0, &val1);
28461 if (!SWIG_IsOK(ecode1)) {
28462 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28463 }
28464 arg1 = static_cast< int >(val1);
28465 }
28466 {
28467 PyThreadState* __tstate = wxPyBeginAllowThreads();
28468 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28469 wxPyEndAllowThreads(__tstate);
28470 if (PyErr_Occurred()) SWIG_fail;
28471 }
28472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28473 return resultobj;
28474 fail:
28475 return NULL;
28476 }
28477
28478
28479 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28480 PyObject *obj;
28481 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28482 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28483 return SWIG_Py_Void();
28484 }
28485
28486 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28487 return SWIG_Python_InitShadowInstance(args);
28488 }
28489
28490 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28491 PyObject *resultobj = 0;
28492 wxDisplayChangedEvent *result = 0 ;
28493
28494 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28495 {
28496 PyThreadState* __tstate = wxPyBeginAllowThreads();
28497 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28498 wxPyEndAllowThreads(__tstate);
28499 if (PyErr_Occurred()) SWIG_fail;
28500 }
28501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28502 return resultobj;
28503 fail:
28504 return NULL;
28505 }
28506
28507
28508 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28509 PyObject *obj;
28510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28511 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28512 return SWIG_Py_Void();
28513 }
28514
28515 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28516 return SWIG_Python_InitShadowInstance(args);
28517 }
28518
28519 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28520 PyObject *resultobj = 0;
28521 int arg1 = (int) 0 ;
28522 wxPaletteChangedEvent *result = 0 ;
28523 int val1 ;
28524 int ecode1 = 0 ;
28525 PyObject * obj0 = 0 ;
28526 char * kwnames[] = {
28527 (char *) "id", NULL
28528 };
28529
28530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28531 if (obj0) {
28532 ecode1 = SWIG_AsVal_int(obj0, &val1);
28533 if (!SWIG_IsOK(ecode1)) {
28534 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28535 }
28536 arg1 = static_cast< int >(val1);
28537 }
28538 {
28539 PyThreadState* __tstate = wxPyBeginAllowThreads();
28540 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28541 wxPyEndAllowThreads(__tstate);
28542 if (PyErr_Occurred()) SWIG_fail;
28543 }
28544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28545 return resultobj;
28546 fail:
28547 return NULL;
28548 }
28549
28550
28551 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28552 PyObject *resultobj = 0;
28553 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28554 wxWindow *arg2 = (wxWindow *) 0 ;
28555 void *argp1 = 0 ;
28556 int res1 = 0 ;
28557 void *argp2 = 0 ;
28558 int res2 = 0 ;
28559 PyObject * obj0 = 0 ;
28560 PyObject * obj1 = 0 ;
28561 char * kwnames[] = {
28562 (char *) "self",(char *) "win", NULL
28563 };
28564
28565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28567 if (!SWIG_IsOK(res1)) {
28568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28569 }
28570 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28571 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28572 if (!SWIG_IsOK(res2)) {
28573 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28574 }
28575 arg2 = reinterpret_cast< wxWindow * >(argp2);
28576 {
28577 PyThreadState* __tstate = wxPyBeginAllowThreads();
28578 (arg1)->SetChangedWindow(arg2);
28579 wxPyEndAllowThreads(__tstate);
28580 if (PyErr_Occurred()) SWIG_fail;
28581 }
28582 resultobj = SWIG_Py_Void();
28583 return resultobj;
28584 fail:
28585 return NULL;
28586 }
28587
28588
28589 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28590 PyObject *resultobj = 0;
28591 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28592 wxWindow *result = 0 ;
28593 void *argp1 = 0 ;
28594 int res1 = 0 ;
28595 PyObject *swig_obj[1] ;
28596
28597 if (!args) SWIG_fail;
28598 swig_obj[0] = args;
28599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28600 if (!SWIG_IsOK(res1)) {
28601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28602 }
28603 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28604 {
28605 PyThreadState* __tstate = wxPyBeginAllowThreads();
28606 result = (wxWindow *)(arg1)->GetChangedWindow();
28607 wxPyEndAllowThreads(__tstate);
28608 if (PyErr_Occurred()) SWIG_fail;
28609 }
28610 {
28611 resultobj = wxPyMake_wxObject(result, (bool)0);
28612 }
28613 return resultobj;
28614 fail:
28615 return NULL;
28616 }
28617
28618
28619 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28620 PyObject *obj;
28621 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28622 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28623 return SWIG_Py_Void();
28624 }
28625
28626 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28627 return SWIG_Python_InitShadowInstance(args);
28628 }
28629
28630 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28631 PyObject *resultobj = 0;
28632 int arg1 = (int) 0 ;
28633 wxQueryNewPaletteEvent *result = 0 ;
28634 int val1 ;
28635 int ecode1 = 0 ;
28636 PyObject * obj0 = 0 ;
28637 char * kwnames[] = {
28638 (char *) "winid", NULL
28639 };
28640
28641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28642 if (obj0) {
28643 ecode1 = SWIG_AsVal_int(obj0, &val1);
28644 if (!SWIG_IsOK(ecode1)) {
28645 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28646 }
28647 arg1 = static_cast< int >(val1);
28648 }
28649 {
28650 PyThreadState* __tstate = wxPyBeginAllowThreads();
28651 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28652 wxPyEndAllowThreads(__tstate);
28653 if (PyErr_Occurred()) SWIG_fail;
28654 }
28655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28656 return resultobj;
28657 fail:
28658 return NULL;
28659 }
28660
28661
28662 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28663 PyObject *resultobj = 0;
28664 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28665 bool arg2 ;
28666 void *argp1 = 0 ;
28667 int res1 = 0 ;
28668 bool val2 ;
28669 int ecode2 = 0 ;
28670 PyObject * obj0 = 0 ;
28671 PyObject * obj1 = 0 ;
28672 char * kwnames[] = {
28673 (char *) "self",(char *) "realized", NULL
28674 };
28675
28676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28678 if (!SWIG_IsOK(res1)) {
28679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28680 }
28681 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28682 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28683 if (!SWIG_IsOK(ecode2)) {
28684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28685 }
28686 arg2 = static_cast< bool >(val2);
28687 {
28688 PyThreadState* __tstate = wxPyBeginAllowThreads();
28689 (arg1)->SetPaletteRealized(arg2);
28690 wxPyEndAllowThreads(__tstate);
28691 if (PyErr_Occurred()) SWIG_fail;
28692 }
28693 resultobj = SWIG_Py_Void();
28694 return resultobj;
28695 fail:
28696 return NULL;
28697 }
28698
28699
28700 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28701 PyObject *resultobj = 0;
28702 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28703 bool result;
28704 void *argp1 = 0 ;
28705 int res1 = 0 ;
28706 PyObject *swig_obj[1] ;
28707
28708 if (!args) SWIG_fail;
28709 swig_obj[0] = args;
28710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28711 if (!SWIG_IsOK(res1)) {
28712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28713 }
28714 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28715 {
28716 PyThreadState* __tstate = wxPyBeginAllowThreads();
28717 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28718 wxPyEndAllowThreads(__tstate);
28719 if (PyErr_Occurred()) SWIG_fail;
28720 }
28721 {
28722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28723 }
28724 return resultobj;
28725 fail:
28726 return NULL;
28727 }
28728
28729
28730 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28731 PyObject *obj;
28732 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28733 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28734 return SWIG_Py_Void();
28735 }
28736
28737 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28738 return SWIG_Python_InitShadowInstance(args);
28739 }
28740
28741 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28742 PyObject *resultobj = 0;
28743 wxNavigationKeyEvent *result = 0 ;
28744
28745 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28746 {
28747 PyThreadState* __tstate = wxPyBeginAllowThreads();
28748 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28749 wxPyEndAllowThreads(__tstate);
28750 if (PyErr_Occurred()) SWIG_fail;
28751 }
28752 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28753 return resultobj;
28754 fail:
28755 return NULL;
28756 }
28757
28758
28759 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28760 PyObject *resultobj = 0;
28761 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28762 bool result;
28763 void *argp1 = 0 ;
28764 int res1 = 0 ;
28765 PyObject *swig_obj[1] ;
28766
28767 if (!args) SWIG_fail;
28768 swig_obj[0] = args;
28769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28770 if (!SWIG_IsOK(res1)) {
28771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28772 }
28773 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28774 {
28775 PyThreadState* __tstate = wxPyBeginAllowThreads();
28776 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28777 wxPyEndAllowThreads(__tstate);
28778 if (PyErr_Occurred()) SWIG_fail;
28779 }
28780 {
28781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28782 }
28783 return resultobj;
28784 fail:
28785 return NULL;
28786 }
28787
28788
28789 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28790 PyObject *resultobj = 0;
28791 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28792 bool arg2 ;
28793 void *argp1 = 0 ;
28794 int res1 = 0 ;
28795 bool val2 ;
28796 int ecode2 = 0 ;
28797 PyObject * obj0 = 0 ;
28798 PyObject * obj1 = 0 ;
28799 char * kwnames[] = {
28800 (char *) "self",(char *) "forward", NULL
28801 };
28802
28803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28805 if (!SWIG_IsOK(res1)) {
28806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28807 }
28808 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28809 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28810 if (!SWIG_IsOK(ecode2)) {
28811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28812 }
28813 arg2 = static_cast< bool >(val2);
28814 {
28815 PyThreadState* __tstate = wxPyBeginAllowThreads();
28816 (arg1)->SetDirection(arg2);
28817 wxPyEndAllowThreads(__tstate);
28818 if (PyErr_Occurred()) SWIG_fail;
28819 }
28820 resultobj = SWIG_Py_Void();
28821 return resultobj;
28822 fail:
28823 return NULL;
28824 }
28825
28826
28827 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28828 PyObject *resultobj = 0;
28829 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28830 bool result;
28831 void *argp1 = 0 ;
28832 int res1 = 0 ;
28833 PyObject *swig_obj[1] ;
28834
28835 if (!args) SWIG_fail;
28836 swig_obj[0] = args;
28837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28838 if (!SWIG_IsOK(res1)) {
28839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28840 }
28841 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28842 {
28843 PyThreadState* __tstate = wxPyBeginAllowThreads();
28844 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28845 wxPyEndAllowThreads(__tstate);
28846 if (PyErr_Occurred()) SWIG_fail;
28847 }
28848 {
28849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28850 }
28851 return resultobj;
28852 fail:
28853 return NULL;
28854 }
28855
28856
28857 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28858 PyObject *resultobj = 0;
28859 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28860 bool arg2 ;
28861 void *argp1 = 0 ;
28862 int res1 = 0 ;
28863 bool val2 ;
28864 int ecode2 = 0 ;
28865 PyObject * obj0 = 0 ;
28866 PyObject * obj1 = 0 ;
28867 char * kwnames[] = {
28868 (char *) "self",(char *) "ischange", NULL
28869 };
28870
28871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28873 if (!SWIG_IsOK(res1)) {
28874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28875 }
28876 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28877 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28878 if (!SWIG_IsOK(ecode2)) {
28879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28880 }
28881 arg2 = static_cast< bool >(val2);
28882 {
28883 PyThreadState* __tstate = wxPyBeginAllowThreads();
28884 (arg1)->SetWindowChange(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_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28896 PyObject *resultobj = 0;
28897 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28898 bool 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_wxNavigationKeyEvent, 0 | 0 );
28906 if (!SWIG_IsOK(res1)) {
28907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28908 }
28909 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28910 {
28911 PyThreadState* __tstate = wxPyBeginAllowThreads();
28912 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28913 wxPyEndAllowThreads(__tstate);
28914 if (PyErr_Occurred()) SWIG_fail;
28915 }
28916 {
28917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28918 }
28919 return resultobj;
28920 fail:
28921 return NULL;
28922 }
28923
28924
28925 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28926 PyObject *resultobj = 0;
28927 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28928 bool arg2 ;
28929 void *argp1 = 0 ;
28930 int res1 = 0 ;
28931 bool val2 ;
28932 int ecode2 = 0 ;
28933 PyObject * obj0 = 0 ;
28934 PyObject * obj1 = 0 ;
28935 char * kwnames[] = {
28936 (char *) "self",(char *) "bIs", NULL
28937 };
28938
28939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28941 if (!SWIG_IsOK(res1)) {
28942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28943 }
28944 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28945 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28946 if (!SWIG_IsOK(ecode2)) {
28947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28948 }
28949 arg2 = static_cast< bool >(val2);
28950 {
28951 PyThreadState* __tstate = wxPyBeginAllowThreads();
28952 (arg1)->SetFromTab(arg2);
28953 wxPyEndAllowThreads(__tstate);
28954 if (PyErr_Occurred()) SWIG_fail;
28955 }
28956 resultobj = SWIG_Py_Void();
28957 return resultobj;
28958 fail:
28959 return NULL;
28960 }
28961
28962
28963 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28964 PyObject *resultobj = 0;
28965 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28966 long arg2 ;
28967 void *argp1 = 0 ;
28968 int res1 = 0 ;
28969 long val2 ;
28970 int ecode2 = 0 ;
28971 PyObject * obj0 = 0 ;
28972 PyObject * obj1 = 0 ;
28973 char * kwnames[] = {
28974 (char *) "self",(char *) "flags", NULL
28975 };
28976
28977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28979 if (!SWIG_IsOK(res1)) {
28980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28981 }
28982 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28983 ecode2 = SWIG_AsVal_long(obj1, &val2);
28984 if (!SWIG_IsOK(ecode2)) {
28985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28986 }
28987 arg2 = static_cast< long >(val2);
28988 {
28989 PyThreadState* __tstate = wxPyBeginAllowThreads();
28990 (arg1)->SetFlags(arg2);
28991 wxPyEndAllowThreads(__tstate);
28992 if (PyErr_Occurred()) SWIG_fail;
28993 }
28994 resultobj = SWIG_Py_Void();
28995 return resultobj;
28996 fail:
28997 return NULL;
28998 }
28999
29000
29001 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29002 PyObject *resultobj = 0;
29003 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29004 wxWindow *result = 0 ;
29005 void *argp1 = 0 ;
29006 int res1 = 0 ;
29007 PyObject *swig_obj[1] ;
29008
29009 if (!args) SWIG_fail;
29010 swig_obj[0] = args;
29011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29012 if (!SWIG_IsOK(res1)) {
29013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29014 }
29015 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29016 {
29017 PyThreadState* __tstate = wxPyBeginAllowThreads();
29018 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
29019 wxPyEndAllowThreads(__tstate);
29020 if (PyErr_Occurred()) SWIG_fail;
29021 }
29022 {
29023 resultobj = wxPyMake_wxObject(result, (bool)0);
29024 }
29025 return resultobj;
29026 fail:
29027 return NULL;
29028 }
29029
29030
29031 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29032 PyObject *resultobj = 0;
29033 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29034 wxWindow *arg2 = (wxWindow *) 0 ;
29035 void *argp1 = 0 ;
29036 int res1 = 0 ;
29037 void *argp2 = 0 ;
29038 int res2 = 0 ;
29039 PyObject * obj0 = 0 ;
29040 PyObject * obj1 = 0 ;
29041 char * kwnames[] = {
29042 (char *) "self",(char *) "win", NULL
29043 };
29044
29045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
29046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29047 if (!SWIG_IsOK(res1)) {
29048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29049 }
29050 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29051 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29052 if (!SWIG_IsOK(res2)) {
29053 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
29054 }
29055 arg2 = reinterpret_cast< wxWindow * >(argp2);
29056 {
29057 PyThreadState* __tstate = wxPyBeginAllowThreads();
29058 (arg1)->SetCurrentFocus(arg2);
29059 wxPyEndAllowThreads(__tstate);
29060 if (PyErr_Occurred()) SWIG_fail;
29061 }
29062 resultobj = SWIG_Py_Void();
29063 return resultobj;
29064 fail:
29065 return NULL;
29066 }
29067
29068
29069 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29070 PyObject *obj;
29071 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29072 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
29073 return SWIG_Py_Void();
29074 }
29075
29076 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29077 return SWIG_Python_InitShadowInstance(args);
29078 }
29079
29080 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29081 PyObject *resultobj = 0;
29082 wxWindow *arg1 = (wxWindow *) NULL ;
29083 wxWindowCreateEvent *result = 0 ;
29084 void *argp1 = 0 ;
29085 int res1 = 0 ;
29086 PyObject * obj0 = 0 ;
29087 char * kwnames[] = {
29088 (char *) "win", NULL
29089 };
29090
29091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
29092 if (obj0) {
29093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29094 if (!SWIG_IsOK(res1)) {
29095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29096 }
29097 arg1 = reinterpret_cast< wxWindow * >(argp1);
29098 }
29099 {
29100 PyThreadState* __tstate = wxPyBeginAllowThreads();
29101 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29102 wxPyEndAllowThreads(__tstate);
29103 if (PyErr_Occurred()) SWIG_fail;
29104 }
29105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29106 return resultobj;
29107 fail:
29108 return NULL;
29109 }
29110
29111
29112 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29113 PyObject *resultobj = 0;
29114 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29115 wxWindow *result = 0 ;
29116 void *argp1 = 0 ;
29117 int res1 = 0 ;
29118 PyObject *swig_obj[1] ;
29119
29120 if (!args) SWIG_fail;
29121 swig_obj[0] = args;
29122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29123 if (!SWIG_IsOK(res1)) {
29124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29125 }
29126 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29127 {
29128 PyThreadState* __tstate = wxPyBeginAllowThreads();
29129 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29130 wxPyEndAllowThreads(__tstate);
29131 if (PyErr_Occurred()) SWIG_fail;
29132 }
29133 {
29134 resultobj = wxPyMake_wxObject(result, (bool)0);
29135 }
29136 return resultobj;
29137 fail:
29138 return NULL;
29139 }
29140
29141
29142 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29143 PyObject *obj;
29144 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29145 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29146 return SWIG_Py_Void();
29147 }
29148
29149 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29150 return SWIG_Python_InitShadowInstance(args);
29151 }
29152
29153 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29154 PyObject *resultobj = 0;
29155 wxWindow *arg1 = (wxWindow *) NULL ;
29156 wxWindowDestroyEvent *result = 0 ;
29157 void *argp1 = 0 ;
29158 int res1 = 0 ;
29159 PyObject * obj0 = 0 ;
29160 char * kwnames[] = {
29161 (char *) "win", NULL
29162 };
29163
29164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29165 if (obj0) {
29166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29167 if (!SWIG_IsOK(res1)) {
29168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29169 }
29170 arg1 = reinterpret_cast< wxWindow * >(argp1);
29171 }
29172 {
29173 PyThreadState* __tstate = wxPyBeginAllowThreads();
29174 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29175 wxPyEndAllowThreads(__tstate);
29176 if (PyErr_Occurred()) SWIG_fail;
29177 }
29178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29179 return resultobj;
29180 fail:
29181 return NULL;
29182 }
29183
29184
29185 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29186 PyObject *resultobj = 0;
29187 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29188 wxWindow *result = 0 ;
29189 void *argp1 = 0 ;
29190 int res1 = 0 ;
29191 PyObject *swig_obj[1] ;
29192
29193 if (!args) SWIG_fail;
29194 swig_obj[0] = args;
29195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29196 if (!SWIG_IsOK(res1)) {
29197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29198 }
29199 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29200 {
29201 PyThreadState* __tstate = wxPyBeginAllowThreads();
29202 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29203 wxPyEndAllowThreads(__tstate);
29204 if (PyErr_Occurred()) SWIG_fail;
29205 }
29206 {
29207 resultobj = wxPyMake_wxObject(result, (bool)0);
29208 }
29209 return resultobj;
29210 fail:
29211 return NULL;
29212 }
29213
29214
29215 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29216 PyObject *obj;
29217 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29218 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29219 return SWIG_Py_Void();
29220 }
29221
29222 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29223 return SWIG_Python_InitShadowInstance(args);
29224 }
29225
29226 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29227 PyObject *resultobj = 0;
29228 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29229 int arg2 = (int) 0 ;
29230 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29231 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29232 wxContextMenuEvent *result = 0 ;
29233 int val1 ;
29234 int ecode1 = 0 ;
29235 int val2 ;
29236 int ecode2 = 0 ;
29237 wxPoint temp3 ;
29238 PyObject * obj0 = 0 ;
29239 PyObject * obj1 = 0 ;
29240 PyObject * obj2 = 0 ;
29241 char * kwnames[] = {
29242 (char *) "type",(char *) "winid",(char *) "pt", NULL
29243 };
29244
29245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29246 if (obj0) {
29247 ecode1 = SWIG_AsVal_int(obj0, &val1);
29248 if (!SWIG_IsOK(ecode1)) {
29249 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29250 }
29251 arg1 = static_cast< wxEventType >(val1);
29252 }
29253 if (obj1) {
29254 ecode2 = SWIG_AsVal_int(obj1, &val2);
29255 if (!SWIG_IsOK(ecode2)) {
29256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29257 }
29258 arg2 = static_cast< int >(val2);
29259 }
29260 if (obj2) {
29261 {
29262 arg3 = &temp3;
29263 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29264 }
29265 }
29266 {
29267 PyThreadState* __tstate = wxPyBeginAllowThreads();
29268 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29269 wxPyEndAllowThreads(__tstate);
29270 if (PyErr_Occurred()) SWIG_fail;
29271 }
29272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29273 return resultobj;
29274 fail:
29275 return NULL;
29276 }
29277
29278
29279 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29280 PyObject *resultobj = 0;
29281 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29282 wxPoint *result = 0 ;
29283 void *argp1 = 0 ;
29284 int res1 = 0 ;
29285 PyObject *swig_obj[1] ;
29286
29287 if (!args) SWIG_fail;
29288 swig_obj[0] = args;
29289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29290 if (!SWIG_IsOK(res1)) {
29291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29292 }
29293 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29294 {
29295 PyThreadState* __tstate = wxPyBeginAllowThreads();
29296 {
29297 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29298 result = (wxPoint *) &_result_ref;
29299 }
29300 wxPyEndAllowThreads(__tstate);
29301 if (PyErr_Occurred()) SWIG_fail;
29302 }
29303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29304 return resultobj;
29305 fail:
29306 return NULL;
29307 }
29308
29309
29310 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29311 PyObject *resultobj = 0;
29312 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29313 wxPoint *arg2 = 0 ;
29314 void *argp1 = 0 ;
29315 int res1 = 0 ;
29316 wxPoint temp2 ;
29317 PyObject * obj0 = 0 ;
29318 PyObject * obj1 = 0 ;
29319 char * kwnames[] = {
29320 (char *) "self",(char *) "pos", NULL
29321 };
29322
29323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29325 if (!SWIG_IsOK(res1)) {
29326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29327 }
29328 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29329 {
29330 arg2 = &temp2;
29331 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29332 }
29333 {
29334 PyThreadState* __tstate = wxPyBeginAllowThreads();
29335 (arg1)->SetPosition((wxPoint const &)*arg2);
29336 wxPyEndAllowThreads(__tstate);
29337 if (PyErr_Occurred()) SWIG_fail;
29338 }
29339 resultobj = SWIG_Py_Void();
29340 return resultobj;
29341 fail:
29342 return NULL;
29343 }
29344
29345
29346 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29347 PyObject *obj;
29348 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29349 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29350 return SWIG_Py_Void();
29351 }
29352
29353 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29354 return SWIG_Python_InitShadowInstance(args);
29355 }
29356
29357 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29358 PyObject *resultobj = 0;
29359 wxIdleEvent *result = 0 ;
29360
29361 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29362 {
29363 PyThreadState* __tstate = wxPyBeginAllowThreads();
29364 result = (wxIdleEvent *)new wxIdleEvent();
29365 wxPyEndAllowThreads(__tstate);
29366 if (PyErr_Occurred()) SWIG_fail;
29367 }
29368 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29369 return resultobj;
29370 fail:
29371 return NULL;
29372 }
29373
29374
29375 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29376 PyObject *resultobj = 0;
29377 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29378 bool arg2 = (bool) true ;
29379 void *argp1 = 0 ;
29380 int res1 = 0 ;
29381 bool val2 ;
29382 int ecode2 = 0 ;
29383 PyObject * obj0 = 0 ;
29384 PyObject * obj1 = 0 ;
29385 char * kwnames[] = {
29386 (char *) "self",(char *) "needMore", NULL
29387 };
29388
29389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29391 if (!SWIG_IsOK(res1)) {
29392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29393 }
29394 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29395 if (obj1) {
29396 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29397 if (!SWIG_IsOK(ecode2)) {
29398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29399 }
29400 arg2 = static_cast< bool >(val2);
29401 }
29402 {
29403 PyThreadState* __tstate = wxPyBeginAllowThreads();
29404 (arg1)->RequestMore(arg2);
29405 wxPyEndAllowThreads(__tstate);
29406 if (PyErr_Occurred()) SWIG_fail;
29407 }
29408 resultobj = SWIG_Py_Void();
29409 return resultobj;
29410 fail:
29411 return NULL;
29412 }
29413
29414
29415 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29416 PyObject *resultobj = 0;
29417 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29418 bool result;
29419 void *argp1 = 0 ;
29420 int res1 = 0 ;
29421 PyObject *swig_obj[1] ;
29422
29423 if (!args) SWIG_fail;
29424 swig_obj[0] = args;
29425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29426 if (!SWIG_IsOK(res1)) {
29427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29428 }
29429 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29430 {
29431 PyThreadState* __tstate = wxPyBeginAllowThreads();
29432 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29433 wxPyEndAllowThreads(__tstate);
29434 if (PyErr_Occurred()) SWIG_fail;
29435 }
29436 {
29437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29438 }
29439 return resultobj;
29440 fail:
29441 return NULL;
29442 }
29443
29444
29445 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29446 PyObject *resultobj = 0;
29447 wxIdleMode arg1 ;
29448 int val1 ;
29449 int ecode1 = 0 ;
29450 PyObject * obj0 = 0 ;
29451 char * kwnames[] = {
29452 (char *) "mode", NULL
29453 };
29454
29455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29456 ecode1 = SWIG_AsVal_int(obj0, &val1);
29457 if (!SWIG_IsOK(ecode1)) {
29458 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29459 }
29460 arg1 = static_cast< wxIdleMode >(val1);
29461 {
29462 PyThreadState* __tstate = wxPyBeginAllowThreads();
29463 wxIdleEvent::SetMode(arg1);
29464 wxPyEndAllowThreads(__tstate);
29465 if (PyErr_Occurred()) SWIG_fail;
29466 }
29467 resultobj = SWIG_Py_Void();
29468 return resultobj;
29469 fail:
29470 return NULL;
29471 }
29472
29473
29474 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29475 PyObject *resultobj = 0;
29476 wxIdleMode result;
29477
29478 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29479 {
29480 PyThreadState* __tstate = wxPyBeginAllowThreads();
29481 result = (wxIdleMode)wxIdleEvent::GetMode();
29482 wxPyEndAllowThreads(__tstate);
29483 if (PyErr_Occurred()) SWIG_fail;
29484 }
29485 resultobj = SWIG_From_int(static_cast< int >(result));
29486 return resultobj;
29487 fail:
29488 return NULL;
29489 }
29490
29491
29492 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29493 PyObject *resultobj = 0;
29494 wxWindow *arg1 = (wxWindow *) 0 ;
29495 bool result;
29496 void *argp1 = 0 ;
29497 int res1 = 0 ;
29498 PyObject * obj0 = 0 ;
29499 char * kwnames[] = {
29500 (char *) "win", NULL
29501 };
29502
29503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29505 if (!SWIG_IsOK(res1)) {
29506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29507 }
29508 arg1 = reinterpret_cast< wxWindow * >(argp1);
29509 {
29510 PyThreadState* __tstate = wxPyBeginAllowThreads();
29511 result = (bool)wxIdleEvent::CanSend(arg1);
29512 wxPyEndAllowThreads(__tstate);
29513 if (PyErr_Occurred()) SWIG_fail;
29514 }
29515 {
29516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29517 }
29518 return resultobj;
29519 fail:
29520 return NULL;
29521 }
29522
29523
29524 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29525 PyObject *obj;
29526 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29527 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29528 return SWIG_Py_Void();
29529 }
29530
29531 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29532 return SWIG_Python_InitShadowInstance(args);
29533 }
29534
29535 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29536 PyObject *resultobj = 0;
29537 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29538 int arg2 = (int) 0 ;
29539 wxClipboardTextEvent *result = 0 ;
29540 int val1 ;
29541 int ecode1 = 0 ;
29542 int val2 ;
29543 int ecode2 = 0 ;
29544 PyObject * obj0 = 0 ;
29545 PyObject * obj1 = 0 ;
29546 char * kwnames[] = {
29547 (char *) "type",(char *) "winid", NULL
29548 };
29549
29550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29551 if (obj0) {
29552 ecode1 = SWIG_AsVal_int(obj0, &val1);
29553 if (!SWIG_IsOK(ecode1)) {
29554 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29555 }
29556 arg1 = static_cast< wxEventType >(val1);
29557 }
29558 if (obj1) {
29559 ecode2 = SWIG_AsVal_int(obj1, &val2);
29560 if (!SWIG_IsOK(ecode2)) {
29561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29562 }
29563 arg2 = static_cast< int >(val2);
29564 }
29565 {
29566 PyThreadState* __tstate = wxPyBeginAllowThreads();
29567 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29568 wxPyEndAllowThreads(__tstate);
29569 if (PyErr_Occurred()) SWIG_fail;
29570 }
29571 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29572 return resultobj;
29573 fail:
29574 return NULL;
29575 }
29576
29577
29578 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29579 PyObject *obj;
29580 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29581 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29582 return SWIG_Py_Void();
29583 }
29584
29585 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29586 return SWIG_Python_InitShadowInstance(args);
29587 }
29588
29589 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29590 PyObject *resultobj = 0;
29591 int arg1 = (int) 0 ;
29592 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29593 wxPyEvent *result = 0 ;
29594 int val1 ;
29595 int ecode1 = 0 ;
29596 int val2 ;
29597 int ecode2 = 0 ;
29598 PyObject * obj0 = 0 ;
29599 PyObject * obj1 = 0 ;
29600 char * kwnames[] = {
29601 (char *) "winid",(char *) "eventType", NULL
29602 };
29603
29604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29605 if (obj0) {
29606 ecode1 = SWIG_AsVal_int(obj0, &val1);
29607 if (!SWIG_IsOK(ecode1)) {
29608 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29609 }
29610 arg1 = static_cast< int >(val1);
29611 }
29612 if (obj1) {
29613 ecode2 = SWIG_AsVal_int(obj1, &val2);
29614 if (!SWIG_IsOK(ecode2)) {
29615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29616 }
29617 arg2 = static_cast< wxEventType >(val2);
29618 }
29619 {
29620 PyThreadState* __tstate = wxPyBeginAllowThreads();
29621 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29622 wxPyEndAllowThreads(__tstate);
29623 if (PyErr_Occurred()) SWIG_fail;
29624 }
29625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29626 return resultobj;
29627 fail:
29628 return NULL;
29629 }
29630
29631
29632 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29633 PyObject *resultobj = 0;
29634 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29635 void *argp1 = 0 ;
29636 int res1 = 0 ;
29637 PyObject *swig_obj[1] ;
29638
29639 if (!args) SWIG_fail;
29640 swig_obj[0] = args;
29641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29642 if (!SWIG_IsOK(res1)) {
29643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29644 }
29645 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29646 {
29647 PyThreadState* __tstate = wxPyBeginAllowThreads();
29648 delete arg1;
29649
29650 wxPyEndAllowThreads(__tstate);
29651 if (PyErr_Occurred()) SWIG_fail;
29652 }
29653 resultobj = SWIG_Py_Void();
29654 return resultobj;
29655 fail:
29656 return NULL;
29657 }
29658
29659
29660 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29661 PyObject *resultobj = 0;
29662 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29663 PyObject *arg2 = (PyObject *) 0 ;
29664 void *argp1 = 0 ;
29665 int res1 = 0 ;
29666 PyObject * obj0 = 0 ;
29667 PyObject * obj1 = 0 ;
29668 char * kwnames[] = {
29669 (char *) "self",(char *) "self", NULL
29670 };
29671
29672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29674 if (!SWIG_IsOK(res1)) {
29675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29676 }
29677 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29678 arg2 = obj1;
29679 {
29680 PyThreadState* __tstate = wxPyBeginAllowThreads();
29681 (arg1)->SetSelf(arg2);
29682 wxPyEndAllowThreads(__tstate);
29683 if (PyErr_Occurred()) SWIG_fail;
29684 }
29685 resultobj = SWIG_Py_Void();
29686 return resultobj;
29687 fail:
29688 return NULL;
29689 }
29690
29691
29692 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29693 PyObject *resultobj = 0;
29694 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29695 PyObject *result = 0 ;
29696 void *argp1 = 0 ;
29697 int res1 = 0 ;
29698 PyObject *swig_obj[1] ;
29699
29700 if (!args) SWIG_fail;
29701 swig_obj[0] = args;
29702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29703 if (!SWIG_IsOK(res1)) {
29704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29705 }
29706 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29707 {
29708 PyThreadState* __tstate = wxPyBeginAllowThreads();
29709 result = (PyObject *)(arg1)->GetSelf();
29710 wxPyEndAllowThreads(__tstate);
29711 if (PyErr_Occurred()) SWIG_fail;
29712 }
29713 resultobj = result;
29714 return resultobj;
29715 fail:
29716 return NULL;
29717 }
29718
29719
29720 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29721 PyObject *obj;
29722 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29723 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29724 return SWIG_Py_Void();
29725 }
29726
29727 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29728 return SWIG_Python_InitShadowInstance(args);
29729 }
29730
29731 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29732 PyObject *resultobj = 0;
29733 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29734 int arg2 = (int) 0 ;
29735 wxPyCommandEvent *result = 0 ;
29736 int val1 ;
29737 int ecode1 = 0 ;
29738 int val2 ;
29739 int ecode2 = 0 ;
29740 PyObject * obj0 = 0 ;
29741 PyObject * obj1 = 0 ;
29742 char * kwnames[] = {
29743 (char *) "eventType",(char *) "id", NULL
29744 };
29745
29746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29747 if (obj0) {
29748 ecode1 = SWIG_AsVal_int(obj0, &val1);
29749 if (!SWIG_IsOK(ecode1)) {
29750 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29751 }
29752 arg1 = static_cast< wxEventType >(val1);
29753 }
29754 if (obj1) {
29755 ecode2 = SWIG_AsVal_int(obj1, &val2);
29756 if (!SWIG_IsOK(ecode2)) {
29757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29758 }
29759 arg2 = static_cast< int >(val2);
29760 }
29761 {
29762 PyThreadState* __tstate = wxPyBeginAllowThreads();
29763 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29764 wxPyEndAllowThreads(__tstate);
29765 if (PyErr_Occurred()) SWIG_fail;
29766 }
29767 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29768 return resultobj;
29769 fail:
29770 return NULL;
29771 }
29772
29773
29774 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29775 PyObject *resultobj = 0;
29776 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29777 void *argp1 = 0 ;
29778 int res1 = 0 ;
29779 PyObject *swig_obj[1] ;
29780
29781 if (!args) SWIG_fail;
29782 swig_obj[0] = args;
29783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29784 if (!SWIG_IsOK(res1)) {
29785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29786 }
29787 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29788 {
29789 PyThreadState* __tstate = wxPyBeginAllowThreads();
29790 delete arg1;
29791
29792 wxPyEndAllowThreads(__tstate);
29793 if (PyErr_Occurred()) SWIG_fail;
29794 }
29795 resultobj = SWIG_Py_Void();
29796 return resultobj;
29797 fail:
29798 return NULL;
29799 }
29800
29801
29802 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29803 PyObject *resultobj = 0;
29804 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29805 PyObject *arg2 = (PyObject *) 0 ;
29806 void *argp1 = 0 ;
29807 int res1 = 0 ;
29808 PyObject * obj0 = 0 ;
29809 PyObject * obj1 = 0 ;
29810 char * kwnames[] = {
29811 (char *) "self",(char *) "self", NULL
29812 };
29813
29814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29816 if (!SWIG_IsOK(res1)) {
29817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29818 }
29819 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29820 arg2 = obj1;
29821 {
29822 PyThreadState* __tstate = wxPyBeginAllowThreads();
29823 (arg1)->SetSelf(arg2);
29824 wxPyEndAllowThreads(__tstate);
29825 if (PyErr_Occurred()) SWIG_fail;
29826 }
29827 resultobj = SWIG_Py_Void();
29828 return resultobj;
29829 fail:
29830 return NULL;
29831 }
29832
29833
29834 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29835 PyObject *resultobj = 0;
29836 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29837 PyObject *result = 0 ;
29838 void *argp1 = 0 ;
29839 int res1 = 0 ;
29840 PyObject *swig_obj[1] ;
29841
29842 if (!args) SWIG_fail;
29843 swig_obj[0] = args;
29844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29845 if (!SWIG_IsOK(res1)) {
29846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29847 }
29848 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29849 {
29850 PyThreadState* __tstate = wxPyBeginAllowThreads();
29851 result = (PyObject *)(arg1)->GetSelf();
29852 wxPyEndAllowThreads(__tstate);
29853 if (PyErr_Occurred()) SWIG_fail;
29854 }
29855 resultobj = result;
29856 return resultobj;
29857 fail:
29858 return NULL;
29859 }
29860
29861
29862 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29863 PyObject *obj;
29864 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29865 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29866 return SWIG_Py_Void();
29867 }
29868
29869 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29870 return SWIG_Python_InitShadowInstance(args);
29871 }
29872
29873 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29874 PyObject *resultobj = 0;
29875 wxWindow *arg1 = (wxWindow *) 0 ;
29876 wxDateTime *arg2 = 0 ;
29877 wxEventType arg3 ;
29878 wxDateEvent *result = 0 ;
29879 void *argp1 = 0 ;
29880 int res1 = 0 ;
29881 void *argp2 = 0 ;
29882 int res2 = 0 ;
29883 int val3 ;
29884 int ecode3 = 0 ;
29885 PyObject * obj0 = 0 ;
29886 PyObject * obj1 = 0 ;
29887 PyObject * obj2 = 0 ;
29888 char * kwnames[] = {
29889 (char *) "win",(char *) "dt",(char *) "type", NULL
29890 };
29891
29892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29894 if (!SWIG_IsOK(res1)) {
29895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29896 }
29897 arg1 = reinterpret_cast< wxWindow * >(argp1);
29898 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29899 if (!SWIG_IsOK(res2)) {
29900 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29901 }
29902 if (!argp2) {
29903 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29904 }
29905 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29906 ecode3 = SWIG_AsVal_int(obj2, &val3);
29907 if (!SWIG_IsOK(ecode3)) {
29908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29909 }
29910 arg3 = static_cast< wxEventType >(val3);
29911 {
29912 PyThreadState* __tstate = wxPyBeginAllowThreads();
29913 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29914 wxPyEndAllowThreads(__tstate);
29915 if (PyErr_Occurred()) SWIG_fail;
29916 }
29917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29918 return resultobj;
29919 fail:
29920 return NULL;
29921 }
29922
29923
29924 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29925 PyObject *resultobj = 0;
29926 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29927 wxDateTime *result = 0 ;
29928 void *argp1 = 0 ;
29929 int res1 = 0 ;
29930 PyObject *swig_obj[1] ;
29931
29932 if (!args) SWIG_fail;
29933 swig_obj[0] = args;
29934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29935 if (!SWIG_IsOK(res1)) {
29936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29937 }
29938 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29939 {
29940 PyThreadState* __tstate = wxPyBeginAllowThreads();
29941 {
29942 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29943 result = (wxDateTime *) &_result_ref;
29944 }
29945 wxPyEndAllowThreads(__tstate);
29946 if (PyErr_Occurred()) SWIG_fail;
29947 }
29948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29949 return resultobj;
29950 fail:
29951 return NULL;
29952 }
29953
29954
29955 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29956 PyObject *resultobj = 0;
29957 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29958 wxDateTime *arg2 = 0 ;
29959 void *argp1 = 0 ;
29960 int res1 = 0 ;
29961 void *argp2 = 0 ;
29962 int res2 = 0 ;
29963 PyObject * obj0 = 0 ;
29964 PyObject * obj1 = 0 ;
29965 char * kwnames[] = {
29966 (char *) "self",(char *) "date", NULL
29967 };
29968
29969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29971 if (!SWIG_IsOK(res1)) {
29972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29973 }
29974 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29975 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29976 if (!SWIG_IsOK(res2)) {
29977 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29978 }
29979 if (!argp2) {
29980 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29981 }
29982 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29983 {
29984 PyThreadState* __tstate = wxPyBeginAllowThreads();
29985 (arg1)->SetDate((wxDateTime const &)*arg2);
29986 wxPyEndAllowThreads(__tstate);
29987 if (PyErr_Occurred()) SWIG_fail;
29988 }
29989 resultobj = SWIG_Py_Void();
29990 return resultobj;
29991 fail:
29992 return NULL;
29993 }
29994
29995
29996 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29997 PyObject *obj;
29998 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29999 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
30000 return SWIG_Py_Void();
30001 }
30002
30003 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30004 return SWIG_Python_InitShadowInstance(args);
30005 }
30006
30007 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30008 PyObject *resultobj = 0;
30009 wxPyApp *result = 0 ;
30010
30011 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
30012 {
30013 PyThreadState* __tstate = wxPyBeginAllowThreads();
30014 result = (wxPyApp *)new_wxPyApp();
30015 wxPyEndAllowThreads(__tstate);
30016 if (PyErr_Occurred()) SWIG_fail;
30017 }
30018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
30019 return resultobj;
30020 fail:
30021 return NULL;
30022 }
30023
30024
30025 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30026 PyObject *resultobj = 0;
30027 wxPyApp *arg1 = (wxPyApp *) 0 ;
30028 void *argp1 = 0 ;
30029 int res1 = 0 ;
30030 PyObject *swig_obj[1] ;
30031
30032 if (!args) SWIG_fail;
30033 swig_obj[0] = args;
30034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
30035 if (!SWIG_IsOK(res1)) {
30036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
30037 }
30038 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30039 {
30040 PyThreadState* __tstate = wxPyBeginAllowThreads();
30041 delete arg1;
30042
30043 wxPyEndAllowThreads(__tstate);
30044 if (PyErr_Occurred()) SWIG_fail;
30045 }
30046 resultobj = SWIG_Py_Void();
30047 return resultobj;
30048 fail:
30049 return NULL;
30050 }
30051
30052
30053 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30054 PyObject *resultobj = 0;
30055 wxPyApp *arg1 = (wxPyApp *) 0 ;
30056 PyObject *arg2 = (PyObject *) 0 ;
30057 PyObject *arg3 = (PyObject *) 0 ;
30058 bool arg4 ;
30059 void *argp1 = 0 ;
30060 int res1 = 0 ;
30061 bool val4 ;
30062 int ecode4 = 0 ;
30063 PyObject * obj0 = 0 ;
30064 PyObject * obj1 = 0 ;
30065 PyObject * obj2 = 0 ;
30066 PyObject * obj3 = 0 ;
30067 char * kwnames[] = {
30068 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
30069 };
30070
30071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30073 if (!SWIG_IsOK(res1)) {
30074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
30075 }
30076 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30077 arg2 = obj1;
30078 arg3 = obj2;
30079 ecode4 = SWIG_AsVal_bool(obj3, &val4);
30080 if (!SWIG_IsOK(ecode4)) {
30081 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
30082 }
30083 arg4 = static_cast< bool >(val4);
30084 {
30085 PyThreadState* __tstate = wxPyBeginAllowThreads();
30086 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
30087 wxPyEndAllowThreads(__tstate);
30088 if (PyErr_Occurred()) SWIG_fail;
30089 }
30090 resultobj = SWIG_Py_Void();
30091 return resultobj;
30092 fail:
30093 return NULL;
30094 }
30095
30096
30097 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30098 PyObject *resultobj = 0;
30099 wxPyApp *arg1 = (wxPyApp *) 0 ;
30100 wxString result;
30101 void *argp1 = 0 ;
30102 int res1 = 0 ;
30103 PyObject *swig_obj[1] ;
30104
30105 if (!args) SWIG_fail;
30106 swig_obj[0] = args;
30107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30108 if (!SWIG_IsOK(res1)) {
30109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30110 }
30111 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30112 {
30113 PyThreadState* __tstate = wxPyBeginAllowThreads();
30114 result = ((wxPyApp const *)arg1)->GetAppName();
30115 wxPyEndAllowThreads(__tstate);
30116 if (PyErr_Occurred()) SWIG_fail;
30117 }
30118 {
30119 #if wxUSE_UNICODE
30120 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30121 #else
30122 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30123 #endif
30124 }
30125 return resultobj;
30126 fail:
30127 return NULL;
30128 }
30129
30130
30131 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30132 PyObject *resultobj = 0;
30133 wxPyApp *arg1 = (wxPyApp *) 0 ;
30134 wxString *arg2 = 0 ;
30135 void *argp1 = 0 ;
30136 int res1 = 0 ;
30137 bool temp2 = false ;
30138 PyObject * obj0 = 0 ;
30139 PyObject * obj1 = 0 ;
30140 char * kwnames[] = {
30141 (char *) "self",(char *) "name", NULL
30142 };
30143
30144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30146 if (!SWIG_IsOK(res1)) {
30147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30148 }
30149 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30150 {
30151 arg2 = wxString_in_helper(obj1);
30152 if (arg2 == NULL) SWIG_fail;
30153 temp2 = true;
30154 }
30155 {
30156 PyThreadState* __tstate = wxPyBeginAllowThreads();
30157 (arg1)->SetAppName((wxString const &)*arg2);
30158 wxPyEndAllowThreads(__tstate);
30159 if (PyErr_Occurred()) SWIG_fail;
30160 }
30161 resultobj = SWIG_Py_Void();
30162 {
30163 if (temp2)
30164 delete arg2;
30165 }
30166 return resultobj;
30167 fail:
30168 {
30169 if (temp2)
30170 delete arg2;
30171 }
30172 return NULL;
30173 }
30174
30175
30176 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30177 PyObject *resultobj = 0;
30178 wxPyApp *arg1 = (wxPyApp *) 0 ;
30179 wxString result;
30180 void *argp1 = 0 ;
30181 int res1 = 0 ;
30182 PyObject *swig_obj[1] ;
30183
30184 if (!args) SWIG_fail;
30185 swig_obj[0] = args;
30186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30187 if (!SWIG_IsOK(res1)) {
30188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30189 }
30190 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30191 {
30192 PyThreadState* __tstate = wxPyBeginAllowThreads();
30193 result = ((wxPyApp const *)arg1)->GetClassName();
30194 wxPyEndAllowThreads(__tstate);
30195 if (PyErr_Occurred()) SWIG_fail;
30196 }
30197 {
30198 #if wxUSE_UNICODE
30199 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30200 #else
30201 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30202 #endif
30203 }
30204 return resultobj;
30205 fail:
30206 return NULL;
30207 }
30208
30209
30210 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30211 PyObject *resultobj = 0;
30212 wxPyApp *arg1 = (wxPyApp *) 0 ;
30213 wxString *arg2 = 0 ;
30214 void *argp1 = 0 ;
30215 int res1 = 0 ;
30216 bool temp2 = false ;
30217 PyObject * obj0 = 0 ;
30218 PyObject * obj1 = 0 ;
30219 char * kwnames[] = {
30220 (char *) "self",(char *) "name", NULL
30221 };
30222
30223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30225 if (!SWIG_IsOK(res1)) {
30226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30227 }
30228 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30229 {
30230 arg2 = wxString_in_helper(obj1);
30231 if (arg2 == NULL) SWIG_fail;
30232 temp2 = true;
30233 }
30234 {
30235 PyThreadState* __tstate = wxPyBeginAllowThreads();
30236 (arg1)->SetClassName((wxString const &)*arg2);
30237 wxPyEndAllowThreads(__tstate);
30238 if (PyErr_Occurred()) SWIG_fail;
30239 }
30240 resultobj = SWIG_Py_Void();
30241 {
30242 if (temp2)
30243 delete arg2;
30244 }
30245 return resultobj;
30246 fail:
30247 {
30248 if (temp2)
30249 delete arg2;
30250 }
30251 return NULL;
30252 }
30253
30254
30255 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30256 PyObject *resultobj = 0;
30257 wxPyApp *arg1 = (wxPyApp *) 0 ;
30258 wxString *result = 0 ;
30259 void *argp1 = 0 ;
30260 int res1 = 0 ;
30261 PyObject *swig_obj[1] ;
30262
30263 if (!args) SWIG_fail;
30264 swig_obj[0] = args;
30265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30266 if (!SWIG_IsOK(res1)) {
30267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30268 }
30269 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30270 {
30271 PyThreadState* __tstate = wxPyBeginAllowThreads();
30272 {
30273 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30274 result = (wxString *) &_result_ref;
30275 }
30276 wxPyEndAllowThreads(__tstate);
30277 if (PyErr_Occurred()) SWIG_fail;
30278 }
30279 {
30280 #if wxUSE_UNICODE
30281 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30282 #else
30283 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30284 #endif
30285 }
30286 return resultobj;
30287 fail:
30288 return NULL;
30289 }
30290
30291
30292 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30293 PyObject *resultobj = 0;
30294 wxPyApp *arg1 = (wxPyApp *) 0 ;
30295 wxString *arg2 = 0 ;
30296 void *argp1 = 0 ;
30297 int res1 = 0 ;
30298 bool temp2 = false ;
30299 PyObject * obj0 = 0 ;
30300 PyObject * obj1 = 0 ;
30301 char * kwnames[] = {
30302 (char *) "self",(char *) "name", NULL
30303 };
30304
30305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30307 if (!SWIG_IsOK(res1)) {
30308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30309 }
30310 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30311 {
30312 arg2 = wxString_in_helper(obj1);
30313 if (arg2 == NULL) SWIG_fail;
30314 temp2 = true;
30315 }
30316 {
30317 PyThreadState* __tstate = wxPyBeginAllowThreads();
30318 (arg1)->SetVendorName((wxString const &)*arg2);
30319 wxPyEndAllowThreads(__tstate);
30320 if (PyErr_Occurred()) SWIG_fail;
30321 }
30322 resultobj = SWIG_Py_Void();
30323 {
30324 if (temp2)
30325 delete arg2;
30326 }
30327 return resultobj;
30328 fail:
30329 {
30330 if (temp2)
30331 delete arg2;
30332 }
30333 return NULL;
30334 }
30335
30336
30337 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30338 PyObject *resultobj = 0;
30339 wxPyApp *arg1 = (wxPyApp *) 0 ;
30340 wxAppTraits *result = 0 ;
30341 void *argp1 = 0 ;
30342 int res1 = 0 ;
30343 PyObject *swig_obj[1] ;
30344
30345 if (!args) SWIG_fail;
30346 swig_obj[0] = args;
30347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30348 if (!SWIG_IsOK(res1)) {
30349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30350 }
30351 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30352 {
30353 PyThreadState* __tstate = wxPyBeginAllowThreads();
30354 result = (wxAppTraits *)(arg1)->GetTraits();
30355 wxPyEndAllowThreads(__tstate);
30356 if (PyErr_Occurred()) SWIG_fail;
30357 }
30358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30359 return resultobj;
30360 fail:
30361 return NULL;
30362 }
30363
30364
30365 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30366 PyObject *resultobj = 0;
30367 wxPyApp *arg1 = (wxPyApp *) 0 ;
30368 void *argp1 = 0 ;
30369 int res1 = 0 ;
30370 PyObject *swig_obj[1] ;
30371
30372 if (!args) SWIG_fail;
30373 swig_obj[0] = args;
30374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30375 if (!SWIG_IsOK(res1)) {
30376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30377 }
30378 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30379 {
30380 PyThreadState* __tstate = wxPyBeginAllowThreads();
30381 (arg1)->ProcessPendingEvents();
30382 wxPyEndAllowThreads(__tstate);
30383 if (PyErr_Occurred()) SWIG_fail;
30384 }
30385 resultobj = SWIG_Py_Void();
30386 return resultobj;
30387 fail:
30388 return NULL;
30389 }
30390
30391
30392 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30393 PyObject *resultobj = 0;
30394 wxPyApp *arg1 = (wxPyApp *) 0 ;
30395 bool arg2 = (bool) false ;
30396 bool result;
30397 void *argp1 = 0 ;
30398 int res1 = 0 ;
30399 bool val2 ;
30400 int ecode2 = 0 ;
30401 PyObject * obj0 = 0 ;
30402 PyObject * obj1 = 0 ;
30403 char * kwnames[] = {
30404 (char *) "self",(char *) "onlyIfNeeded", NULL
30405 };
30406
30407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30409 if (!SWIG_IsOK(res1)) {
30410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30411 }
30412 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30413 if (obj1) {
30414 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30415 if (!SWIG_IsOK(ecode2)) {
30416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30417 }
30418 arg2 = static_cast< bool >(val2);
30419 }
30420 {
30421 PyThreadState* __tstate = wxPyBeginAllowThreads();
30422 result = (bool)(arg1)->Yield(arg2);
30423 wxPyEndAllowThreads(__tstate);
30424 if (PyErr_Occurred()) SWIG_fail;
30425 }
30426 {
30427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30428 }
30429 return resultobj;
30430 fail:
30431 return NULL;
30432 }
30433
30434
30435 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30436 PyObject *resultobj = 0;
30437 wxPyApp *arg1 = (wxPyApp *) 0 ;
30438 void *argp1 = 0 ;
30439 int res1 = 0 ;
30440 PyObject *swig_obj[1] ;
30441
30442 if (!args) SWIG_fail;
30443 swig_obj[0] = args;
30444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30445 if (!SWIG_IsOK(res1)) {
30446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30447 }
30448 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30449 {
30450 PyThreadState* __tstate = wxPyBeginAllowThreads();
30451 (arg1)->WakeUpIdle();
30452 wxPyEndAllowThreads(__tstate);
30453 if (PyErr_Occurred()) SWIG_fail;
30454 }
30455 resultobj = SWIG_Py_Void();
30456 return resultobj;
30457 fail:
30458 return NULL;
30459 }
30460
30461
30462 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30463 PyObject *resultobj = 0;
30464 bool result;
30465
30466 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30467 {
30468 PyThreadState* __tstate = wxPyBeginAllowThreads();
30469 result = (bool)wxPyApp::IsMainLoopRunning();
30470 wxPyEndAllowThreads(__tstate);
30471 if (PyErr_Occurred()) SWIG_fail;
30472 }
30473 {
30474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30475 }
30476 return resultobj;
30477 fail:
30478 return NULL;
30479 }
30480
30481
30482 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30483 PyObject *resultobj = 0;
30484 wxPyApp *arg1 = (wxPyApp *) 0 ;
30485 int result;
30486 void *argp1 = 0 ;
30487 int res1 = 0 ;
30488 PyObject *swig_obj[1] ;
30489
30490 if (!args) SWIG_fail;
30491 swig_obj[0] = args;
30492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30493 if (!SWIG_IsOK(res1)) {
30494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30495 }
30496 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30497 {
30498 PyThreadState* __tstate = wxPyBeginAllowThreads();
30499 result = (int)(arg1)->MainLoop();
30500 wxPyEndAllowThreads(__tstate);
30501 if (PyErr_Occurred()) SWIG_fail;
30502 }
30503 resultobj = SWIG_From_int(static_cast< int >(result));
30504 return resultobj;
30505 fail:
30506 return NULL;
30507 }
30508
30509
30510 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30511 PyObject *resultobj = 0;
30512 wxPyApp *arg1 = (wxPyApp *) 0 ;
30513 void *argp1 = 0 ;
30514 int res1 = 0 ;
30515 PyObject *swig_obj[1] ;
30516
30517 if (!args) SWIG_fail;
30518 swig_obj[0] = args;
30519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30520 if (!SWIG_IsOK(res1)) {
30521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30522 }
30523 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30524 {
30525 PyThreadState* __tstate = wxPyBeginAllowThreads();
30526 (arg1)->Exit();
30527 wxPyEndAllowThreads(__tstate);
30528 if (PyErr_Occurred()) SWIG_fail;
30529 }
30530 resultobj = SWIG_Py_Void();
30531 return resultobj;
30532 fail:
30533 return NULL;
30534 }
30535
30536
30537 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30538 PyObject *resultobj = 0;
30539 wxPyApp *arg1 = (wxPyApp *) 0 ;
30540 wxLayoutDirection result;
30541 void *argp1 = 0 ;
30542 int res1 = 0 ;
30543 PyObject *swig_obj[1] ;
30544
30545 if (!args) SWIG_fail;
30546 swig_obj[0] = args;
30547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30548 if (!SWIG_IsOK(res1)) {
30549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30550 }
30551 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30552 {
30553 PyThreadState* __tstate = wxPyBeginAllowThreads();
30554 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30555 wxPyEndAllowThreads(__tstate);
30556 if (PyErr_Occurred()) SWIG_fail;
30557 }
30558 resultobj = SWIG_From_int(static_cast< int >(result));
30559 return resultobj;
30560 fail:
30561 return NULL;
30562 }
30563
30564
30565 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30566 PyObject *resultobj = 0;
30567 wxPyApp *arg1 = (wxPyApp *) 0 ;
30568 void *argp1 = 0 ;
30569 int res1 = 0 ;
30570 PyObject *swig_obj[1] ;
30571
30572 if (!args) SWIG_fail;
30573 swig_obj[0] = args;
30574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30575 if (!SWIG_IsOK(res1)) {
30576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30577 }
30578 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30579 {
30580 PyThreadState* __tstate = wxPyBeginAllowThreads();
30581 (arg1)->ExitMainLoop();
30582 wxPyEndAllowThreads(__tstate);
30583 if (PyErr_Occurred()) SWIG_fail;
30584 }
30585 resultobj = SWIG_Py_Void();
30586 return resultobj;
30587 fail:
30588 return NULL;
30589 }
30590
30591
30592 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30593 PyObject *resultobj = 0;
30594 wxPyApp *arg1 = (wxPyApp *) 0 ;
30595 bool result;
30596 void *argp1 = 0 ;
30597 int res1 = 0 ;
30598 PyObject *swig_obj[1] ;
30599
30600 if (!args) SWIG_fail;
30601 swig_obj[0] = args;
30602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30603 if (!SWIG_IsOK(res1)) {
30604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30605 }
30606 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30607 {
30608 PyThreadState* __tstate = wxPyBeginAllowThreads();
30609 result = (bool)(arg1)->Pending();
30610 wxPyEndAllowThreads(__tstate);
30611 if (PyErr_Occurred()) SWIG_fail;
30612 }
30613 {
30614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30615 }
30616 return resultobj;
30617 fail:
30618 return NULL;
30619 }
30620
30621
30622 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30623 PyObject *resultobj = 0;
30624 wxPyApp *arg1 = (wxPyApp *) 0 ;
30625 bool result;
30626 void *argp1 = 0 ;
30627 int res1 = 0 ;
30628 PyObject *swig_obj[1] ;
30629
30630 if (!args) SWIG_fail;
30631 swig_obj[0] = args;
30632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30633 if (!SWIG_IsOK(res1)) {
30634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30635 }
30636 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30637 {
30638 PyThreadState* __tstate = wxPyBeginAllowThreads();
30639 result = (bool)(arg1)->Dispatch();
30640 wxPyEndAllowThreads(__tstate);
30641 if (PyErr_Occurred()) SWIG_fail;
30642 }
30643 {
30644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30645 }
30646 return resultobj;
30647 fail:
30648 return NULL;
30649 }
30650
30651
30652 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30653 PyObject *resultobj = 0;
30654 wxPyApp *arg1 = (wxPyApp *) 0 ;
30655 bool result;
30656 void *argp1 = 0 ;
30657 int res1 = 0 ;
30658 PyObject *swig_obj[1] ;
30659
30660 if (!args) SWIG_fail;
30661 swig_obj[0] = args;
30662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30663 if (!SWIG_IsOK(res1)) {
30664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30665 }
30666 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30667 {
30668 PyThreadState* __tstate = wxPyBeginAllowThreads();
30669 result = (bool)(arg1)->ProcessIdle();
30670 wxPyEndAllowThreads(__tstate);
30671 if (PyErr_Occurred()) SWIG_fail;
30672 }
30673 {
30674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30675 }
30676 return resultobj;
30677 fail:
30678 return NULL;
30679 }
30680
30681
30682 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30683 PyObject *resultobj = 0;
30684 wxPyApp *arg1 = (wxPyApp *) 0 ;
30685 wxWindow *arg2 = (wxWindow *) 0 ;
30686 wxIdleEvent *arg3 = 0 ;
30687 bool result;
30688 void *argp1 = 0 ;
30689 int res1 = 0 ;
30690 void *argp2 = 0 ;
30691 int res2 = 0 ;
30692 void *argp3 = 0 ;
30693 int res3 = 0 ;
30694 PyObject * obj0 = 0 ;
30695 PyObject * obj1 = 0 ;
30696 PyObject * obj2 = 0 ;
30697 char * kwnames[] = {
30698 (char *) "self",(char *) "win",(char *) "event", NULL
30699 };
30700
30701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30703 if (!SWIG_IsOK(res1)) {
30704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30705 }
30706 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30707 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30708 if (!SWIG_IsOK(res2)) {
30709 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30710 }
30711 arg2 = reinterpret_cast< wxWindow * >(argp2);
30712 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30713 if (!SWIG_IsOK(res3)) {
30714 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30715 }
30716 if (!argp3) {
30717 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30718 }
30719 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30720 {
30721 PyThreadState* __tstate = wxPyBeginAllowThreads();
30722 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30723 wxPyEndAllowThreads(__tstate);
30724 if (PyErr_Occurred()) SWIG_fail;
30725 }
30726 {
30727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30728 }
30729 return resultobj;
30730 fail:
30731 return NULL;
30732 }
30733
30734
30735 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30736 PyObject *resultobj = 0;
30737 wxPyApp *arg1 = (wxPyApp *) 0 ;
30738 bool result;
30739 void *argp1 = 0 ;
30740 int res1 = 0 ;
30741 PyObject *swig_obj[1] ;
30742
30743 if (!args) SWIG_fail;
30744 swig_obj[0] = args;
30745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30746 if (!SWIG_IsOK(res1)) {
30747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30748 }
30749 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30750 {
30751 PyThreadState* __tstate = wxPyBeginAllowThreads();
30752 result = (bool)((wxPyApp const *)arg1)->IsActive();
30753 wxPyEndAllowThreads(__tstate);
30754 if (PyErr_Occurred()) SWIG_fail;
30755 }
30756 {
30757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30758 }
30759 return resultobj;
30760 fail:
30761 return NULL;
30762 }
30763
30764
30765 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30766 PyObject *resultobj = 0;
30767 wxPyApp *arg1 = (wxPyApp *) 0 ;
30768 wxWindow *arg2 = (wxWindow *) 0 ;
30769 void *argp1 = 0 ;
30770 int res1 = 0 ;
30771 void *argp2 = 0 ;
30772 int res2 = 0 ;
30773 PyObject * obj0 = 0 ;
30774 PyObject * obj1 = 0 ;
30775 char * kwnames[] = {
30776 (char *) "self",(char *) "win", NULL
30777 };
30778
30779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30781 if (!SWIG_IsOK(res1)) {
30782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30783 }
30784 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30785 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30786 if (!SWIG_IsOK(res2)) {
30787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30788 }
30789 arg2 = reinterpret_cast< wxWindow * >(argp2);
30790 {
30791 PyThreadState* __tstate = wxPyBeginAllowThreads();
30792 (arg1)->SetTopWindow(arg2);
30793 wxPyEndAllowThreads(__tstate);
30794 if (PyErr_Occurred()) SWIG_fail;
30795 }
30796 resultobj = SWIG_Py_Void();
30797 return resultobj;
30798 fail:
30799 return NULL;
30800 }
30801
30802
30803 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30804 PyObject *resultobj = 0;
30805 wxPyApp *arg1 = (wxPyApp *) 0 ;
30806 wxWindow *result = 0 ;
30807 void *argp1 = 0 ;
30808 int res1 = 0 ;
30809 PyObject *swig_obj[1] ;
30810
30811 if (!args) SWIG_fail;
30812 swig_obj[0] = args;
30813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30814 if (!SWIG_IsOK(res1)) {
30815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30816 }
30817 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30818 {
30819 PyThreadState* __tstate = wxPyBeginAllowThreads();
30820 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30821 wxPyEndAllowThreads(__tstate);
30822 if (PyErr_Occurred()) SWIG_fail;
30823 }
30824 {
30825 resultobj = wxPyMake_wxObject(result, (bool)0);
30826 }
30827 return resultobj;
30828 fail:
30829 return NULL;
30830 }
30831
30832
30833 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30834 PyObject *resultobj = 0;
30835 wxPyApp *arg1 = (wxPyApp *) 0 ;
30836 bool arg2 ;
30837 void *argp1 = 0 ;
30838 int res1 = 0 ;
30839 bool val2 ;
30840 int ecode2 = 0 ;
30841 PyObject * obj0 = 0 ;
30842 PyObject * obj1 = 0 ;
30843 char * kwnames[] = {
30844 (char *) "self",(char *) "flag", NULL
30845 };
30846
30847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30849 if (!SWIG_IsOK(res1)) {
30850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30851 }
30852 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30853 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30854 if (!SWIG_IsOK(ecode2)) {
30855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30856 }
30857 arg2 = static_cast< bool >(val2);
30858 {
30859 PyThreadState* __tstate = wxPyBeginAllowThreads();
30860 (arg1)->SetExitOnFrameDelete(arg2);
30861 wxPyEndAllowThreads(__tstate);
30862 if (PyErr_Occurred()) SWIG_fail;
30863 }
30864 resultobj = SWIG_Py_Void();
30865 return resultobj;
30866 fail:
30867 return NULL;
30868 }
30869
30870
30871 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30872 PyObject *resultobj = 0;
30873 wxPyApp *arg1 = (wxPyApp *) 0 ;
30874 bool result;
30875 void *argp1 = 0 ;
30876 int res1 = 0 ;
30877 PyObject *swig_obj[1] ;
30878
30879 if (!args) SWIG_fail;
30880 swig_obj[0] = args;
30881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30882 if (!SWIG_IsOK(res1)) {
30883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30884 }
30885 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30886 {
30887 PyThreadState* __tstate = wxPyBeginAllowThreads();
30888 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30889 wxPyEndAllowThreads(__tstate);
30890 if (PyErr_Occurred()) SWIG_fail;
30891 }
30892 {
30893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30894 }
30895 return resultobj;
30896 fail:
30897 return NULL;
30898 }
30899
30900
30901 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30902 PyObject *resultobj = 0;
30903 wxPyApp *arg1 = (wxPyApp *) 0 ;
30904 bool arg2 ;
30905 void *argp1 = 0 ;
30906 int res1 = 0 ;
30907 bool val2 ;
30908 int ecode2 = 0 ;
30909 PyObject * obj0 = 0 ;
30910 PyObject * obj1 = 0 ;
30911 char * kwnames[] = {
30912 (char *) "self",(char *) "flag", NULL
30913 };
30914
30915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
30916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30917 if (!SWIG_IsOK(res1)) {
30918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
30919 }
30920 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30921 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30922 if (!SWIG_IsOK(ecode2)) {
30923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
30924 }
30925 arg2 = static_cast< bool >(val2);
30926 {
30927 PyThreadState* __tstate = wxPyBeginAllowThreads();
30928 (arg1)->SetUseBestVisual(arg2);
30929 wxPyEndAllowThreads(__tstate);
30930 if (PyErr_Occurred()) SWIG_fail;
30931 }
30932 resultobj = SWIG_Py_Void();
30933 return resultobj;
30934 fail:
30935 return NULL;
30936 }
30937
30938
30939 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30940 PyObject *resultobj = 0;
30941 wxPyApp *arg1 = (wxPyApp *) 0 ;
30942 bool result;
30943 void *argp1 = 0 ;
30944 int res1 = 0 ;
30945 PyObject *swig_obj[1] ;
30946
30947 if (!args) SWIG_fail;
30948 swig_obj[0] = args;
30949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30950 if (!SWIG_IsOK(res1)) {
30951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30952 }
30953 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30954 {
30955 PyThreadState* __tstate = wxPyBeginAllowThreads();
30956 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
30957 wxPyEndAllowThreads(__tstate);
30958 if (PyErr_Occurred()) SWIG_fail;
30959 }
30960 {
30961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30962 }
30963 return resultobj;
30964 fail:
30965 return NULL;
30966 }
30967
30968
30969 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30970 PyObject *resultobj = 0;
30971 wxPyApp *arg1 = (wxPyApp *) 0 ;
30972 int arg2 ;
30973 void *argp1 = 0 ;
30974 int res1 = 0 ;
30975 int val2 ;
30976 int ecode2 = 0 ;
30977 PyObject * obj0 = 0 ;
30978 PyObject * obj1 = 0 ;
30979 char * kwnames[] = {
30980 (char *) "self",(char *) "mode", NULL
30981 };
30982
30983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
30984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30985 if (!SWIG_IsOK(res1)) {
30986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30987 }
30988 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30989 ecode2 = SWIG_AsVal_int(obj1, &val2);
30990 if (!SWIG_IsOK(ecode2)) {
30991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
30992 }
30993 arg2 = static_cast< int >(val2);
30994 {
30995 PyThreadState* __tstate = wxPyBeginAllowThreads();
30996 (arg1)->SetPrintMode(arg2);
30997 wxPyEndAllowThreads(__tstate);
30998 if (PyErr_Occurred()) SWIG_fail;
30999 }
31000 resultobj = SWIG_Py_Void();
31001 return resultobj;
31002 fail:
31003 return NULL;
31004 }
31005
31006
31007 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31008 PyObject *resultobj = 0;
31009 wxPyApp *arg1 = (wxPyApp *) 0 ;
31010 int result;
31011 void *argp1 = 0 ;
31012 int res1 = 0 ;
31013 PyObject *swig_obj[1] ;
31014
31015 if (!args) SWIG_fail;
31016 swig_obj[0] = args;
31017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31018 if (!SWIG_IsOK(res1)) {
31019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31020 }
31021 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31022 {
31023 PyThreadState* __tstate = wxPyBeginAllowThreads();
31024 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
31025 wxPyEndAllowThreads(__tstate);
31026 if (PyErr_Occurred()) SWIG_fail;
31027 }
31028 resultobj = SWIG_From_int(static_cast< int >(result));
31029 return resultobj;
31030 fail:
31031 return NULL;
31032 }
31033
31034
31035 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31036 PyObject *resultobj = 0;
31037 wxPyApp *arg1 = (wxPyApp *) 0 ;
31038 int arg2 ;
31039 void *argp1 = 0 ;
31040 int res1 = 0 ;
31041 int val2 ;
31042 int ecode2 = 0 ;
31043 PyObject * obj0 = 0 ;
31044 PyObject * obj1 = 0 ;
31045 char * kwnames[] = {
31046 (char *) "self",(char *) "mode", NULL
31047 };
31048
31049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
31050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31051 if (!SWIG_IsOK(res1)) {
31052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31053 }
31054 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31055 ecode2 = SWIG_AsVal_int(obj1, &val2);
31056 if (!SWIG_IsOK(ecode2)) {
31057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
31058 }
31059 arg2 = static_cast< int >(val2);
31060 {
31061 PyThreadState* __tstate = wxPyBeginAllowThreads();
31062 (arg1)->SetAssertMode(arg2);
31063 wxPyEndAllowThreads(__tstate);
31064 if (PyErr_Occurred()) SWIG_fail;
31065 }
31066 resultobj = SWIG_Py_Void();
31067 return resultobj;
31068 fail:
31069 return NULL;
31070 }
31071
31072
31073 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31074 PyObject *resultobj = 0;
31075 wxPyApp *arg1 = (wxPyApp *) 0 ;
31076 int result;
31077 void *argp1 = 0 ;
31078 int res1 = 0 ;
31079 PyObject *swig_obj[1] ;
31080
31081 if (!args) SWIG_fail;
31082 swig_obj[0] = args;
31083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31084 if (!SWIG_IsOK(res1)) {
31085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31086 }
31087 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31088 {
31089 PyThreadState* __tstate = wxPyBeginAllowThreads();
31090 result = (int)(arg1)->GetAssertMode();
31091 wxPyEndAllowThreads(__tstate);
31092 if (PyErr_Occurred()) SWIG_fail;
31093 }
31094 resultobj = SWIG_From_int(static_cast< int >(result));
31095 return resultobj;
31096 fail:
31097 return NULL;
31098 }
31099
31100
31101 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31102 PyObject *resultobj = 0;
31103 bool result;
31104
31105 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31106 {
31107 PyThreadState* __tstate = wxPyBeginAllowThreads();
31108 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31109 wxPyEndAllowThreads(__tstate);
31110 if (PyErr_Occurred()) SWIG_fail;
31111 }
31112 {
31113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31114 }
31115 return resultobj;
31116 fail:
31117 return NULL;
31118 }
31119
31120
31121 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31122 PyObject *resultobj = 0;
31123 long result;
31124
31125 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31126 {
31127 PyThreadState* __tstate = wxPyBeginAllowThreads();
31128 result = (long)wxPyApp::GetMacAboutMenuItemId();
31129 wxPyEndAllowThreads(__tstate);
31130 if (PyErr_Occurred()) SWIG_fail;
31131 }
31132 resultobj = SWIG_From_long(static_cast< long >(result));
31133 return resultobj;
31134 fail:
31135 return NULL;
31136 }
31137
31138
31139 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31140 PyObject *resultobj = 0;
31141 long result;
31142
31143 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31144 {
31145 PyThreadState* __tstate = wxPyBeginAllowThreads();
31146 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31147 wxPyEndAllowThreads(__tstate);
31148 if (PyErr_Occurred()) SWIG_fail;
31149 }
31150 resultobj = SWIG_From_long(static_cast< long >(result));
31151 return resultobj;
31152 fail:
31153 return NULL;
31154 }
31155
31156
31157 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31158 PyObject *resultobj = 0;
31159 long result;
31160
31161 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31162 {
31163 PyThreadState* __tstate = wxPyBeginAllowThreads();
31164 result = (long)wxPyApp::GetMacExitMenuItemId();
31165 wxPyEndAllowThreads(__tstate);
31166 if (PyErr_Occurred()) SWIG_fail;
31167 }
31168 resultobj = SWIG_From_long(static_cast< long >(result));
31169 return resultobj;
31170 fail:
31171 return NULL;
31172 }
31173
31174
31175 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31176 PyObject *resultobj = 0;
31177 wxString result;
31178
31179 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31180 {
31181 PyThreadState* __tstate = wxPyBeginAllowThreads();
31182 result = wxPyApp::GetMacHelpMenuTitleName();
31183 wxPyEndAllowThreads(__tstate);
31184 if (PyErr_Occurred()) SWIG_fail;
31185 }
31186 {
31187 #if wxUSE_UNICODE
31188 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31189 #else
31190 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31191 #endif
31192 }
31193 return resultobj;
31194 fail:
31195 return NULL;
31196 }
31197
31198
31199 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31200 PyObject *resultobj = 0;
31201 bool arg1 ;
31202 bool val1 ;
31203 int ecode1 = 0 ;
31204 PyObject * obj0 = 0 ;
31205 char * kwnames[] = {
31206 (char *) "val", NULL
31207 };
31208
31209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31210 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31211 if (!SWIG_IsOK(ecode1)) {
31212 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31213 }
31214 arg1 = static_cast< bool >(val1);
31215 {
31216 PyThreadState* __tstate = wxPyBeginAllowThreads();
31217 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31218 wxPyEndAllowThreads(__tstate);
31219 if (PyErr_Occurred()) SWIG_fail;
31220 }
31221 resultobj = SWIG_Py_Void();
31222 return resultobj;
31223 fail:
31224 return NULL;
31225 }
31226
31227
31228 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31229 PyObject *resultobj = 0;
31230 long arg1 ;
31231 long val1 ;
31232 int ecode1 = 0 ;
31233 PyObject * obj0 = 0 ;
31234 char * kwnames[] = {
31235 (char *) "val", NULL
31236 };
31237
31238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31239 ecode1 = SWIG_AsVal_long(obj0, &val1);
31240 if (!SWIG_IsOK(ecode1)) {
31241 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31242 }
31243 arg1 = static_cast< long >(val1);
31244 {
31245 PyThreadState* __tstate = wxPyBeginAllowThreads();
31246 wxPyApp::SetMacAboutMenuItemId(arg1);
31247 wxPyEndAllowThreads(__tstate);
31248 if (PyErr_Occurred()) SWIG_fail;
31249 }
31250 resultobj = SWIG_Py_Void();
31251 return resultobj;
31252 fail:
31253 return NULL;
31254 }
31255
31256
31257 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31258 PyObject *resultobj = 0;
31259 long arg1 ;
31260 long val1 ;
31261 int ecode1 = 0 ;
31262 PyObject * obj0 = 0 ;
31263 char * kwnames[] = {
31264 (char *) "val", NULL
31265 };
31266
31267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31268 ecode1 = SWIG_AsVal_long(obj0, &val1);
31269 if (!SWIG_IsOK(ecode1)) {
31270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31271 }
31272 arg1 = static_cast< long >(val1);
31273 {
31274 PyThreadState* __tstate = wxPyBeginAllowThreads();
31275 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31276 wxPyEndAllowThreads(__tstate);
31277 if (PyErr_Occurred()) SWIG_fail;
31278 }
31279 resultobj = SWIG_Py_Void();
31280 return resultobj;
31281 fail:
31282 return NULL;
31283 }
31284
31285
31286 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31287 PyObject *resultobj = 0;
31288 long arg1 ;
31289 long val1 ;
31290 int ecode1 = 0 ;
31291 PyObject * obj0 = 0 ;
31292 char * kwnames[] = {
31293 (char *) "val", NULL
31294 };
31295
31296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31297 ecode1 = SWIG_AsVal_long(obj0, &val1);
31298 if (!SWIG_IsOK(ecode1)) {
31299 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31300 }
31301 arg1 = static_cast< long >(val1);
31302 {
31303 PyThreadState* __tstate = wxPyBeginAllowThreads();
31304 wxPyApp::SetMacExitMenuItemId(arg1);
31305 wxPyEndAllowThreads(__tstate);
31306 if (PyErr_Occurred()) SWIG_fail;
31307 }
31308 resultobj = SWIG_Py_Void();
31309 return resultobj;
31310 fail:
31311 return NULL;
31312 }
31313
31314
31315 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31316 PyObject *resultobj = 0;
31317 wxString *arg1 = 0 ;
31318 bool temp1 = false ;
31319 PyObject * obj0 = 0 ;
31320 char * kwnames[] = {
31321 (char *) "val", NULL
31322 };
31323
31324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31325 {
31326 arg1 = wxString_in_helper(obj0);
31327 if (arg1 == NULL) SWIG_fail;
31328 temp1 = true;
31329 }
31330 {
31331 PyThreadState* __tstate = wxPyBeginAllowThreads();
31332 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31333 wxPyEndAllowThreads(__tstate);
31334 if (PyErr_Occurred()) SWIG_fail;
31335 }
31336 resultobj = SWIG_Py_Void();
31337 {
31338 if (temp1)
31339 delete arg1;
31340 }
31341 return resultobj;
31342 fail:
31343 {
31344 if (temp1)
31345 delete arg1;
31346 }
31347 return NULL;
31348 }
31349
31350
31351 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31352 PyObject *resultobj = 0;
31353 wxPyApp *arg1 = (wxPyApp *) 0 ;
31354 void *argp1 = 0 ;
31355 int res1 = 0 ;
31356 PyObject *swig_obj[1] ;
31357
31358 if (!args) SWIG_fail;
31359 swig_obj[0] = args;
31360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31361 if (!SWIG_IsOK(res1)) {
31362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31363 }
31364 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31365 {
31366 PyThreadState* __tstate = wxPyBeginAllowThreads();
31367 (arg1)->_BootstrapApp();
31368 wxPyEndAllowThreads(__tstate);
31369 if (PyErr_Occurred()) SWIG_fail;
31370 }
31371 resultobj = SWIG_Py_Void();
31372 return resultobj;
31373 fail:
31374 return NULL;
31375 }
31376
31377
31378 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31379 PyObject *resultobj = 0;
31380 int result;
31381
31382 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31383 {
31384 PyThreadState* __tstate = wxPyBeginAllowThreads();
31385 result = (int)wxPyApp_GetComCtl32Version();
31386 wxPyEndAllowThreads(__tstate);
31387 if (PyErr_Occurred()) SWIG_fail;
31388 }
31389 resultobj = SWIG_From_int(static_cast< int >(result));
31390 return resultobj;
31391 fail:
31392 return NULL;
31393 }
31394
31395
31396 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31397 PyObject *resultobj = 0;
31398 bool result;
31399
31400 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31401 {
31402 PyThreadState* __tstate = wxPyBeginAllowThreads();
31403 result = (bool)wxPyApp_IsDisplayAvailable();
31404 wxPyEndAllowThreads(__tstate);
31405 if (PyErr_Occurred()) SWIG_fail;
31406 }
31407 {
31408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31409 }
31410 return resultobj;
31411 fail:
31412 return NULL;
31413 }
31414
31415
31416 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31417 PyObject *obj;
31418 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31419 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31420 return SWIG_Py_Void();
31421 }
31422
31423 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31424 return SWIG_Python_InitShadowInstance(args);
31425 }
31426
31427 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31428 PyObject *resultobj = 0;
31429
31430 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31431 {
31432 PyThreadState* __tstate = wxPyBeginAllowThreads();
31433 wxExit();
31434 wxPyEndAllowThreads(__tstate);
31435 if (PyErr_Occurred()) SWIG_fail;
31436 }
31437 resultobj = SWIG_Py_Void();
31438 return resultobj;
31439 fail:
31440 return NULL;
31441 }
31442
31443
31444 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31445 PyObject *resultobj = 0;
31446 bool result;
31447
31448 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31449 {
31450 PyThreadState* __tstate = wxPyBeginAllowThreads();
31451 result = (bool)wxYield();
31452 wxPyEndAllowThreads(__tstate);
31453 if (PyErr_Occurred()) SWIG_fail;
31454 }
31455 {
31456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31457 }
31458 return resultobj;
31459 fail:
31460 return NULL;
31461 }
31462
31463
31464 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31465 PyObject *resultobj = 0;
31466 bool result;
31467
31468 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31469 {
31470 PyThreadState* __tstate = wxPyBeginAllowThreads();
31471 result = (bool)wxYieldIfNeeded();
31472 wxPyEndAllowThreads(__tstate);
31473 if (PyErr_Occurred()) SWIG_fail;
31474 }
31475 {
31476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31477 }
31478 return resultobj;
31479 fail:
31480 return NULL;
31481 }
31482
31483
31484 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31485 PyObject *resultobj = 0;
31486 wxWindow *arg1 = (wxWindow *) NULL ;
31487 bool arg2 = (bool) false ;
31488 bool result;
31489 void *argp1 = 0 ;
31490 int res1 = 0 ;
31491 bool val2 ;
31492 int ecode2 = 0 ;
31493 PyObject * obj0 = 0 ;
31494 PyObject * obj1 = 0 ;
31495 char * kwnames[] = {
31496 (char *) "win",(char *) "onlyIfNeeded", NULL
31497 };
31498
31499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31500 if (obj0) {
31501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31502 if (!SWIG_IsOK(res1)) {
31503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31504 }
31505 arg1 = reinterpret_cast< wxWindow * >(argp1);
31506 }
31507 if (obj1) {
31508 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31509 if (!SWIG_IsOK(ecode2)) {
31510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31511 }
31512 arg2 = static_cast< bool >(val2);
31513 }
31514 {
31515 PyThreadState* __tstate = wxPyBeginAllowThreads();
31516 result = (bool)wxSafeYield(arg1,arg2);
31517 wxPyEndAllowThreads(__tstate);
31518 if (PyErr_Occurred()) SWIG_fail;
31519 }
31520 {
31521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31522 }
31523 return resultobj;
31524 fail:
31525 return NULL;
31526 }
31527
31528
31529 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31530 PyObject *resultobj = 0;
31531
31532 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31533 {
31534 PyThreadState* __tstate = wxPyBeginAllowThreads();
31535 wxWakeUpIdle();
31536 wxPyEndAllowThreads(__tstate);
31537 if (PyErr_Occurred()) SWIG_fail;
31538 }
31539 resultobj = SWIG_Py_Void();
31540 return resultobj;
31541 fail:
31542 return NULL;
31543 }
31544
31545
31546 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31547 PyObject *resultobj = 0;
31548 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31549 wxEvent *arg2 = 0 ;
31550 void *argp1 = 0 ;
31551 int res1 = 0 ;
31552 void *argp2 = 0 ;
31553 int res2 = 0 ;
31554 PyObject * obj0 = 0 ;
31555 PyObject * obj1 = 0 ;
31556 char * kwnames[] = {
31557 (char *) "dest",(char *) "event", NULL
31558 };
31559
31560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31562 if (!SWIG_IsOK(res1)) {
31563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31564 }
31565 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31566 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31567 if (!SWIG_IsOK(res2)) {
31568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31569 }
31570 if (!argp2) {
31571 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31572 }
31573 arg2 = reinterpret_cast< wxEvent * >(argp2);
31574 {
31575 PyThreadState* __tstate = wxPyBeginAllowThreads();
31576 wxPostEvent(arg1,*arg2);
31577 wxPyEndAllowThreads(__tstate);
31578 if (PyErr_Occurred()) SWIG_fail;
31579 }
31580 resultobj = SWIG_Py_Void();
31581 return resultobj;
31582 fail:
31583 return NULL;
31584 }
31585
31586
31587 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31588 PyObject *resultobj = 0;
31589
31590 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31591 {
31592 PyThreadState* __tstate = wxPyBeginAllowThreads();
31593 wxApp_CleanUp();
31594 wxPyEndAllowThreads(__tstate);
31595 if (PyErr_Occurred()) SWIG_fail;
31596 }
31597 resultobj = SWIG_Py_Void();
31598 return resultobj;
31599 fail:
31600 return NULL;
31601 }
31602
31603
31604 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31605 PyObject *resultobj = 0;
31606 wxPyApp *result = 0 ;
31607
31608 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31609 {
31610 PyThreadState* __tstate = wxPyBeginAllowThreads();
31611 result = (wxPyApp *)wxPyGetApp();
31612 wxPyEndAllowThreads(__tstate);
31613 if (PyErr_Occurred()) SWIG_fail;
31614 }
31615 {
31616 resultobj = wxPyMake_wxObject(result, 0);
31617 }
31618 return resultobj;
31619 fail:
31620 return NULL;
31621 }
31622
31623
31624 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31625 PyObject *resultobj = 0;
31626 char *arg1 = (char *) 0 ;
31627 int res1 ;
31628 char *buf1 = 0 ;
31629 int alloc1 = 0 ;
31630 PyObject * obj0 = 0 ;
31631 char * kwnames[] = {
31632 (char *) "encoding", NULL
31633 };
31634
31635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31636 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31637 if (!SWIG_IsOK(res1)) {
31638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31639 }
31640 arg1 = buf1;
31641 {
31642 PyThreadState* __tstate = wxPyBeginAllowThreads();
31643 wxSetDefaultPyEncoding((char const *)arg1);
31644 wxPyEndAllowThreads(__tstate);
31645 if (PyErr_Occurred()) SWIG_fail;
31646 }
31647 resultobj = SWIG_Py_Void();
31648 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31649 return resultobj;
31650 fail:
31651 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31652 return NULL;
31653 }
31654
31655
31656 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31657 PyObject *resultobj = 0;
31658 char *result = 0 ;
31659
31660 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31661 {
31662 PyThreadState* __tstate = wxPyBeginAllowThreads();
31663 result = (char *)wxGetDefaultPyEncoding();
31664 wxPyEndAllowThreads(__tstate);
31665 if (PyErr_Occurred()) SWIG_fail;
31666 }
31667 resultobj = SWIG_FromCharPtr(result);
31668 return resultobj;
31669 fail:
31670 return NULL;
31671 }
31672
31673
31674 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31675 PyObject *resultobj = 0;
31676 wxEventLoop *result = 0 ;
31677
31678 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31679 {
31680 PyThreadState* __tstate = wxPyBeginAllowThreads();
31681 result = (wxEventLoop *)new wxEventLoop();
31682 wxPyEndAllowThreads(__tstate);
31683 if (PyErr_Occurred()) SWIG_fail;
31684 }
31685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31686 return resultobj;
31687 fail:
31688 return NULL;
31689 }
31690
31691
31692 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31693 PyObject *resultobj = 0;
31694 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31695 void *argp1 = 0 ;
31696 int res1 = 0 ;
31697 PyObject *swig_obj[1] ;
31698
31699 if (!args) SWIG_fail;
31700 swig_obj[0] = args;
31701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31702 if (!SWIG_IsOK(res1)) {
31703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31704 }
31705 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31706 {
31707 PyThreadState* __tstate = wxPyBeginAllowThreads();
31708 delete arg1;
31709
31710 wxPyEndAllowThreads(__tstate);
31711 if (PyErr_Occurred()) SWIG_fail;
31712 }
31713 resultobj = SWIG_Py_Void();
31714 return resultobj;
31715 fail:
31716 return NULL;
31717 }
31718
31719
31720 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31721 PyObject *resultobj = 0;
31722 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31723 int result;
31724 void *argp1 = 0 ;
31725 int res1 = 0 ;
31726 PyObject *swig_obj[1] ;
31727
31728 if (!args) SWIG_fail;
31729 swig_obj[0] = args;
31730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31731 if (!SWIG_IsOK(res1)) {
31732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31733 }
31734 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31735 {
31736 PyThreadState* __tstate = wxPyBeginAllowThreads();
31737 result = (int)(arg1)->Run();
31738 wxPyEndAllowThreads(__tstate);
31739 if (PyErr_Occurred()) SWIG_fail;
31740 }
31741 resultobj = SWIG_From_int(static_cast< int >(result));
31742 return resultobj;
31743 fail:
31744 return NULL;
31745 }
31746
31747
31748 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31749 PyObject *resultobj = 0;
31750 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31751 int arg2 = (int) 0 ;
31752 void *argp1 = 0 ;
31753 int res1 = 0 ;
31754 int val2 ;
31755 int ecode2 = 0 ;
31756 PyObject * obj0 = 0 ;
31757 PyObject * obj1 = 0 ;
31758 char * kwnames[] = {
31759 (char *) "self",(char *) "rc", NULL
31760 };
31761
31762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31764 if (!SWIG_IsOK(res1)) {
31765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31766 }
31767 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31768 if (obj1) {
31769 ecode2 = SWIG_AsVal_int(obj1, &val2);
31770 if (!SWIG_IsOK(ecode2)) {
31771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31772 }
31773 arg2 = static_cast< int >(val2);
31774 }
31775 {
31776 PyThreadState* __tstate = wxPyBeginAllowThreads();
31777 (arg1)->Exit(arg2);
31778 wxPyEndAllowThreads(__tstate);
31779 if (PyErr_Occurred()) SWIG_fail;
31780 }
31781 resultobj = SWIG_Py_Void();
31782 return resultobj;
31783 fail:
31784 return NULL;
31785 }
31786
31787
31788 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31789 PyObject *resultobj = 0;
31790 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31791 bool result;
31792 void *argp1 = 0 ;
31793 int res1 = 0 ;
31794 PyObject *swig_obj[1] ;
31795
31796 if (!args) SWIG_fail;
31797 swig_obj[0] = args;
31798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31799 if (!SWIG_IsOK(res1)) {
31800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31801 }
31802 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31803 {
31804 PyThreadState* __tstate = wxPyBeginAllowThreads();
31805 result = (bool)((wxEventLoop const *)arg1)->Pending();
31806 wxPyEndAllowThreads(__tstate);
31807 if (PyErr_Occurred()) SWIG_fail;
31808 }
31809 {
31810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31811 }
31812 return resultobj;
31813 fail:
31814 return NULL;
31815 }
31816
31817
31818 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31819 PyObject *resultobj = 0;
31820 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31821 bool result;
31822 void *argp1 = 0 ;
31823 int res1 = 0 ;
31824 PyObject *swig_obj[1] ;
31825
31826 if (!args) SWIG_fail;
31827 swig_obj[0] = args;
31828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31829 if (!SWIG_IsOK(res1)) {
31830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31831 }
31832 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31833 {
31834 PyThreadState* __tstate = wxPyBeginAllowThreads();
31835 result = (bool)(arg1)->Dispatch();
31836 wxPyEndAllowThreads(__tstate);
31837 if (PyErr_Occurred()) SWIG_fail;
31838 }
31839 {
31840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31841 }
31842 return resultobj;
31843 fail:
31844 return NULL;
31845 }
31846
31847
31848 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31849 PyObject *resultobj = 0;
31850 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31851 bool result;
31852 void *argp1 = 0 ;
31853 int res1 = 0 ;
31854 PyObject *swig_obj[1] ;
31855
31856 if (!args) SWIG_fail;
31857 swig_obj[0] = args;
31858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31859 if (!SWIG_IsOK(res1)) {
31860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31861 }
31862 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31863 {
31864 PyThreadState* __tstate = wxPyBeginAllowThreads();
31865 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31866 wxPyEndAllowThreads(__tstate);
31867 if (PyErr_Occurred()) SWIG_fail;
31868 }
31869 {
31870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31871 }
31872 return resultobj;
31873 fail:
31874 return NULL;
31875 }
31876
31877
31878 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31879 PyObject *resultobj = 0;
31880 wxEventLoop *result = 0 ;
31881
31882 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31883 {
31884 PyThreadState* __tstate = wxPyBeginAllowThreads();
31885 result = (wxEventLoop *)wxEventLoop::GetActive();
31886 wxPyEndAllowThreads(__tstate);
31887 if (PyErr_Occurred()) SWIG_fail;
31888 }
31889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
31890 return resultobj;
31891 fail:
31892 return NULL;
31893 }
31894
31895
31896 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31897 PyObject *resultobj = 0;
31898 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31899 void *argp1 = 0 ;
31900 int res1 = 0 ;
31901 PyObject * obj0 = 0 ;
31902 char * kwnames[] = {
31903 (char *) "loop", NULL
31904 };
31905
31906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
31907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31908 if (!SWIG_IsOK(res1)) {
31909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31910 }
31911 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31912 {
31913 PyThreadState* __tstate = wxPyBeginAllowThreads();
31914 wxEventLoop::SetActive(arg1);
31915 wxPyEndAllowThreads(__tstate);
31916 if (PyErr_Occurred()) SWIG_fail;
31917 }
31918 resultobj = SWIG_Py_Void();
31919 return resultobj;
31920 fail:
31921 return NULL;
31922 }
31923
31924
31925 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31926 PyObject *obj;
31927 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31928 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
31929 return SWIG_Py_Void();
31930 }
31931
31932 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31933 return SWIG_Python_InitShadowInstance(args);
31934 }
31935
31936 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31937 PyObject *resultobj = 0;
31938 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31939 wxEventLoopActivator *result = 0 ;
31940 void *argp1 = 0 ;
31941 int res1 = 0 ;
31942 PyObject * obj0 = 0 ;
31943 char * kwnames[] = {
31944 (char *) "evtLoop", NULL
31945 };
31946
31947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
31948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31949 if (!SWIG_IsOK(res1)) {
31950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31951 }
31952 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31953 {
31954 PyThreadState* __tstate = wxPyBeginAllowThreads();
31955 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
31956 wxPyEndAllowThreads(__tstate);
31957 if (PyErr_Occurred()) SWIG_fail;
31958 }
31959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
31960 return resultobj;
31961 fail:
31962 return NULL;
31963 }
31964
31965
31966 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31967 PyObject *resultobj = 0;
31968 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
31969 void *argp1 = 0 ;
31970 int res1 = 0 ;
31971 PyObject *swig_obj[1] ;
31972
31973 if (!args) SWIG_fail;
31974 swig_obj[0] = args;
31975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
31976 if (!SWIG_IsOK(res1)) {
31977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
31978 }
31979 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
31980 {
31981 PyThreadState* __tstate = wxPyBeginAllowThreads();
31982 delete arg1;
31983
31984 wxPyEndAllowThreads(__tstate);
31985 if (PyErr_Occurred()) SWIG_fail;
31986 }
31987 resultobj = SWIG_Py_Void();
31988 return resultobj;
31989 fail:
31990 return NULL;
31991 }
31992
31993
31994 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31995 PyObject *obj;
31996 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31997 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
31998 return SWIG_Py_Void();
31999 }
32000
32001 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32002 return SWIG_Python_InitShadowInstance(args);
32003 }
32004
32005 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32006 PyObject *resultobj = 0;
32007 int arg1 = (int) 0 ;
32008 int arg2 = (int) 0 ;
32009 int arg3 = (int) 0 ;
32010 wxAcceleratorEntry *result = 0 ;
32011 int val1 ;
32012 int ecode1 = 0 ;
32013 int val2 ;
32014 int ecode2 = 0 ;
32015 int val3 ;
32016 int ecode3 = 0 ;
32017 PyObject * obj0 = 0 ;
32018 PyObject * obj1 = 0 ;
32019 PyObject * obj2 = 0 ;
32020 char * kwnames[] = {
32021 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
32022 };
32023
32024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32025 if (obj0) {
32026 ecode1 = SWIG_AsVal_int(obj0, &val1);
32027 if (!SWIG_IsOK(ecode1)) {
32028 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
32029 }
32030 arg1 = static_cast< int >(val1);
32031 }
32032 if (obj1) {
32033 ecode2 = SWIG_AsVal_int(obj1, &val2);
32034 if (!SWIG_IsOK(ecode2)) {
32035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
32036 }
32037 arg2 = static_cast< int >(val2);
32038 }
32039 if (obj2) {
32040 ecode3 = SWIG_AsVal_int(obj2, &val3);
32041 if (!SWIG_IsOK(ecode3)) {
32042 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
32043 }
32044 arg3 = static_cast< int >(val3);
32045 }
32046 {
32047 PyThreadState* __tstate = wxPyBeginAllowThreads();
32048 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
32049 wxPyEndAllowThreads(__tstate);
32050 if (PyErr_Occurred()) SWIG_fail;
32051 }
32052 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
32053 return resultobj;
32054 fail:
32055 return NULL;
32056 }
32057
32058
32059 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32060 PyObject *resultobj = 0;
32061 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32062 void *argp1 = 0 ;
32063 int res1 = 0 ;
32064 PyObject *swig_obj[1] ;
32065
32066 if (!args) SWIG_fail;
32067 swig_obj[0] = args;
32068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
32069 if (!SWIG_IsOK(res1)) {
32070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32071 }
32072 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32073 {
32074 PyThreadState* __tstate = wxPyBeginAllowThreads();
32075 delete arg1;
32076
32077 wxPyEndAllowThreads(__tstate);
32078 if (PyErr_Occurred()) SWIG_fail;
32079 }
32080 resultobj = SWIG_Py_Void();
32081 return resultobj;
32082 fail:
32083 return NULL;
32084 }
32085
32086
32087 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32088 PyObject *resultobj = 0;
32089 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32090 int arg2 ;
32091 int arg3 ;
32092 int arg4 ;
32093 void *argp1 = 0 ;
32094 int res1 = 0 ;
32095 int val2 ;
32096 int ecode2 = 0 ;
32097 int val3 ;
32098 int ecode3 = 0 ;
32099 int val4 ;
32100 int ecode4 = 0 ;
32101 PyObject * obj0 = 0 ;
32102 PyObject * obj1 = 0 ;
32103 PyObject * obj2 = 0 ;
32104 PyObject * obj3 = 0 ;
32105 char * kwnames[] = {
32106 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32107 };
32108
32109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32111 if (!SWIG_IsOK(res1)) {
32112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32113 }
32114 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32115 ecode2 = SWIG_AsVal_int(obj1, &val2);
32116 if (!SWIG_IsOK(ecode2)) {
32117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32118 }
32119 arg2 = static_cast< int >(val2);
32120 ecode3 = SWIG_AsVal_int(obj2, &val3);
32121 if (!SWIG_IsOK(ecode3)) {
32122 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32123 }
32124 arg3 = static_cast< int >(val3);
32125 ecode4 = SWIG_AsVal_int(obj3, &val4);
32126 if (!SWIG_IsOK(ecode4)) {
32127 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32128 }
32129 arg4 = static_cast< int >(val4);
32130 {
32131 PyThreadState* __tstate = wxPyBeginAllowThreads();
32132 (arg1)->Set(arg2,arg3,arg4);
32133 wxPyEndAllowThreads(__tstate);
32134 if (PyErr_Occurred()) SWIG_fail;
32135 }
32136 resultobj = SWIG_Py_Void();
32137 return resultobj;
32138 fail:
32139 return NULL;
32140 }
32141
32142
32143 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32144 PyObject *resultobj = 0;
32145 wxString *arg1 = 0 ;
32146 wxAcceleratorEntry *result = 0 ;
32147 bool temp1 = false ;
32148 PyObject * obj0 = 0 ;
32149 char * kwnames[] = {
32150 (char *) "str", NULL
32151 };
32152
32153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32154 {
32155 arg1 = wxString_in_helper(obj0);
32156 if (arg1 == NULL) SWIG_fail;
32157 temp1 = true;
32158 }
32159 {
32160 PyThreadState* __tstate = wxPyBeginAllowThreads();
32161 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32162 wxPyEndAllowThreads(__tstate);
32163 if (PyErr_Occurred()) SWIG_fail;
32164 }
32165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32166 {
32167 if (temp1)
32168 delete arg1;
32169 }
32170 return resultobj;
32171 fail:
32172 {
32173 if (temp1)
32174 delete arg1;
32175 }
32176 return NULL;
32177 }
32178
32179
32180 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32181 PyObject *resultobj = 0;
32182 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32183 int result;
32184 void *argp1 = 0 ;
32185 int res1 = 0 ;
32186 PyObject *swig_obj[1] ;
32187
32188 if (!args) SWIG_fail;
32189 swig_obj[0] = args;
32190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32191 if (!SWIG_IsOK(res1)) {
32192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32193 }
32194 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32195 {
32196 PyThreadState* __tstate = wxPyBeginAllowThreads();
32197 result = (int)(arg1)->GetFlags();
32198 wxPyEndAllowThreads(__tstate);
32199 if (PyErr_Occurred()) SWIG_fail;
32200 }
32201 resultobj = SWIG_From_int(static_cast< int >(result));
32202 return resultobj;
32203 fail:
32204 return NULL;
32205 }
32206
32207
32208 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32209 PyObject *resultobj = 0;
32210 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32211 int result;
32212 void *argp1 = 0 ;
32213 int res1 = 0 ;
32214 PyObject *swig_obj[1] ;
32215
32216 if (!args) SWIG_fail;
32217 swig_obj[0] = args;
32218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32219 if (!SWIG_IsOK(res1)) {
32220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32221 }
32222 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32223 {
32224 PyThreadState* __tstate = wxPyBeginAllowThreads();
32225 result = (int)(arg1)->GetKeyCode();
32226 wxPyEndAllowThreads(__tstate);
32227 if (PyErr_Occurred()) SWIG_fail;
32228 }
32229 resultobj = SWIG_From_int(static_cast< int >(result));
32230 return resultobj;
32231 fail:
32232 return NULL;
32233 }
32234
32235
32236 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32237 PyObject *resultobj = 0;
32238 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32239 int result;
32240 void *argp1 = 0 ;
32241 int res1 = 0 ;
32242 PyObject *swig_obj[1] ;
32243
32244 if (!args) SWIG_fail;
32245 swig_obj[0] = args;
32246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32247 if (!SWIG_IsOK(res1)) {
32248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32249 }
32250 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32251 {
32252 PyThreadState* __tstate = wxPyBeginAllowThreads();
32253 result = (int)(arg1)->GetCommand();
32254 wxPyEndAllowThreads(__tstate);
32255 if (PyErr_Occurred()) SWIG_fail;
32256 }
32257 resultobj = SWIG_From_int(static_cast< int >(result));
32258 return resultobj;
32259 fail:
32260 return NULL;
32261 }
32262
32263
32264 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32265 PyObject *resultobj = 0;
32266 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32267 bool result;
32268 void *argp1 = 0 ;
32269 int res1 = 0 ;
32270 PyObject *swig_obj[1] ;
32271
32272 if (!args) SWIG_fail;
32273 swig_obj[0] = args;
32274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32275 if (!SWIG_IsOK(res1)) {
32276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32277 }
32278 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32279 {
32280 PyThreadState* __tstate = wxPyBeginAllowThreads();
32281 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32282 wxPyEndAllowThreads(__tstate);
32283 if (PyErr_Occurred()) SWIG_fail;
32284 }
32285 {
32286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32287 }
32288 return resultobj;
32289 fail:
32290 return NULL;
32291 }
32292
32293
32294 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32295 PyObject *resultobj = 0;
32296 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32297 wxString result;
32298 void *argp1 = 0 ;
32299 int res1 = 0 ;
32300 PyObject *swig_obj[1] ;
32301
32302 if (!args) SWIG_fail;
32303 swig_obj[0] = args;
32304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32305 if (!SWIG_IsOK(res1)) {
32306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32307 }
32308 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32309 {
32310 PyThreadState* __tstate = wxPyBeginAllowThreads();
32311 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32312 wxPyEndAllowThreads(__tstate);
32313 if (PyErr_Occurred()) SWIG_fail;
32314 }
32315 {
32316 #if wxUSE_UNICODE
32317 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32318 #else
32319 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32320 #endif
32321 }
32322 return resultobj;
32323 fail:
32324 return NULL;
32325 }
32326
32327
32328 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32329 PyObject *resultobj = 0;
32330 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32331 wxString *arg2 = 0 ;
32332 bool result;
32333 void *argp1 = 0 ;
32334 int res1 = 0 ;
32335 bool temp2 = false ;
32336 PyObject * obj0 = 0 ;
32337 PyObject * obj1 = 0 ;
32338 char * kwnames[] = {
32339 (char *) "self",(char *) "str", NULL
32340 };
32341
32342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32344 if (!SWIG_IsOK(res1)) {
32345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32346 }
32347 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32348 {
32349 arg2 = wxString_in_helper(obj1);
32350 if (arg2 == NULL) SWIG_fail;
32351 temp2 = true;
32352 }
32353 {
32354 PyThreadState* __tstate = wxPyBeginAllowThreads();
32355 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32356 wxPyEndAllowThreads(__tstate);
32357 if (PyErr_Occurred()) SWIG_fail;
32358 }
32359 {
32360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32361 }
32362 {
32363 if (temp2)
32364 delete arg2;
32365 }
32366 return resultobj;
32367 fail:
32368 {
32369 if (temp2)
32370 delete arg2;
32371 }
32372 return NULL;
32373 }
32374
32375
32376 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32377 PyObject *obj;
32378 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32379 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32380 return SWIG_Py_Void();
32381 }
32382
32383 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32384 return SWIG_Python_InitShadowInstance(args);
32385 }
32386
32387 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32388 PyObject *resultobj = 0;
32389 int arg1 ;
32390 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32391 wxAcceleratorTable *result = 0 ;
32392 PyObject * obj0 = 0 ;
32393 char * kwnames[] = {
32394 (char *) "n", NULL
32395 };
32396
32397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32398 {
32399 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32400 if (arg2) arg1 = PyList_Size(obj0);
32401 else arg1 = 0;
32402 }
32403 {
32404 PyThreadState* __tstate = wxPyBeginAllowThreads();
32405 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32406 wxPyEndAllowThreads(__tstate);
32407 if (PyErr_Occurred()) SWIG_fail;
32408 }
32409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32410 return resultobj;
32411 fail:
32412 return NULL;
32413 }
32414
32415
32416 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32417 PyObject *resultobj = 0;
32418 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32419 void *argp1 = 0 ;
32420 int res1 = 0 ;
32421 PyObject *swig_obj[1] ;
32422
32423 if (!args) SWIG_fail;
32424 swig_obj[0] = args;
32425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32426 if (!SWIG_IsOK(res1)) {
32427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32428 }
32429 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32430 {
32431 PyThreadState* __tstate = wxPyBeginAllowThreads();
32432 delete arg1;
32433
32434 wxPyEndAllowThreads(__tstate);
32435 if (PyErr_Occurred()) SWIG_fail;
32436 }
32437 resultobj = SWIG_Py_Void();
32438 return resultobj;
32439 fail:
32440 return NULL;
32441 }
32442
32443
32444 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32445 PyObject *resultobj = 0;
32446 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32447 bool result;
32448 void *argp1 = 0 ;
32449 int res1 = 0 ;
32450 PyObject *swig_obj[1] ;
32451
32452 if (!args) SWIG_fail;
32453 swig_obj[0] = args;
32454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32455 if (!SWIG_IsOK(res1)) {
32456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32457 }
32458 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32459 {
32460 PyThreadState* __tstate = wxPyBeginAllowThreads();
32461 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32462 wxPyEndAllowThreads(__tstate);
32463 if (PyErr_Occurred()) SWIG_fail;
32464 }
32465 {
32466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32467 }
32468 return resultobj;
32469 fail:
32470 return NULL;
32471 }
32472
32473
32474 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32475 PyObject *obj;
32476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32477 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32478 return SWIG_Py_Void();
32479 }
32480
32481 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32482 return SWIG_Python_InitShadowInstance(args);
32483 }
32484
32485 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32486 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32487 return 1;
32488 }
32489
32490
32491 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32492 PyObject *pyobj = 0;
32493
32494 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32495 return pyobj;
32496 }
32497
32498
32499 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32500 PyObject *resultobj = 0;
32501 wxString *arg1 = 0 ;
32502 wxAcceleratorEntry *result = 0 ;
32503 bool temp1 = false ;
32504 PyObject * obj0 = 0 ;
32505 char * kwnames[] = {
32506 (char *) "label", NULL
32507 };
32508
32509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
32510 {
32511 arg1 = wxString_in_helper(obj0);
32512 if (arg1 == NULL) SWIG_fail;
32513 temp1 = true;
32514 }
32515 {
32516 PyThreadState* __tstate = wxPyBeginAllowThreads();
32517 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
32518 wxPyEndAllowThreads(__tstate);
32519 if (PyErr_Occurred()) SWIG_fail;
32520 }
32521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32522 {
32523 if (temp1)
32524 delete arg1;
32525 }
32526 return resultobj;
32527 fail:
32528 {
32529 if (temp1)
32530 delete arg1;
32531 }
32532 return NULL;
32533 }
32534
32535
32536 SWIGINTERN int PanelNameStr_set(PyObject *) {
32537 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32538 return 1;
32539 }
32540
32541
32542 SWIGINTERN PyObject *PanelNameStr_get(void) {
32543 PyObject *pyobj = 0;
32544
32545 {
32546 #if wxUSE_UNICODE
32547 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32548 #else
32549 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32550 #endif
32551 }
32552 return pyobj;
32553 }
32554
32555
32556 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32557 PyObject *resultobj = 0;
32558 wxVisualAttributes *result = 0 ;
32559
32560 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32561 {
32562 PyThreadState* __tstate = wxPyBeginAllowThreads();
32563 result = (wxVisualAttributes *)new_wxVisualAttributes();
32564 wxPyEndAllowThreads(__tstate);
32565 if (PyErr_Occurred()) SWIG_fail;
32566 }
32567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32568 return resultobj;
32569 fail:
32570 return NULL;
32571 }
32572
32573
32574 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32575 PyObject *resultobj = 0;
32576 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32577 void *argp1 = 0 ;
32578 int res1 = 0 ;
32579 PyObject *swig_obj[1] ;
32580
32581 if (!args) SWIG_fail;
32582 swig_obj[0] = args;
32583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32584 if (!SWIG_IsOK(res1)) {
32585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32586 }
32587 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32588 {
32589 PyThreadState* __tstate = wxPyBeginAllowThreads();
32590 delete_wxVisualAttributes(arg1);
32591
32592 wxPyEndAllowThreads(__tstate);
32593 if (PyErr_Occurred()) SWIG_fail;
32594 }
32595 resultobj = SWIG_Py_Void();
32596 return resultobj;
32597 fail:
32598 return NULL;
32599 }
32600
32601
32602 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32603 PyObject *resultobj = 0;
32604 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32605 wxFont *arg2 = (wxFont *) 0 ;
32606 void *argp1 = 0 ;
32607 int res1 = 0 ;
32608 void *argp2 = 0 ;
32609 int res2 = 0 ;
32610 PyObject *swig_obj[2] ;
32611
32612 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32614 if (!SWIG_IsOK(res1)) {
32615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32616 }
32617 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32618 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32619 if (!SWIG_IsOK(res2)) {
32620 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32621 }
32622 arg2 = reinterpret_cast< wxFont * >(argp2);
32623 if (arg1) (arg1)->font = *arg2;
32624
32625 resultobj = SWIG_Py_Void();
32626 return resultobj;
32627 fail:
32628 return NULL;
32629 }
32630
32631
32632 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32633 PyObject *resultobj = 0;
32634 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32635 wxFont *result = 0 ;
32636 void *argp1 = 0 ;
32637 int res1 = 0 ;
32638 PyObject *swig_obj[1] ;
32639
32640 if (!args) SWIG_fail;
32641 swig_obj[0] = args;
32642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32643 if (!SWIG_IsOK(res1)) {
32644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32645 }
32646 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32647 result = (wxFont *)& ((arg1)->font);
32648 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32649 return resultobj;
32650 fail:
32651 return NULL;
32652 }
32653
32654
32655 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32656 PyObject *resultobj = 0;
32657 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32658 wxColour *arg2 = (wxColour *) 0 ;
32659 void *argp1 = 0 ;
32660 int res1 = 0 ;
32661 void *argp2 = 0 ;
32662 int res2 = 0 ;
32663 PyObject *swig_obj[2] ;
32664
32665 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32667 if (!SWIG_IsOK(res1)) {
32668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32669 }
32670 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32671 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32672 if (!SWIG_IsOK(res2)) {
32673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32674 }
32675 arg2 = reinterpret_cast< wxColour * >(argp2);
32676 if (arg1) (arg1)->colFg = *arg2;
32677
32678 resultobj = SWIG_Py_Void();
32679 return resultobj;
32680 fail:
32681 return NULL;
32682 }
32683
32684
32685 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32686 PyObject *resultobj = 0;
32687 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32688 wxColour *result = 0 ;
32689 void *argp1 = 0 ;
32690 int res1 = 0 ;
32691 PyObject *swig_obj[1] ;
32692
32693 if (!args) SWIG_fail;
32694 swig_obj[0] = args;
32695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32696 if (!SWIG_IsOK(res1)) {
32697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32698 }
32699 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32700 result = (wxColour *)& ((arg1)->colFg);
32701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32702 return resultobj;
32703 fail:
32704 return NULL;
32705 }
32706
32707
32708 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32709 PyObject *resultobj = 0;
32710 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32711 wxColour *arg2 = (wxColour *) 0 ;
32712 void *argp1 = 0 ;
32713 int res1 = 0 ;
32714 void *argp2 = 0 ;
32715 int res2 = 0 ;
32716 PyObject *swig_obj[2] ;
32717
32718 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32720 if (!SWIG_IsOK(res1)) {
32721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32722 }
32723 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32724 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32725 if (!SWIG_IsOK(res2)) {
32726 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32727 }
32728 arg2 = reinterpret_cast< wxColour * >(argp2);
32729 if (arg1) (arg1)->colBg = *arg2;
32730
32731 resultobj = SWIG_Py_Void();
32732 return resultobj;
32733 fail:
32734 return NULL;
32735 }
32736
32737
32738 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32739 PyObject *resultobj = 0;
32740 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32741 wxColour *result = 0 ;
32742 void *argp1 = 0 ;
32743 int res1 = 0 ;
32744 PyObject *swig_obj[1] ;
32745
32746 if (!args) SWIG_fail;
32747 swig_obj[0] = args;
32748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32749 if (!SWIG_IsOK(res1)) {
32750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32751 }
32752 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32753 result = (wxColour *)& ((arg1)->colBg);
32754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32755 return resultobj;
32756 fail:
32757 return NULL;
32758 }
32759
32760
32761 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32762 PyObject *obj;
32763 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32764 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32765 return SWIG_Py_Void();
32766 }
32767
32768 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32769 return SWIG_Python_InitShadowInstance(args);
32770 }
32771
32772 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32773 PyObject *resultobj = 0;
32774 wxWindow *arg1 = (wxWindow *) 0 ;
32775 int arg2 = (int) (int)-1 ;
32776 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32777 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32778 wxSize const &arg4_defvalue = wxDefaultSize ;
32779 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32780 long arg5 = (long) 0 ;
32781 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32782 wxString *arg6 = (wxString *) &arg6_defvalue ;
32783 wxWindow *result = 0 ;
32784 void *argp1 = 0 ;
32785 int res1 = 0 ;
32786 int val2 ;
32787 int ecode2 = 0 ;
32788 wxPoint temp3 ;
32789 wxSize temp4 ;
32790 long val5 ;
32791 int ecode5 = 0 ;
32792 bool temp6 = false ;
32793 PyObject * obj0 = 0 ;
32794 PyObject * obj1 = 0 ;
32795 PyObject * obj2 = 0 ;
32796 PyObject * obj3 = 0 ;
32797 PyObject * obj4 = 0 ;
32798 PyObject * obj5 = 0 ;
32799 char * kwnames[] = {
32800 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32801 };
32802
32803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32805 if (!SWIG_IsOK(res1)) {
32806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32807 }
32808 arg1 = reinterpret_cast< wxWindow * >(argp1);
32809 if (obj1) {
32810 ecode2 = SWIG_AsVal_int(obj1, &val2);
32811 if (!SWIG_IsOK(ecode2)) {
32812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32813 }
32814 arg2 = static_cast< int >(val2);
32815 }
32816 if (obj2) {
32817 {
32818 arg3 = &temp3;
32819 if ( ! wxPoint_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 if (obj4) {
32829 ecode5 = SWIG_AsVal_long(obj4, &val5);
32830 if (!SWIG_IsOK(ecode5)) {
32831 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32832 }
32833 arg5 = static_cast< long >(val5);
32834 }
32835 if (obj5) {
32836 {
32837 arg6 = wxString_in_helper(obj5);
32838 if (arg6 == NULL) SWIG_fail;
32839 temp6 = true;
32840 }
32841 }
32842 {
32843 if (!wxPyCheckForApp()) SWIG_fail;
32844 PyThreadState* __tstate = wxPyBeginAllowThreads();
32845 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32846 wxPyEndAllowThreads(__tstate);
32847 if (PyErr_Occurred()) SWIG_fail;
32848 }
32849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32850 {
32851 if (temp6)
32852 delete arg6;
32853 }
32854 return resultobj;
32855 fail:
32856 {
32857 if (temp6)
32858 delete arg6;
32859 }
32860 return NULL;
32861 }
32862
32863
32864 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32865 PyObject *resultobj = 0;
32866 wxWindow *result = 0 ;
32867
32868 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32869 {
32870 if (!wxPyCheckForApp()) SWIG_fail;
32871 PyThreadState* __tstate = wxPyBeginAllowThreads();
32872 result = (wxWindow *)new wxWindow();
32873 wxPyEndAllowThreads(__tstate);
32874 if (PyErr_Occurred()) SWIG_fail;
32875 }
32876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32877 return resultobj;
32878 fail:
32879 return NULL;
32880 }
32881
32882
32883 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32884 PyObject *resultobj = 0;
32885 wxWindow *arg1 = (wxWindow *) 0 ;
32886 wxWindow *arg2 = (wxWindow *) 0 ;
32887 int arg3 = (int) (int)-1 ;
32888 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32889 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32890 wxSize const &arg5_defvalue = wxDefaultSize ;
32891 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32892 long arg6 = (long) 0 ;
32893 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32894 wxString *arg7 = (wxString *) &arg7_defvalue ;
32895 bool result;
32896 void *argp1 = 0 ;
32897 int res1 = 0 ;
32898 void *argp2 = 0 ;
32899 int res2 = 0 ;
32900 int val3 ;
32901 int ecode3 = 0 ;
32902 wxPoint temp4 ;
32903 wxSize temp5 ;
32904 long val6 ;
32905 int ecode6 = 0 ;
32906 bool temp7 = false ;
32907 PyObject * obj0 = 0 ;
32908 PyObject * obj1 = 0 ;
32909 PyObject * obj2 = 0 ;
32910 PyObject * obj3 = 0 ;
32911 PyObject * obj4 = 0 ;
32912 PyObject * obj5 = 0 ;
32913 PyObject * obj6 = 0 ;
32914 char * kwnames[] = {
32915 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32916 };
32917
32918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32920 if (!SWIG_IsOK(res1)) {
32921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
32922 }
32923 arg1 = reinterpret_cast< wxWindow * >(argp1);
32924 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32925 if (!SWIG_IsOK(res2)) {
32926 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
32927 }
32928 arg2 = reinterpret_cast< wxWindow * >(argp2);
32929 if (obj2) {
32930 ecode3 = SWIG_AsVal_int(obj2, &val3);
32931 if (!SWIG_IsOK(ecode3)) {
32932 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
32933 }
32934 arg3 = static_cast< int >(val3);
32935 }
32936 if (obj3) {
32937 {
32938 arg4 = &temp4;
32939 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32940 }
32941 }
32942 if (obj4) {
32943 {
32944 arg5 = &temp5;
32945 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
32946 }
32947 }
32948 if (obj5) {
32949 ecode6 = SWIG_AsVal_long(obj5, &val6);
32950 if (!SWIG_IsOK(ecode6)) {
32951 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
32952 }
32953 arg6 = static_cast< long >(val6);
32954 }
32955 if (obj6) {
32956 {
32957 arg7 = wxString_in_helper(obj6);
32958 if (arg7 == NULL) SWIG_fail;
32959 temp7 = true;
32960 }
32961 }
32962 {
32963 PyThreadState* __tstate = wxPyBeginAllowThreads();
32964 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
32965 wxPyEndAllowThreads(__tstate);
32966 if (PyErr_Occurred()) SWIG_fail;
32967 }
32968 {
32969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32970 }
32971 {
32972 if (temp7)
32973 delete arg7;
32974 }
32975 return resultobj;
32976 fail:
32977 {
32978 if (temp7)
32979 delete arg7;
32980 }
32981 return NULL;
32982 }
32983
32984
32985 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32986 PyObject *resultobj = 0;
32987 wxWindow *arg1 = (wxWindow *) 0 ;
32988 bool arg2 = (bool) false ;
32989 bool result;
32990 void *argp1 = 0 ;
32991 int res1 = 0 ;
32992 bool val2 ;
32993 int ecode2 = 0 ;
32994 PyObject * obj0 = 0 ;
32995 PyObject * obj1 = 0 ;
32996 char * kwnames[] = {
32997 (char *) "self",(char *) "force", NULL
32998 };
32999
33000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
33001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33002 if (!SWIG_IsOK(res1)) {
33003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
33004 }
33005 arg1 = reinterpret_cast< wxWindow * >(argp1);
33006 if (obj1) {
33007 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33008 if (!SWIG_IsOK(ecode2)) {
33009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
33010 }
33011 arg2 = static_cast< bool >(val2);
33012 }
33013 {
33014 PyThreadState* __tstate = wxPyBeginAllowThreads();
33015 result = (bool)(arg1)->Close(arg2);
33016 wxPyEndAllowThreads(__tstate);
33017 if (PyErr_Occurred()) SWIG_fail;
33018 }
33019 {
33020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33021 }
33022 return resultobj;
33023 fail:
33024 return NULL;
33025 }
33026
33027
33028 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33029 PyObject *resultobj = 0;
33030 wxWindow *arg1 = (wxWindow *) 0 ;
33031 bool result;
33032 void *argp1 = 0 ;
33033 int res1 = 0 ;
33034 PyObject *swig_obj[1] ;
33035
33036 if (!args) SWIG_fail;
33037 swig_obj[0] = args;
33038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33039 if (!SWIG_IsOK(res1)) {
33040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
33041 }
33042 arg1 = reinterpret_cast< wxWindow * >(argp1);
33043 {
33044 PyThreadState* __tstate = wxPyBeginAllowThreads();
33045 result = (bool)(arg1)->Destroy();
33046 wxPyEndAllowThreads(__tstate);
33047 if (PyErr_Occurred()) SWIG_fail;
33048 }
33049 {
33050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33051 }
33052 return resultobj;
33053 fail:
33054 return NULL;
33055 }
33056
33057
33058 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33059 PyObject *resultobj = 0;
33060 wxWindow *arg1 = (wxWindow *) 0 ;
33061 bool result;
33062 void *argp1 = 0 ;
33063 int res1 = 0 ;
33064 PyObject *swig_obj[1] ;
33065
33066 if (!args) SWIG_fail;
33067 swig_obj[0] = args;
33068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33069 if (!SWIG_IsOK(res1)) {
33070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33071 }
33072 arg1 = reinterpret_cast< wxWindow * >(argp1);
33073 {
33074 PyThreadState* __tstate = wxPyBeginAllowThreads();
33075 result = (bool)(arg1)->DestroyChildren();
33076 wxPyEndAllowThreads(__tstate);
33077 if (PyErr_Occurred()) SWIG_fail;
33078 }
33079 {
33080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33081 }
33082 return resultobj;
33083 fail:
33084 return NULL;
33085 }
33086
33087
33088 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33089 PyObject *resultobj = 0;
33090 wxWindow *arg1 = (wxWindow *) 0 ;
33091 bool result;
33092 void *argp1 = 0 ;
33093 int res1 = 0 ;
33094 PyObject *swig_obj[1] ;
33095
33096 if (!args) SWIG_fail;
33097 swig_obj[0] = args;
33098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33099 if (!SWIG_IsOK(res1)) {
33100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33101 }
33102 arg1 = reinterpret_cast< wxWindow * >(argp1);
33103 {
33104 PyThreadState* __tstate = wxPyBeginAllowThreads();
33105 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33106 wxPyEndAllowThreads(__tstate);
33107 if (PyErr_Occurred()) SWIG_fail;
33108 }
33109 {
33110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33111 }
33112 return resultobj;
33113 fail:
33114 return NULL;
33115 }
33116
33117
33118 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33119 PyObject *resultobj = 0;
33120 wxWindow *arg1 = (wxWindow *) 0 ;
33121 wxString *arg2 = 0 ;
33122 void *argp1 = 0 ;
33123 int res1 = 0 ;
33124 bool temp2 = false ;
33125 PyObject * obj0 = 0 ;
33126 PyObject * obj1 = 0 ;
33127 char * kwnames[] = {
33128 (char *) "self",(char *) "label", NULL
33129 };
33130
33131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33133 if (!SWIG_IsOK(res1)) {
33134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33135 }
33136 arg1 = reinterpret_cast< wxWindow * >(argp1);
33137 {
33138 arg2 = wxString_in_helper(obj1);
33139 if (arg2 == NULL) SWIG_fail;
33140 temp2 = true;
33141 }
33142 {
33143 PyThreadState* __tstate = wxPyBeginAllowThreads();
33144 (arg1)->SetLabel((wxString const &)*arg2);
33145 wxPyEndAllowThreads(__tstate);
33146 if (PyErr_Occurred()) SWIG_fail;
33147 }
33148 resultobj = SWIG_Py_Void();
33149 {
33150 if (temp2)
33151 delete arg2;
33152 }
33153 return resultobj;
33154 fail:
33155 {
33156 if (temp2)
33157 delete arg2;
33158 }
33159 return NULL;
33160 }
33161
33162
33163 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33164 PyObject *resultobj = 0;
33165 wxWindow *arg1 = (wxWindow *) 0 ;
33166 wxString result;
33167 void *argp1 = 0 ;
33168 int res1 = 0 ;
33169 PyObject *swig_obj[1] ;
33170
33171 if (!args) SWIG_fail;
33172 swig_obj[0] = args;
33173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33174 if (!SWIG_IsOK(res1)) {
33175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33176 }
33177 arg1 = reinterpret_cast< wxWindow * >(argp1);
33178 {
33179 PyThreadState* __tstate = wxPyBeginAllowThreads();
33180 result = ((wxWindow const *)arg1)->GetLabel();
33181 wxPyEndAllowThreads(__tstate);
33182 if (PyErr_Occurred()) SWIG_fail;
33183 }
33184 {
33185 #if wxUSE_UNICODE
33186 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33187 #else
33188 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33189 #endif
33190 }
33191 return resultobj;
33192 fail:
33193 return NULL;
33194 }
33195
33196
33197 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33198 PyObject *resultobj = 0;
33199 wxWindow *arg1 = (wxWindow *) 0 ;
33200 wxString *arg2 = 0 ;
33201 void *argp1 = 0 ;
33202 int res1 = 0 ;
33203 bool temp2 = false ;
33204 PyObject * obj0 = 0 ;
33205 PyObject * obj1 = 0 ;
33206 char * kwnames[] = {
33207 (char *) "self",(char *) "name", NULL
33208 };
33209
33210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33212 if (!SWIG_IsOK(res1)) {
33213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33214 }
33215 arg1 = reinterpret_cast< wxWindow * >(argp1);
33216 {
33217 arg2 = wxString_in_helper(obj1);
33218 if (arg2 == NULL) SWIG_fail;
33219 temp2 = true;
33220 }
33221 {
33222 PyThreadState* __tstate = wxPyBeginAllowThreads();
33223 (arg1)->SetName((wxString const &)*arg2);
33224 wxPyEndAllowThreads(__tstate);
33225 if (PyErr_Occurred()) SWIG_fail;
33226 }
33227 resultobj = SWIG_Py_Void();
33228 {
33229 if (temp2)
33230 delete arg2;
33231 }
33232 return resultobj;
33233 fail:
33234 {
33235 if (temp2)
33236 delete arg2;
33237 }
33238 return NULL;
33239 }
33240
33241
33242 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33243 PyObject *resultobj = 0;
33244 wxWindow *arg1 = (wxWindow *) 0 ;
33245 wxString result;
33246 void *argp1 = 0 ;
33247 int res1 = 0 ;
33248 PyObject *swig_obj[1] ;
33249
33250 if (!args) SWIG_fail;
33251 swig_obj[0] = args;
33252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33253 if (!SWIG_IsOK(res1)) {
33254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33255 }
33256 arg1 = reinterpret_cast< wxWindow * >(argp1);
33257 {
33258 PyThreadState* __tstate = wxPyBeginAllowThreads();
33259 result = ((wxWindow const *)arg1)->GetName();
33260 wxPyEndAllowThreads(__tstate);
33261 if (PyErr_Occurred()) SWIG_fail;
33262 }
33263 {
33264 #if wxUSE_UNICODE
33265 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33266 #else
33267 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33268 #endif
33269 }
33270 return resultobj;
33271 fail:
33272 return NULL;
33273 }
33274
33275
33276 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33277 PyObject *resultobj = 0;
33278 wxWindow *arg1 = (wxWindow *) 0 ;
33279 wxWindowVariant arg2 ;
33280 void *argp1 = 0 ;
33281 int res1 = 0 ;
33282 int val2 ;
33283 int ecode2 = 0 ;
33284 PyObject * obj0 = 0 ;
33285 PyObject * obj1 = 0 ;
33286 char * kwnames[] = {
33287 (char *) "self",(char *) "variant", NULL
33288 };
33289
33290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33292 if (!SWIG_IsOK(res1)) {
33293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33294 }
33295 arg1 = reinterpret_cast< wxWindow * >(argp1);
33296 ecode2 = SWIG_AsVal_int(obj1, &val2);
33297 if (!SWIG_IsOK(ecode2)) {
33298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33299 }
33300 arg2 = static_cast< wxWindowVariant >(val2);
33301 {
33302 PyThreadState* __tstate = wxPyBeginAllowThreads();
33303 (arg1)->SetWindowVariant(arg2);
33304 wxPyEndAllowThreads(__tstate);
33305 if (PyErr_Occurred()) SWIG_fail;
33306 }
33307 resultobj = SWIG_Py_Void();
33308 return resultobj;
33309 fail:
33310 return NULL;
33311 }
33312
33313
33314 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33315 PyObject *resultobj = 0;
33316 wxWindow *arg1 = (wxWindow *) 0 ;
33317 wxWindowVariant result;
33318 void *argp1 = 0 ;
33319 int res1 = 0 ;
33320 PyObject *swig_obj[1] ;
33321
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_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33327 }
33328 arg1 = reinterpret_cast< wxWindow * >(argp1);
33329 {
33330 PyThreadState* __tstate = wxPyBeginAllowThreads();
33331 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33332 wxPyEndAllowThreads(__tstate);
33333 if (PyErr_Occurred()) SWIG_fail;
33334 }
33335 resultobj = SWIG_From_int(static_cast< int >(result));
33336 return resultobj;
33337 fail:
33338 return NULL;
33339 }
33340
33341
33342 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33343 PyObject *resultobj = 0;
33344 wxWindow *arg1 = (wxWindow *) 0 ;
33345 int arg2 ;
33346 void *argp1 = 0 ;
33347 int res1 = 0 ;
33348 int val2 ;
33349 int ecode2 = 0 ;
33350 PyObject * obj0 = 0 ;
33351 PyObject * obj1 = 0 ;
33352 char * kwnames[] = {
33353 (char *) "self",(char *) "winid", NULL
33354 };
33355
33356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33358 if (!SWIG_IsOK(res1)) {
33359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33360 }
33361 arg1 = reinterpret_cast< wxWindow * >(argp1);
33362 ecode2 = SWIG_AsVal_int(obj1, &val2);
33363 if (!SWIG_IsOK(ecode2)) {
33364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33365 }
33366 arg2 = static_cast< int >(val2);
33367 {
33368 PyThreadState* __tstate = wxPyBeginAllowThreads();
33369 (arg1)->SetId(arg2);
33370 wxPyEndAllowThreads(__tstate);
33371 if (PyErr_Occurred()) SWIG_fail;
33372 }
33373 resultobj = SWIG_Py_Void();
33374 return resultobj;
33375 fail:
33376 return NULL;
33377 }
33378
33379
33380 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33381 PyObject *resultobj = 0;
33382 wxWindow *arg1 = (wxWindow *) 0 ;
33383 int result;
33384 void *argp1 = 0 ;
33385 int res1 = 0 ;
33386 PyObject *swig_obj[1] ;
33387
33388 if (!args) SWIG_fail;
33389 swig_obj[0] = args;
33390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33391 if (!SWIG_IsOK(res1)) {
33392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33393 }
33394 arg1 = reinterpret_cast< wxWindow * >(argp1);
33395 {
33396 PyThreadState* __tstate = wxPyBeginAllowThreads();
33397 result = (int)((wxWindow const *)arg1)->GetId();
33398 wxPyEndAllowThreads(__tstate);
33399 if (PyErr_Occurred()) SWIG_fail;
33400 }
33401 resultobj = SWIG_From_int(static_cast< int >(result));
33402 return resultobj;
33403 fail:
33404 return NULL;
33405 }
33406
33407
33408 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33409 PyObject *resultobj = 0;
33410 int result;
33411
33412 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33413 {
33414 PyThreadState* __tstate = wxPyBeginAllowThreads();
33415 result = (int)wxWindow::NewControlId();
33416 wxPyEndAllowThreads(__tstate);
33417 if (PyErr_Occurred()) SWIG_fail;
33418 }
33419 resultobj = SWIG_From_int(static_cast< int >(result));
33420 return resultobj;
33421 fail:
33422 return NULL;
33423 }
33424
33425
33426 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33427 PyObject *resultobj = 0;
33428 int arg1 ;
33429 int result;
33430 int val1 ;
33431 int ecode1 = 0 ;
33432 PyObject * obj0 = 0 ;
33433 char * kwnames[] = {
33434 (char *) "winid", NULL
33435 };
33436
33437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33438 ecode1 = SWIG_AsVal_int(obj0, &val1);
33439 if (!SWIG_IsOK(ecode1)) {
33440 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33441 }
33442 arg1 = static_cast< int >(val1);
33443 {
33444 PyThreadState* __tstate = wxPyBeginAllowThreads();
33445 result = (int)wxWindow::NextControlId(arg1);
33446 wxPyEndAllowThreads(__tstate);
33447 if (PyErr_Occurred()) SWIG_fail;
33448 }
33449 resultobj = SWIG_From_int(static_cast< int >(result));
33450 return resultobj;
33451 fail:
33452 return NULL;
33453 }
33454
33455
33456 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33457 PyObject *resultobj = 0;
33458 int arg1 ;
33459 int result;
33460 int val1 ;
33461 int ecode1 = 0 ;
33462 PyObject * obj0 = 0 ;
33463 char * kwnames[] = {
33464 (char *) "winid", NULL
33465 };
33466
33467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33468 ecode1 = SWIG_AsVal_int(obj0, &val1);
33469 if (!SWIG_IsOK(ecode1)) {
33470 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33471 }
33472 arg1 = static_cast< int >(val1);
33473 {
33474 PyThreadState* __tstate = wxPyBeginAllowThreads();
33475 result = (int)wxWindow::PrevControlId(arg1);
33476 wxPyEndAllowThreads(__tstate);
33477 if (PyErr_Occurred()) SWIG_fail;
33478 }
33479 resultobj = SWIG_From_int(static_cast< int >(result));
33480 return resultobj;
33481 fail:
33482 return NULL;
33483 }
33484
33485
33486 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33487 PyObject *resultobj = 0;
33488 wxWindow *arg1 = (wxWindow *) 0 ;
33489 wxLayoutDirection result;
33490 void *argp1 = 0 ;
33491 int res1 = 0 ;
33492 PyObject *swig_obj[1] ;
33493
33494 if (!args) SWIG_fail;
33495 swig_obj[0] = args;
33496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33497 if (!SWIG_IsOK(res1)) {
33498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33499 }
33500 arg1 = reinterpret_cast< wxWindow * >(argp1);
33501 {
33502 PyThreadState* __tstate = wxPyBeginAllowThreads();
33503 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33504 wxPyEndAllowThreads(__tstate);
33505 if (PyErr_Occurred()) SWIG_fail;
33506 }
33507 resultobj = SWIG_From_int(static_cast< int >(result));
33508 return resultobj;
33509 fail:
33510 return NULL;
33511 }
33512
33513
33514 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33515 PyObject *resultobj = 0;
33516 wxWindow *arg1 = (wxWindow *) 0 ;
33517 wxLayoutDirection arg2 ;
33518 void *argp1 = 0 ;
33519 int res1 = 0 ;
33520 int val2 ;
33521 int ecode2 = 0 ;
33522 PyObject * obj0 = 0 ;
33523 PyObject * obj1 = 0 ;
33524 char * kwnames[] = {
33525 (char *) "self",(char *) "dir", NULL
33526 };
33527
33528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33530 if (!SWIG_IsOK(res1)) {
33531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33532 }
33533 arg1 = reinterpret_cast< wxWindow * >(argp1);
33534 ecode2 = SWIG_AsVal_int(obj1, &val2);
33535 if (!SWIG_IsOK(ecode2)) {
33536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33537 }
33538 arg2 = static_cast< wxLayoutDirection >(val2);
33539 {
33540 PyThreadState* __tstate = wxPyBeginAllowThreads();
33541 (arg1)->SetLayoutDirection(arg2);
33542 wxPyEndAllowThreads(__tstate);
33543 if (PyErr_Occurred()) SWIG_fail;
33544 }
33545 resultobj = SWIG_Py_Void();
33546 return resultobj;
33547 fail:
33548 return NULL;
33549 }
33550
33551
33552 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33553 PyObject *resultobj = 0;
33554 wxWindow *arg1 = (wxWindow *) 0 ;
33555 int arg2 ;
33556 int arg3 ;
33557 int arg4 ;
33558 int result;
33559 void *argp1 = 0 ;
33560 int res1 = 0 ;
33561 int val2 ;
33562 int ecode2 = 0 ;
33563 int val3 ;
33564 int ecode3 = 0 ;
33565 int val4 ;
33566 int ecode4 = 0 ;
33567 PyObject * obj0 = 0 ;
33568 PyObject * obj1 = 0 ;
33569 PyObject * obj2 = 0 ;
33570 PyObject * obj3 = 0 ;
33571 char * kwnames[] = {
33572 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33573 };
33574
33575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33577 if (!SWIG_IsOK(res1)) {
33578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33579 }
33580 arg1 = reinterpret_cast< wxWindow * >(argp1);
33581 ecode2 = SWIG_AsVal_int(obj1, &val2);
33582 if (!SWIG_IsOK(ecode2)) {
33583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33584 }
33585 arg2 = static_cast< int >(val2);
33586 ecode3 = SWIG_AsVal_int(obj2, &val3);
33587 if (!SWIG_IsOK(ecode3)) {
33588 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33589 }
33590 arg3 = static_cast< int >(val3);
33591 ecode4 = SWIG_AsVal_int(obj3, &val4);
33592 if (!SWIG_IsOK(ecode4)) {
33593 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33594 }
33595 arg4 = static_cast< int >(val4);
33596 {
33597 PyThreadState* __tstate = wxPyBeginAllowThreads();
33598 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33599 wxPyEndAllowThreads(__tstate);
33600 if (PyErr_Occurred()) SWIG_fail;
33601 }
33602 resultobj = SWIG_From_int(static_cast< int >(result));
33603 return resultobj;
33604 fail:
33605 return NULL;
33606 }
33607
33608
33609 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33610 PyObject *resultobj = 0;
33611 wxWindow *arg1 = (wxWindow *) 0 ;
33612 wxSize *arg2 = 0 ;
33613 void *argp1 = 0 ;
33614 int res1 = 0 ;
33615 wxSize temp2 ;
33616 PyObject * obj0 = 0 ;
33617 PyObject * obj1 = 0 ;
33618 char * kwnames[] = {
33619 (char *) "self",(char *) "size", NULL
33620 };
33621
33622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33624 if (!SWIG_IsOK(res1)) {
33625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33626 }
33627 arg1 = reinterpret_cast< wxWindow * >(argp1);
33628 {
33629 arg2 = &temp2;
33630 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33631 }
33632 {
33633 PyThreadState* __tstate = wxPyBeginAllowThreads();
33634 (arg1)->SetSize((wxSize const &)*arg2);
33635 wxPyEndAllowThreads(__tstate);
33636 if (PyErr_Occurred()) SWIG_fail;
33637 }
33638 resultobj = SWIG_Py_Void();
33639 return resultobj;
33640 fail:
33641 return NULL;
33642 }
33643
33644
33645 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33646 PyObject *resultobj = 0;
33647 wxWindow *arg1 = (wxWindow *) 0 ;
33648 int arg2 ;
33649 int arg3 ;
33650 int arg4 ;
33651 int arg5 ;
33652 int arg6 = (int) wxSIZE_AUTO ;
33653 void *argp1 = 0 ;
33654 int res1 = 0 ;
33655 int val2 ;
33656 int ecode2 = 0 ;
33657 int val3 ;
33658 int ecode3 = 0 ;
33659 int val4 ;
33660 int ecode4 = 0 ;
33661 int val5 ;
33662 int ecode5 = 0 ;
33663 int val6 ;
33664 int ecode6 = 0 ;
33665 PyObject * obj0 = 0 ;
33666 PyObject * obj1 = 0 ;
33667 PyObject * obj2 = 0 ;
33668 PyObject * obj3 = 0 ;
33669 PyObject * obj4 = 0 ;
33670 PyObject * obj5 = 0 ;
33671 char * kwnames[] = {
33672 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33673 };
33674
33675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33677 if (!SWIG_IsOK(res1)) {
33678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33679 }
33680 arg1 = reinterpret_cast< wxWindow * >(argp1);
33681 ecode2 = SWIG_AsVal_int(obj1, &val2);
33682 if (!SWIG_IsOK(ecode2)) {
33683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33684 }
33685 arg2 = static_cast< int >(val2);
33686 ecode3 = SWIG_AsVal_int(obj2, &val3);
33687 if (!SWIG_IsOK(ecode3)) {
33688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33689 }
33690 arg3 = static_cast< int >(val3);
33691 ecode4 = SWIG_AsVal_int(obj3, &val4);
33692 if (!SWIG_IsOK(ecode4)) {
33693 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33694 }
33695 arg4 = static_cast< int >(val4);
33696 ecode5 = SWIG_AsVal_int(obj4, &val5);
33697 if (!SWIG_IsOK(ecode5)) {
33698 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33699 }
33700 arg5 = static_cast< int >(val5);
33701 if (obj5) {
33702 ecode6 = SWIG_AsVal_int(obj5, &val6);
33703 if (!SWIG_IsOK(ecode6)) {
33704 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33705 }
33706 arg6 = static_cast< int >(val6);
33707 }
33708 {
33709 PyThreadState* __tstate = wxPyBeginAllowThreads();
33710 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33711 wxPyEndAllowThreads(__tstate);
33712 if (PyErr_Occurred()) SWIG_fail;
33713 }
33714 resultobj = SWIG_Py_Void();
33715 return resultobj;
33716 fail:
33717 return NULL;
33718 }
33719
33720
33721 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33722 PyObject *resultobj = 0;
33723 wxWindow *arg1 = (wxWindow *) 0 ;
33724 wxRect *arg2 = 0 ;
33725 int arg3 = (int) wxSIZE_AUTO ;
33726 void *argp1 = 0 ;
33727 int res1 = 0 ;
33728 wxRect temp2 ;
33729 int val3 ;
33730 int ecode3 = 0 ;
33731 PyObject * obj0 = 0 ;
33732 PyObject * obj1 = 0 ;
33733 PyObject * obj2 = 0 ;
33734 char * kwnames[] = {
33735 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33736 };
33737
33738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33740 if (!SWIG_IsOK(res1)) {
33741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33742 }
33743 arg1 = reinterpret_cast< wxWindow * >(argp1);
33744 {
33745 arg2 = &temp2;
33746 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33747 }
33748 if (obj2) {
33749 ecode3 = SWIG_AsVal_int(obj2, &val3);
33750 if (!SWIG_IsOK(ecode3)) {
33751 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33752 }
33753 arg3 = static_cast< int >(val3);
33754 }
33755 {
33756 PyThreadState* __tstate = wxPyBeginAllowThreads();
33757 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33758 wxPyEndAllowThreads(__tstate);
33759 if (PyErr_Occurred()) SWIG_fail;
33760 }
33761 resultobj = SWIG_Py_Void();
33762 return resultobj;
33763 fail:
33764 return NULL;
33765 }
33766
33767
33768 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33769 PyObject *resultobj = 0;
33770 wxWindow *arg1 = (wxWindow *) 0 ;
33771 int arg2 ;
33772 int arg3 ;
33773 void *argp1 = 0 ;
33774 int res1 = 0 ;
33775 int val2 ;
33776 int ecode2 = 0 ;
33777 int val3 ;
33778 int ecode3 = 0 ;
33779 PyObject * obj0 = 0 ;
33780 PyObject * obj1 = 0 ;
33781 PyObject * obj2 = 0 ;
33782 char * kwnames[] = {
33783 (char *) "self",(char *) "width",(char *) "height", NULL
33784 };
33785
33786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33788 if (!SWIG_IsOK(res1)) {
33789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33790 }
33791 arg1 = reinterpret_cast< wxWindow * >(argp1);
33792 ecode2 = SWIG_AsVal_int(obj1, &val2);
33793 if (!SWIG_IsOK(ecode2)) {
33794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33795 }
33796 arg2 = static_cast< int >(val2);
33797 ecode3 = SWIG_AsVal_int(obj2, &val3);
33798 if (!SWIG_IsOK(ecode3)) {
33799 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33800 }
33801 arg3 = static_cast< int >(val3);
33802 {
33803 PyThreadState* __tstate = wxPyBeginAllowThreads();
33804 (arg1)->SetSize(arg2,arg3);
33805 wxPyEndAllowThreads(__tstate);
33806 if (PyErr_Occurred()) SWIG_fail;
33807 }
33808 resultobj = SWIG_Py_Void();
33809 return resultobj;
33810 fail:
33811 return NULL;
33812 }
33813
33814
33815 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33816 PyObject *resultobj = 0;
33817 wxWindow *arg1 = (wxWindow *) 0 ;
33818 wxPoint *arg2 = 0 ;
33819 int arg3 = (int) wxSIZE_USE_EXISTING ;
33820 void *argp1 = 0 ;
33821 int res1 = 0 ;
33822 wxPoint temp2 ;
33823 int val3 ;
33824 int ecode3 = 0 ;
33825 PyObject * obj0 = 0 ;
33826 PyObject * obj1 = 0 ;
33827 PyObject * obj2 = 0 ;
33828 char * kwnames[] = {
33829 (char *) "self",(char *) "pt",(char *) "flags", NULL
33830 };
33831
33832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33834 if (!SWIG_IsOK(res1)) {
33835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33836 }
33837 arg1 = reinterpret_cast< wxWindow * >(argp1);
33838 {
33839 arg2 = &temp2;
33840 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33841 }
33842 if (obj2) {
33843 ecode3 = SWIG_AsVal_int(obj2, &val3);
33844 if (!SWIG_IsOK(ecode3)) {
33845 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33846 }
33847 arg3 = static_cast< int >(val3);
33848 }
33849 {
33850 PyThreadState* __tstate = wxPyBeginAllowThreads();
33851 (arg1)->Move((wxPoint const &)*arg2,arg3);
33852 wxPyEndAllowThreads(__tstate);
33853 if (PyErr_Occurred()) SWIG_fail;
33854 }
33855 resultobj = SWIG_Py_Void();
33856 return resultobj;
33857 fail:
33858 return NULL;
33859 }
33860
33861
33862 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33863 PyObject *resultobj = 0;
33864 wxWindow *arg1 = (wxWindow *) 0 ;
33865 int arg2 ;
33866 int arg3 ;
33867 int arg4 = (int) wxSIZE_USE_EXISTING ;
33868 void *argp1 = 0 ;
33869 int res1 = 0 ;
33870 int val2 ;
33871 int ecode2 = 0 ;
33872 int val3 ;
33873 int ecode3 = 0 ;
33874 int val4 ;
33875 int ecode4 = 0 ;
33876 PyObject * obj0 = 0 ;
33877 PyObject * obj1 = 0 ;
33878 PyObject * obj2 = 0 ;
33879 PyObject * obj3 = 0 ;
33880 char * kwnames[] = {
33881 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33882 };
33883
33884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33886 if (!SWIG_IsOK(res1)) {
33887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33888 }
33889 arg1 = reinterpret_cast< wxWindow * >(argp1);
33890 ecode2 = SWIG_AsVal_int(obj1, &val2);
33891 if (!SWIG_IsOK(ecode2)) {
33892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33893 }
33894 arg2 = static_cast< int >(val2);
33895 ecode3 = SWIG_AsVal_int(obj2, &val3);
33896 if (!SWIG_IsOK(ecode3)) {
33897 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33898 }
33899 arg3 = static_cast< int >(val3);
33900 if (obj3) {
33901 ecode4 = SWIG_AsVal_int(obj3, &val4);
33902 if (!SWIG_IsOK(ecode4)) {
33903 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33904 }
33905 arg4 = static_cast< int >(val4);
33906 }
33907 {
33908 PyThreadState* __tstate = wxPyBeginAllowThreads();
33909 (arg1)->Move(arg2,arg3,arg4);
33910 wxPyEndAllowThreads(__tstate);
33911 if (PyErr_Occurred()) SWIG_fail;
33912 }
33913 resultobj = SWIG_Py_Void();
33914 return resultobj;
33915 fail:
33916 return NULL;
33917 }
33918
33919
33920 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33921 PyObject *resultobj = 0;
33922 wxWindow *arg1 = (wxWindow *) 0 ;
33923 wxSize const &arg2_defvalue = wxDefaultSize ;
33924 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
33925 void *argp1 = 0 ;
33926 int res1 = 0 ;
33927 wxSize temp2 ;
33928 PyObject * obj0 = 0 ;
33929 PyObject * obj1 = 0 ;
33930 char * kwnames[] = {
33931 (char *) "self",(char *) "size", NULL
33932 };
33933
33934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
33935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33936 if (!SWIG_IsOK(res1)) {
33937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33938 }
33939 arg1 = reinterpret_cast< wxWindow * >(argp1);
33940 if (obj1) {
33941 {
33942 arg2 = &temp2;
33943 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33944 }
33945 }
33946 {
33947 PyThreadState* __tstate = wxPyBeginAllowThreads();
33948 (arg1)->SetInitialSize((wxSize const &)*arg2);
33949 wxPyEndAllowThreads(__tstate);
33950 if (PyErr_Occurred()) SWIG_fail;
33951 }
33952 resultobj = SWIG_Py_Void();
33953 return resultobj;
33954 fail:
33955 return NULL;
33956 }
33957
33958
33959 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33960 PyObject *resultobj = 0;
33961 wxWindow *arg1 = (wxWindow *) 0 ;
33962 void *argp1 = 0 ;
33963 int res1 = 0 ;
33964 PyObject *swig_obj[1] ;
33965
33966 if (!args) SWIG_fail;
33967 swig_obj[0] = args;
33968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33969 if (!SWIG_IsOK(res1)) {
33970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
33971 }
33972 arg1 = reinterpret_cast< wxWindow * >(argp1);
33973 {
33974 PyThreadState* __tstate = wxPyBeginAllowThreads();
33975 (arg1)->Raise();
33976 wxPyEndAllowThreads(__tstate);
33977 if (PyErr_Occurred()) SWIG_fail;
33978 }
33979 resultobj = SWIG_Py_Void();
33980 return resultobj;
33981 fail:
33982 return NULL;
33983 }
33984
33985
33986 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33987 PyObject *resultobj = 0;
33988 wxWindow *arg1 = (wxWindow *) 0 ;
33989 void *argp1 = 0 ;
33990 int res1 = 0 ;
33991 PyObject *swig_obj[1] ;
33992
33993 if (!args) SWIG_fail;
33994 swig_obj[0] = args;
33995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33996 if (!SWIG_IsOK(res1)) {
33997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
33998 }
33999 arg1 = reinterpret_cast< wxWindow * >(argp1);
34000 {
34001 PyThreadState* __tstate = wxPyBeginAllowThreads();
34002 (arg1)->Lower();
34003 wxPyEndAllowThreads(__tstate);
34004 if (PyErr_Occurred()) SWIG_fail;
34005 }
34006 resultobj = SWIG_Py_Void();
34007 return resultobj;
34008 fail:
34009 return NULL;
34010 }
34011
34012
34013 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34014 PyObject *resultobj = 0;
34015 wxWindow *arg1 = (wxWindow *) 0 ;
34016 wxSize *arg2 = 0 ;
34017 void *argp1 = 0 ;
34018 int res1 = 0 ;
34019 wxSize temp2 ;
34020 PyObject * obj0 = 0 ;
34021 PyObject * obj1 = 0 ;
34022 char * kwnames[] = {
34023 (char *) "self",(char *) "size", NULL
34024 };
34025
34026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
34027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34028 if (!SWIG_IsOK(res1)) {
34029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34030 }
34031 arg1 = reinterpret_cast< wxWindow * >(argp1);
34032 {
34033 arg2 = &temp2;
34034 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34035 }
34036 {
34037 PyThreadState* __tstate = wxPyBeginAllowThreads();
34038 (arg1)->SetClientSize((wxSize const &)*arg2);
34039 wxPyEndAllowThreads(__tstate);
34040 if (PyErr_Occurred()) SWIG_fail;
34041 }
34042 resultobj = SWIG_Py_Void();
34043 return resultobj;
34044 fail:
34045 return NULL;
34046 }
34047
34048
34049 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34050 PyObject *resultobj = 0;
34051 wxWindow *arg1 = (wxWindow *) 0 ;
34052 int arg2 ;
34053 int arg3 ;
34054 void *argp1 = 0 ;
34055 int res1 = 0 ;
34056 int val2 ;
34057 int ecode2 = 0 ;
34058 int val3 ;
34059 int ecode3 = 0 ;
34060 PyObject * obj0 = 0 ;
34061 PyObject * obj1 = 0 ;
34062 PyObject * obj2 = 0 ;
34063 char * kwnames[] = {
34064 (char *) "self",(char *) "width",(char *) "height", NULL
34065 };
34066
34067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34069 if (!SWIG_IsOK(res1)) {
34070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34071 }
34072 arg1 = reinterpret_cast< wxWindow * >(argp1);
34073 ecode2 = SWIG_AsVal_int(obj1, &val2);
34074 if (!SWIG_IsOK(ecode2)) {
34075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
34076 }
34077 arg2 = static_cast< int >(val2);
34078 ecode3 = SWIG_AsVal_int(obj2, &val3);
34079 if (!SWIG_IsOK(ecode3)) {
34080 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
34081 }
34082 arg3 = static_cast< int >(val3);
34083 {
34084 PyThreadState* __tstate = wxPyBeginAllowThreads();
34085 (arg1)->SetClientSize(arg2,arg3);
34086 wxPyEndAllowThreads(__tstate);
34087 if (PyErr_Occurred()) SWIG_fail;
34088 }
34089 resultobj = SWIG_Py_Void();
34090 return resultobj;
34091 fail:
34092 return NULL;
34093 }
34094
34095
34096 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34097 PyObject *resultobj = 0;
34098 wxWindow *arg1 = (wxWindow *) 0 ;
34099 wxRect *arg2 = 0 ;
34100 void *argp1 = 0 ;
34101 int res1 = 0 ;
34102 wxRect temp2 ;
34103 PyObject * obj0 = 0 ;
34104 PyObject * obj1 = 0 ;
34105 char * kwnames[] = {
34106 (char *) "self",(char *) "rect", NULL
34107 };
34108
34109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34111 if (!SWIG_IsOK(res1)) {
34112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34113 }
34114 arg1 = reinterpret_cast< wxWindow * >(argp1);
34115 {
34116 arg2 = &temp2;
34117 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34118 }
34119 {
34120 PyThreadState* __tstate = wxPyBeginAllowThreads();
34121 (arg1)->SetClientSize((wxRect const &)*arg2);
34122 wxPyEndAllowThreads(__tstate);
34123 if (PyErr_Occurred()) SWIG_fail;
34124 }
34125 resultobj = SWIG_Py_Void();
34126 return resultobj;
34127 fail:
34128 return NULL;
34129 }
34130
34131
34132 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34133 PyObject *resultobj = 0;
34134 wxWindow *arg1 = (wxWindow *) 0 ;
34135 wxPoint result;
34136 void *argp1 = 0 ;
34137 int res1 = 0 ;
34138 PyObject *swig_obj[1] ;
34139
34140 if (!args) SWIG_fail;
34141 swig_obj[0] = args;
34142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34143 if (!SWIG_IsOK(res1)) {
34144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34145 }
34146 arg1 = reinterpret_cast< wxWindow * >(argp1);
34147 {
34148 PyThreadState* __tstate = wxPyBeginAllowThreads();
34149 result = ((wxWindow const *)arg1)->GetPosition();
34150 wxPyEndAllowThreads(__tstate);
34151 if (PyErr_Occurred()) SWIG_fail;
34152 }
34153 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34154 return resultobj;
34155 fail:
34156 return NULL;
34157 }
34158
34159
34160 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34161 PyObject *resultobj = 0;
34162 wxWindow *arg1 = (wxWindow *) 0 ;
34163 int *arg2 = (int *) 0 ;
34164 int *arg3 = (int *) 0 ;
34165 void *argp1 = 0 ;
34166 int res1 = 0 ;
34167 int temp2 ;
34168 int res2 = SWIG_TMPOBJ ;
34169 int temp3 ;
34170 int res3 = SWIG_TMPOBJ ;
34171 PyObject *swig_obj[1] ;
34172
34173 arg2 = &temp2;
34174 arg3 = &temp3;
34175 if (!args) SWIG_fail;
34176 swig_obj[0] = args;
34177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34178 if (!SWIG_IsOK(res1)) {
34179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34180 }
34181 arg1 = reinterpret_cast< wxWindow * >(argp1);
34182 {
34183 PyThreadState* __tstate = wxPyBeginAllowThreads();
34184 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34185 wxPyEndAllowThreads(__tstate);
34186 if (PyErr_Occurred()) SWIG_fail;
34187 }
34188 resultobj = SWIG_Py_Void();
34189 if (SWIG_IsTmpObj(res2)) {
34190 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34191 } else {
34192 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34193 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34194 }
34195 if (SWIG_IsTmpObj(res3)) {
34196 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34197 } else {
34198 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34199 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34200 }
34201 return resultobj;
34202 fail:
34203 return NULL;
34204 }
34205
34206
34207 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34208 PyObject *resultobj = 0;
34209 wxWindow *arg1 = (wxWindow *) 0 ;
34210 wxPoint result;
34211 void *argp1 = 0 ;
34212 int res1 = 0 ;
34213 PyObject *swig_obj[1] ;
34214
34215 if (!args) SWIG_fail;
34216 swig_obj[0] = args;
34217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34218 if (!SWIG_IsOK(res1)) {
34219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34220 }
34221 arg1 = reinterpret_cast< wxWindow * >(argp1);
34222 {
34223 PyThreadState* __tstate = wxPyBeginAllowThreads();
34224 result = ((wxWindow const *)arg1)->GetScreenPosition();
34225 wxPyEndAllowThreads(__tstate);
34226 if (PyErr_Occurred()) SWIG_fail;
34227 }
34228 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34229 return resultobj;
34230 fail:
34231 return NULL;
34232 }
34233
34234
34235 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34236 PyObject *resultobj = 0;
34237 wxWindow *arg1 = (wxWindow *) 0 ;
34238 int *arg2 = (int *) 0 ;
34239 int *arg3 = (int *) 0 ;
34240 void *argp1 = 0 ;
34241 int res1 = 0 ;
34242 int temp2 ;
34243 int res2 = SWIG_TMPOBJ ;
34244 int temp3 ;
34245 int res3 = SWIG_TMPOBJ ;
34246 PyObject *swig_obj[1] ;
34247
34248 arg2 = &temp2;
34249 arg3 = &temp3;
34250 if (!args) SWIG_fail;
34251 swig_obj[0] = args;
34252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34253 if (!SWIG_IsOK(res1)) {
34254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34255 }
34256 arg1 = reinterpret_cast< wxWindow * >(argp1);
34257 {
34258 PyThreadState* __tstate = wxPyBeginAllowThreads();
34259 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34260 wxPyEndAllowThreads(__tstate);
34261 if (PyErr_Occurred()) SWIG_fail;
34262 }
34263 resultobj = SWIG_Py_Void();
34264 if (SWIG_IsTmpObj(res2)) {
34265 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34266 } else {
34267 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34268 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34269 }
34270 if (SWIG_IsTmpObj(res3)) {
34271 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34272 } else {
34273 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34274 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34275 }
34276 return resultobj;
34277 fail:
34278 return NULL;
34279 }
34280
34281
34282 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34283 PyObject *resultobj = 0;
34284 wxWindow *arg1 = (wxWindow *) 0 ;
34285 wxRect result;
34286 void *argp1 = 0 ;
34287 int res1 = 0 ;
34288 PyObject *swig_obj[1] ;
34289
34290 if (!args) SWIG_fail;
34291 swig_obj[0] = args;
34292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34293 if (!SWIG_IsOK(res1)) {
34294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34295 }
34296 arg1 = reinterpret_cast< wxWindow * >(argp1);
34297 {
34298 PyThreadState* __tstate = wxPyBeginAllowThreads();
34299 result = ((wxWindow const *)arg1)->GetScreenRect();
34300 wxPyEndAllowThreads(__tstate);
34301 if (PyErr_Occurred()) SWIG_fail;
34302 }
34303 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34304 return resultobj;
34305 fail:
34306 return NULL;
34307 }
34308
34309
34310 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34311 PyObject *resultobj = 0;
34312 wxWindow *arg1 = (wxWindow *) 0 ;
34313 wxSize result;
34314 void *argp1 = 0 ;
34315 int res1 = 0 ;
34316 PyObject *swig_obj[1] ;
34317
34318 if (!args) SWIG_fail;
34319 swig_obj[0] = args;
34320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34321 if (!SWIG_IsOK(res1)) {
34322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34323 }
34324 arg1 = reinterpret_cast< wxWindow * >(argp1);
34325 {
34326 PyThreadState* __tstate = wxPyBeginAllowThreads();
34327 result = ((wxWindow const *)arg1)->GetSize();
34328 wxPyEndAllowThreads(__tstate);
34329 if (PyErr_Occurred()) SWIG_fail;
34330 }
34331 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34332 return resultobj;
34333 fail:
34334 return NULL;
34335 }
34336
34337
34338 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34339 PyObject *resultobj = 0;
34340 wxWindow *arg1 = (wxWindow *) 0 ;
34341 int *arg2 = (int *) 0 ;
34342 int *arg3 = (int *) 0 ;
34343 void *argp1 = 0 ;
34344 int res1 = 0 ;
34345 int temp2 ;
34346 int res2 = SWIG_TMPOBJ ;
34347 int temp3 ;
34348 int res3 = SWIG_TMPOBJ ;
34349 PyObject *swig_obj[1] ;
34350
34351 arg2 = &temp2;
34352 arg3 = &temp3;
34353 if (!args) SWIG_fail;
34354 swig_obj[0] = args;
34355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34356 if (!SWIG_IsOK(res1)) {
34357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34358 }
34359 arg1 = reinterpret_cast< wxWindow * >(argp1);
34360 {
34361 PyThreadState* __tstate = wxPyBeginAllowThreads();
34362 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34363 wxPyEndAllowThreads(__tstate);
34364 if (PyErr_Occurred()) SWIG_fail;
34365 }
34366 resultobj = SWIG_Py_Void();
34367 if (SWIG_IsTmpObj(res2)) {
34368 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34369 } else {
34370 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34371 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34372 }
34373 if (SWIG_IsTmpObj(res3)) {
34374 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34375 } else {
34376 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34377 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34378 }
34379 return resultobj;
34380 fail:
34381 return NULL;
34382 }
34383
34384
34385 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34386 PyObject *resultobj = 0;
34387 wxWindow *arg1 = (wxWindow *) 0 ;
34388 wxRect result;
34389 void *argp1 = 0 ;
34390 int res1 = 0 ;
34391 PyObject *swig_obj[1] ;
34392
34393 if (!args) SWIG_fail;
34394 swig_obj[0] = args;
34395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34396 if (!SWIG_IsOK(res1)) {
34397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34398 }
34399 arg1 = reinterpret_cast< wxWindow * >(argp1);
34400 {
34401 PyThreadState* __tstate = wxPyBeginAllowThreads();
34402 result = ((wxWindow const *)arg1)->GetRect();
34403 wxPyEndAllowThreads(__tstate);
34404 if (PyErr_Occurred()) SWIG_fail;
34405 }
34406 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34407 return resultobj;
34408 fail:
34409 return NULL;
34410 }
34411
34412
34413 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34414 PyObject *resultobj = 0;
34415 wxWindow *arg1 = (wxWindow *) 0 ;
34416 wxSize result;
34417 void *argp1 = 0 ;
34418 int res1 = 0 ;
34419 PyObject *swig_obj[1] ;
34420
34421 if (!args) SWIG_fail;
34422 swig_obj[0] = args;
34423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34424 if (!SWIG_IsOK(res1)) {
34425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34426 }
34427 arg1 = reinterpret_cast< wxWindow * >(argp1);
34428 {
34429 PyThreadState* __tstate = wxPyBeginAllowThreads();
34430 result = ((wxWindow const *)arg1)->GetClientSize();
34431 wxPyEndAllowThreads(__tstate);
34432 if (PyErr_Occurred()) SWIG_fail;
34433 }
34434 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34435 return resultobj;
34436 fail:
34437 return NULL;
34438 }
34439
34440
34441 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34442 PyObject *resultobj = 0;
34443 wxWindow *arg1 = (wxWindow *) 0 ;
34444 int *arg2 = (int *) 0 ;
34445 int *arg3 = (int *) 0 ;
34446 void *argp1 = 0 ;
34447 int res1 = 0 ;
34448 int temp2 ;
34449 int res2 = SWIG_TMPOBJ ;
34450 int temp3 ;
34451 int res3 = SWIG_TMPOBJ ;
34452 PyObject *swig_obj[1] ;
34453
34454 arg2 = &temp2;
34455 arg3 = &temp3;
34456 if (!args) SWIG_fail;
34457 swig_obj[0] = args;
34458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34459 if (!SWIG_IsOK(res1)) {
34460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34461 }
34462 arg1 = reinterpret_cast< wxWindow * >(argp1);
34463 {
34464 PyThreadState* __tstate = wxPyBeginAllowThreads();
34465 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34466 wxPyEndAllowThreads(__tstate);
34467 if (PyErr_Occurred()) SWIG_fail;
34468 }
34469 resultobj = SWIG_Py_Void();
34470 if (SWIG_IsTmpObj(res2)) {
34471 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34472 } else {
34473 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34474 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34475 }
34476 if (SWIG_IsTmpObj(res3)) {
34477 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34478 } else {
34479 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34480 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34481 }
34482 return resultobj;
34483 fail:
34484 return NULL;
34485 }
34486
34487
34488 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34489 PyObject *resultobj = 0;
34490 wxWindow *arg1 = (wxWindow *) 0 ;
34491 wxPoint result;
34492 void *argp1 = 0 ;
34493 int res1 = 0 ;
34494 PyObject *swig_obj[1] ;
34495
34496 if (!args) SWIG_fail;
34497 swig_obj[0] = args;
34498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34499 if (!SWIG_IsOK(res1)) {
34500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34501 }
34502 arg1 = reinterpret_cast< wxWindow * >(argp1);
34503 {
34504 PyThreadState* __tstate = wxPyBeginAllowThreads();
34505 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34506 wxPyEndAllowThreads(__tstate);
34507 if (PyErr_Occurred()) SWIG_fail;
34508 }
34509 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34510 return resultobj;
34511 fail:
34512 return NULL;
34513 }
34514
34515
34516 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34517 PyObject *resultobj = 0;
34518 wxWindow *arg1 = (wxWindow *) 0 ;
34519 wxRect result;
34520 void *argp1 = 0 ;
34521 int res1 = 0 ;
34522 PyObject *swig_obj[1] ;
34523
34524 if (!args) SWIG_fail;
34525 swig_obj[0] = args;
34526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34527 if (!SWIG_IsOK(res1)) {
34528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34529 }
34530 arg1 = reinterpret_cast< wxWindow * >(argp1);
34531 {
34532 PyThreadState* __tstate = wxPyBeginAllowThreads();
34533 result = ((wxWindow const *)arg1)->GetClientRect();
34534 wxPyEndAllowThreads(__tstate);
34535 if (PyErr_Occurred()) SWIG_fail;
34536 }
34537 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34538 return resultobj;
34539 fail:
34540 return NULL;
34541 }
34542
34543
34544 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34545 PyObject *resultobj = 0;
34546 wxWindow *arg1 = (wxWindow *) 0 ;
34547 wxSize result;
34548 void *argp1 = 0 ;
34549 int res1 = 0 ;
34550 PyObject *swig_obj[1] ;
34551
34552 if (!args) SWIG_fail;
34553 swig_obj[0] = args;
34554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34555 if (!SWIG_IsOK(res1)) {
34556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34557 }
34558 arg1 = reinterpret_cast< wxWindow * >(argp1);
34559 {
34560 PyThreadState* __tstate = wxPyBeginAllowThreads();
34561 result = ((wxWindow const *)arg1)->GetBestSize();
34562 wxPyEndAllowThreads(__tstate);
34563 if (PyErr_Occurred()) SWIG_fail;
34564 }
34565 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34566 return resultobj;
34567 fail:
34568 return NULL;
34569 }
34570
34571
34572 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34573 PyObject *resultobj = 0;
34574 wxWindow *arg1 = (wxWindow *) 0 ;
34575 int *arg2 = (int *) 0 ;
34576 int *arg3 = (int *) 0 ;
34577 void *argp1 = 0 ;
34578 int res1 = 0 ;
34579 int temp2 ;
34580 int res2 = SWIG_TMPOBJ ;
34581 int temp3 ;
34582 int res3 = SWIG_TMPOBJ ;
34583 PyObject *swig_obj[1] ;
34584
34585 arg2 = &temp2;
34586 arg3 = &temp3;
34587 if (!args) SWIG_fail;
34588 swig_obj[0] = args;
34589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34590 if (!SWIG_IsOK(res1)) {
34591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34592 }
34593 arg1 = reinterpret_cast< wxWindow * >(argp1);
34594 {
34595 PyThreadState* __tstate = wxPyBeginAllowThreads();
34596 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34597 wxPyEndAllowThreads(__tstate);
34598 if (PyErr_Occurred()) SWIG_fail;
34599 }
34600 resultobj = SWIG_Py_Void();
34601 if (SWIG_IsTmpObj(res2)) {
34602 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34603 } else {
34604 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34605 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34606 }
34607 if (SWIG_IsTmpObj(res3)) {
34608 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34609 } else {
34610 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34611 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34612 }
34613 return resultobj;
34614 fail:
34615 return NULL;
34616 }
34617
34618
34619 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34620 PyObject *resultobj = 0;
34621 wxWindow *arg1 = (wxWindow *) 0 ;
34622 void *argp1 = 0 ;
34623 int res1 = 0 ;
34624 PyObject *swig_obj[1] ;
34625
34626 if (!args) SWIG_fail;
34627 swig_obj[0] = args;
34628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34629 if (!SWIG_IsOK(res1)) {
34630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34631 }
34632 arg1 = reinterpret_cast< wxWindow * >(argp1);
34633 {
34634 PyThreadState* __tstate = wxPyBeginAllowThreads();
34635 (arg1)->InvalidateBestSize();
34636 wxPyEndAllowThreads(__tstate);
34637 if (PyErr_Occurred()) SWIG_fail;
34638 }
34639 resultobj = SWIG_Py_Void();
34640 return resultobj;
34641 fail:
34642 return NULL;
34643 }
34644
34645
34646 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34647 PyObject *resultobj = 0;
34648 wxWindow *arg1 = (wxWindow *) 0 ;
34649 wxSize *arg2 = 0 ;
34650 void *argp1 = 0 ;
34651 int res1 = 0 ;
34652 wxSize temp2 ;
34653 PyObject * obj0 = 0 ;
34654 PyObject * obj1 = 0 ;
34655 char * kwnames[] = {
34656 (char *) "self",(char *) "size", NULL
34657 };
34658
34659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34661 if (!SWIG_IsOK(res1)) {
34662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34663 }
34664 arg1 = reinterpret_cast< wxWindow * >(argp1);
34665 {
34666 arg2 = &temp2;
34667 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34668 }
34669 {
34670 PyThreadState* __tstate = wxPyBeginAllowThreads();
34671 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34672 wxPyEndAllowThreads(__tstate);
34673 if (PyErr_Occurred()) SWIG_fail;
34674 }
34675 resultobj = SWIG_Py_Void();
34676 return resultobj;
34677 fail:
34678 return NULL;
34679 }
34680
34681
34682 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34683 PyObject *resultobj = 0;
34684 wxWindow *arg1 = (wxWindow *) 0 ;
34685 wxSize result;
34686 void *argp1 = 0 ;
34687 int res1 = 0 ;
34688 PyObject *swig_obj[1] ;
34689
34690 if (!args) SWIG_fail;
34691 swig_obj[0] = args;
34692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34693 if (!SWIG_IsOK(res1)) {
34694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34695 }
34696 arg1 = reinterpret_cast< wxWindow * >(argp1);
34697 {
34698 PyThreadState* __tstate = wxPyBeginAllowThreads();
34699 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
34700 wxPyEndAllowThreads(__tstate);
34701 if (PyErr_Occurred()) SWIG_fail;
34702 }
34703 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34704 return resultobj;
34705 fail:
34706 return NULL;
34707 }
34708
34709
34710 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34711 PyObject *resultobj = 0;
34712 wxWindow *arg1 = (wxWindow *) 0 ;
34713 int arg2 = (int) wxBOTH ;
34714 void *argp1 = 0 ;
34715 int res1 = 0 ;
34716 int val2 ;
34717 int ecode2 = 0 ;
34718 PyObject * obj0 = 0 ;
34719 PyObject * obj1 = 0 ;
34720 char * kwnames[] = {
34721 (char *) "self",(char *) "direction", NULL
34722 };
34723
34724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34726 if (!SWIG_IsOK(res1)) {
34727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34728 }
34729 arg1 = reinterpret_cast< wxWindow * >(argp1);
34730 if (obj1) {
34731 ecode2 = SWIG_AsVal_int(obj1, &val2);
34732 if (!SWIG_IsOK(ecode2)) {
34733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34734 }
34735 arg2 = static_cast< int >(val2);
34736 }
34737 {
34738 PyThreadState* __tstate = wxPyBeginAllowThreads();
34739 (arg1)->Center(arg2);
34740 wxPyEndAllowThreads(__tstate);
34741 if (PyErr_Occurred()) SWIG_fail;
34742 }
34743 resultobj = SWIG_Py_Void();
34744 return resultobj;
34745 fail:
34746 return NULL;
34747 }
34748
34749
34750 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34751 PyObject *resultobj = 0;
34752 wxWindow *arg1 = (wxWindow *) 0 ;
34753 int arg2 = (int) wxBOTH ;
34754 void *argp1 = 0 ;
34755 int res1 = 0 ;
34756 int val2 ;
34757 int ecode2 = 0 ;
34758 PyObject * obj0 = 0 ;
34759 PyObject * obj1 = 0 ;
34760 char * kwnames[] = {
34761 (char *) "self",(char *) "dir", NULL
34762 };
34763
34764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34766 if (!SWIG_IsOK(res1)) {
34767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34768 }
34769 arg1 = reinterpret_cast< wxWindow * >(argp1);
34770 if (obj1) {
34771 ecode2 = SWIG_AsVal_int(obj1, &val2);
34772 if (!SWIG_IsOK(ecode2)) {
34773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34774 }
34775 arg2 = static_cast< int >(val2);
34776 }
34777 {
34778 PyThreadState* __tstate = wxPyBeginAllowThreads();
34779 (arg1)->CenterOnParent(arg2);
34780 wxPyEndAllowThreads(__tstate);
34781 if (PyErr_Occurred()) SWIG_fail;
34782 }
34783 resultobj = SWIG_Py_Void();
34784 return resultobj;
34785 fail:
34786 return NULL;
34787 }
34788
34789
34790 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34791 PyObject *resultobj = 0;
34792 wxWindow *arg1 = (wxWindow *) 0 ;
34793 void *argp1 = 0 ;
34794 int res1 = 0 ;
34795 PyObject *swig_obj[1] ;
34796
34797 if (!args) SWIG_fail;
34798 swig_obj[0] = args;
34799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34800 if (!SWIG_IsOK(res1)) {
34801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34802 }
34803 arg1 = reinterpret_cast< wxWindow * >(argp1);
34804 {
34805 PyThreadState* __tstate = wxPyBeginAllowThreads();
34806 (arg1)->Fit();
34807 wxPyEndAllowThreads(__tstate);
34808 if (PyErr_Occurred()) SWIG_fail;
34809 }
34810 resultobj = SWIG_Py_Void();
34811 return resultobj;
34812 fail:
34813 return NULL;
34814 }
34815
34816
34817 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34818 PyObject *resultobj = 0;
34819 wxWindow *arg1 = (wxWindow *) 0 ;
34820 void *argp1 = 0 ;
34821 int res1 = 0 ;
34822 PyObject *swig_obj[1] ;
34823
34824 if (!args) SWIG_fail;
34825 swig_obj[0] = args;
34826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34827 if (!SWIG_IsOK(res1)) {
34828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34829 }
34830 arg1 = reinterpret_cast< wxWindow * >(argp1);
34831 {
34832 PyThreadState* __tstate = wxPyBeginAllowThreads();
34833 (arg1)->FitInside();
34834 wxPyEndAllowThreads(__tstate);
34835 if (PyErr_Occurred()) SWIG_fail;
34836 }
34837 resultobj = SWIG_Py_Void();
34838 return resultobj;
34839 fail:
34840 return NULL;
34841 }
34842
34843
34844 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34845 PyObject *resultobj = 0;
34846 wxWindow *arg1 = (wxWindow *) 0 ;
34847 int arg2 ;
34848 int arg3 ;
34849 int arg4 = (int) -1 ;
34850 int arg5 = (int) -1 ;
34851 int arg6 = (int) -1 ;
34852 int arg7 = (int) -1 ;
34853 void *argp1 = 0 ;
34854 int res1 = 0 ;
34855 int val2 ;
34856 int ecode2 = 0 ;
34857 int val3 ;
34858 int ecode3 = 0 ;
34859 int val4 ;
34860 int ecode4 = 0 ;
34861 int val5 ;
34862 int ecode5 = 0 ;
34863 int val6 ;
34864 int ecode6 = 0 ;
34865 int val7 ;
34866 int ecode7 = 0 ;
34867 PyObject * obj0 = 0 ;
34868 PyObject * obj1 = 0 ;
34869 PyObject * obj2 = 0 ;
34870 PyObject * obj3 = 0 ;
34871 PyObject * obj4 = 0 ;
34872 PyObject * obj5 = 0 ;
34873 PyObject * obj6 = 0 ;
34874 char * kwnames[] = {
34875 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34876 };
34877
34878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34880 if (!SWIG_IsOK(res1)) {
34881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34882 }
34883 arg1 = reinterpret_cast< wxWindow * >(argp1);
34884 ecode2 = SWIG_AsVal_int(obj1, &val2);
34885 if (!SWIG_IsOK(ecode2)) {
34886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34887 }
34888 arg2 = static_cast< int >(val2);
34889 ecode3 = SWIG_AsVal_int(obj2, &val3);
34890 if (!SWIG_IsOK(ecode3)) {
34891 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34892 }
34893 arg3 = static_cast< int >(val3);
34894 if (obj3) {
34895 ecode4 = SWIG_AsVal_int(obj3, &val4);
34896 if (!SWIG_IsOK(ecode4)) {
34897 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34898 }
34899 arg4 = static_cast< int >(val4);
34900 }
34901 if (obj4) {
34902 ecode5 = SWIG_AsVal_int(obj4, &val5);
34903 if (!SWIG_IsOK(ecode5)) {
34904 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34905 }
34906 arg5 = static_cast< int >(val5);
34907 }
34908 if (obj5) {
34909 ecode6 = SWIG_AsVal_int(obj5, &val6);
34910 if (!SWIG_IsOK(ecode6)) {
34911 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34912 }
34913 arg6 = static_cast< int >(val6);
34914 }
34915 if (obj6) {
34916 ecode7 = SWIG_AsVal_int(obj6, &val7);
34917 if (!SWIG_IsOK(ecode7)) {
34918 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34919 }
34920 arg7 = static_cast< int >(val7);
34921 }
34922 {
34923 PyThreadState* __tstate = wxPyBeginAllowThreads();
34924 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
34925 wxPyEndAllowThreads(__tstate);
34926 if (PyErr_Occurred()) SWIG_fail;
34927 }
34928 resultobj = SWIG_Py_Void();
34929 return resultobj;
34930 fail:
34931 return NULL;
34932 }
34933
34934
34935 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34936 PyObject *resultobj = 0;
34937 wxWindow *arg1 = (wxWindow *) 0 ;
34938 wxSize *arg2 = 0 ;
34939 wxSize const &arg3_defvalue = wxDefaultSize ;
34940 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34941 wxSize const &arg4_defvalue = wxDefaultSize ;
34942 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
34943 void *argp1 = 0 ;
34944 int res1 = 0 ;
34945 wxSize temp2 ;
34946 wxSize temp3 ;
34947 wxSize temp4 ;
34948 PyObject * obj0 = 0 ;
34949 PyObject * obj1 = 0 ;
34950 PyObject * obj2 = 0 ;
34951 PyObject * obj3 = 0 ;
34952 char * kwnames[] = {
34953 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
34954 };
34955
34956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34958 if (!SWIG_IsOK(res1)) {
34959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34960 }
34961 arg1 = reinterpret_cast< wxWindow * >(argp1);
34962 {
34963 arg2 = &temp2;
34964 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34965 }
34966 if (obj2) {
34967 {
34968 arg3 = &temp3;
34969 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34970 }
34971 }
34972 if (obj3) {
34973 {
34974 arg4 = &temp4;
34975 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
34976 }
34977 }
34978 {
34979 PyThreadState* __tstate = wxPyBeginAllowThreads();
34980 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
34981 wxPyEndAllowThreads(__tstate);
34982 if (PyErr_Occurred()) SWIG_fail;
34983 }
34984 resultobj = SWIG_Py_Void();
34985 return resultobj;
34986 fail:
34987 return NULL;
34988 }
34989
34990
34991 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34992 PyObject *resultobj = 0;
34993 wxWindow *arg1 = (wxWindow *) 0 ;
34994 int arg2 ;
34995 int arg3 ;
34996 int arg4 = (int) -1 ;
34997 int arg5 = (int) -1 ;
34998 void *argp1 = 0 ;
34999 int res1 = 0 ;
35000 int val2 ;
35001 int ecode2 = 0 ;
35002 int val3 ;
35003 int ecode3 = 0 ;
35004 int val4 ;
35005 int ecode4 = 0 ;
35006 int val5 ;
35007 int ecode5 = 0 ;
35008 PyObject * obj0 = 0 ;
35009 PyObject * obj1 = 0 ;
35010 PyObject * obj2 = 0 ;
35011 PyObject * obj3 = 0 ;
35012 PyObject * obj4 = 0 ;
35013 char * kwnames[] = {
35014 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
35015 };
35016
35017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35019 if (!SWIG_IsOK(res1)) {
35020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
35021 }
35022 arg1 = reinterpret_cast< wxWindow * >(argp1);
35023 ecode2 = SWIG_AsVal_int(obj1, &val2);
35024 if (!SWIG_IsOK(ecode2)) {
35025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
35026 }
35027 arg2 = static_cast< int >(val2);
35028 ecode3 = SWIG_AsVal_int(obj2, &val3);
35029 if (!SWIG_IsOK(ecode3)) {
35030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
35031 }
35032 arg3 = static_cast< int >(val3);
35033 if (obj3) {
35034 ecode4 = SWIG_AsVal_int(obj3, &val4);
35035 if (!SWIG_IsOK(ecode4)) {
35036 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
35037 }
35038 arg4 = static_cast< int >(val4);
35039 }
35040 if (obj4) {
35041 ecode5 = SWIG_AsVal_int(obj4, &val5);
35042 if (!SWIG_IsOK(ecode5)) {
35043 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
35044 }
35045 arg5 = static_cast< int >(val5);
35046 }
35047 {
35048 PyThreadState* __tstate = wxPyBeginAllowThreads();
35049 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
35050 wxPyEndAllowThreads(__tstate);
35051 if (PyErr_Occurred()) SWIG_fail;
35052 }
35053 resultobj = SWIG_Py_Void();
35054 return resultobj;
35055 fail:
35056 return NULL;
35057 }
35058
35059
35060 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35061 PyObject *resultobj = 0;
35062 wxWindow *arg1 = (wxWindow *) 0 ;
35063 wxSize *arg2 = 0 ;
35064 wxSize const &arg3_defvalue = wxDefaultSize ;
35065 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35066 void *argp1 = 0 ;
35067 int res1 = 0 ;
35068 wxSize temp2 ;
35069 wxSize temp3 ;
35070 PyObject * obj0 = 0 ;
35071 PyObject * obj1 = 0 ;
35072 PyObject * obj2 = 0 ;
35073 char * kwnames[] = {
35074 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
35075 };
35076
35077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35079 if (!SWIG_IsOK(res1)) {
35080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35081 }
35082 arg1 = reinterpret_cast< wxWindow * >(argp1);
35083 {
35084 arg2 = &temp2;
35085 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35086 }
35087 if (obj2) {
35088 {
35089 arg3 = &temp3;
35090 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35091 }
35092 }
35093 {
35094 PyThreadState* __tstate = wxPyBeginAllowThreads();
35095 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35096 wxPyEndAllowThreads(__tstate);
35097 if (PyErr_Occurred()) SWIG_fail;
35098 }
35099 resultobj = SWIG_Py_Void();
35100 return resultobj;
35101 fail:
35102 return NULL;
35103 }
35104
35105
35106 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35107 PyObject *resultobj = 0;
35108 wxWindow *arg1 = (wxWindow *) 0 ;
35109 wxSize result;
35110 void *argp1 = 0 ;
35111 int res1 = 0 ;
35112 PyObject *swig_obj[1] ;
35113
35114 if (!args) SWIG_fail;
35115 swig_obj[0] = args;
35116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35117 if (!SWIG_IsOK(res1)) {
35118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35119 }
35120 arg1 = reinterpret_cast< wxWindow * >(argp1);
35121 {
35122 PyThreadState* __tstate = wxPyBeginAllowThreads();
35123 result = ((wxWindow const *)arg1)->GetMaxSize();
35124 wxPyEndAllowThreads(__tstate);
35125 if (PyErr_Occurred()) SWIG_fail;
35126 }
35127 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35128 return resultobj;
35129 fail:
35130 return NULL;
35131 }
35132
35133
35134 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35135 PyObject *resultobj = 0;
35136 wxWindow *arg1 = (wxWindow *) 0 ;
35137 wxSize result;
35138 void *argp1 = 0 ;
35139 int res1 = 0 ;
35140 PyObject *swig_obj[1] ;
35141
35142 if (!args) SWIG_fail;
35143 swig_obj[0] = args;
35144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35145 if (!SWIG_IsOK(res1)) {
35146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35147 }
35148 arg1 = reinterpret_cast< wxWindow * >(argp1);
35149 {
35150 PyThreadState* __tstate = wxPyBeginAllowThreads();
35151 result = ((wxWindow const *)arg1)->GetMinSize();
35152 wxPyEndAllowThreads(__tstate);
35153 if (PyErr_Occurred()) SWIG_fail;
35154 }
35155 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35156 return resultobj;
35157 fail:
35158 return NULL;
35159 }
35160
35161
35162 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35163 PyObject *resultobj = 0;
35164 wxWindow *arg1 = (wxWindow *) 0 ;
35165 wxSize *arg2 = 0 ;
35166 void *argp1 = 0 ;
35167 int res1 = 0 ;
35168 wxSize temp2 ;
35169 PyObject * obj0 = 0 ;
35170 PyObject * obj1 = 0 ;
35171 char * kwnames[] = {
35172 (char *) "self",(char *) "minSize", NULL
35173 };
35174
35175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35177 if (!SWIG_IsOK(res1)) {
35178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35179 }
35180 arg1 = reinterpret_cast< wxWindow * >(argp1);
35181 {
35182 arg2 = &temp2;
35183 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35184 }
35185 {
35186 PyThreadState* __tstate = wxPyBeginAllowThreads();
35187 (arg1)->SetMinSize((wxSize const &)*arg2);
35188 wxPyEndAllowThreads(__tstate);
35189 if (PyErr_Occurred()) SWIG_fail;
35190 }
35191 resultobj = SWIG_Py_Void();
35192 return resultobj;
35193 fail:
35194 return NULL;
35195 }
35196
35197
35198 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35199 PyObject *resultobj = 0;
35200 wxWindow *arg1 = (wxWindow *) 0 ;
35201 wxSize *arg2 = 0 ;
35202 void *argp1 = 0 ;
35203 int res1 = 0 ;
35204 wxSize temp2 ;
35205 PyObject * obj0 = 0 ;
35206 PyObject * obj1 = 0 ;
35207 char * kwnames[] = {
35208 (char *) "self",(char *) "maxSize", NULL
35209 };
35210
35211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35213 if (!SWIG_IsOK(res1)) {
35214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35215 }
35216 arg1 = reinterpret_cast< wxWindow * >(argp1);
35217 {
35218 arg2 = &temp2;
35219 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35220 }
35221 {
35222 PyThreadState* __tstate = wxPyBeginAllowThreads();
35223 (arg1)->SetMaxSize((wxSize const &)*arg2);
35224 wxPyEndAllowThreads(__tstate);
35225 if (PyErr_Occurred()) SWIG_fail;
35226 }
35227 resultobj = SWIG_Py_Void();
35228 return resultobj;
35229 fail:
35230 return NULL;
35231 }
35232
35233
35234 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35235 PyObject *resultobj = 0;
35236 wxWindow *arg1 = (wxWindow *) 0 ;
35237 int result;
35238 void *argp1 = 0 ;
35239 int res1 = 0 ;
35240 PyObject *swig_obj[1] ;
35241
35242 if (!args) SWIG_fail;
35243 swig_obj[0] = args;
35244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35245 if (!SWIG_IsOK(res1)) {
35246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35247 }
35248 arg1 = reinterpret_cast< wxWindow * >(argp1);
35249 {
35250 PyThreadState* __tstate = wxPyBeginAllowThreads();
35251 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35252 wxPyEndAllowThreads(__tstate);
35253 if (PyErr_Occurred()) SWIG_fail;
35254 }
35255 resultobj = SWIG_From_int(static_cast< int >(result));
35256 return resultobj;
35257 fail:
35258 return NULL;
35259 }
35260
35261
35262 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35263 PyObject *resultobj = 0;
35264 wxWindow *arg1 = (wxWindow *) 0 ;
35265 int result;
35266 void *argp1 = 0 ;
35267 int res1 = 0 ;
35268 PyObject *swig_obj[1] ;
35269
35270 if (!args) SWIG_fail;
35271 swig_obj[0] = args;
35272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35273 if (!SWIG_IsOK(res1)) {
35274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35275 }
35276 arg1 = reinterpret_cast< wxWindow * >(argp1);
35277 {
35278 PyThreadState* __tstate = wxPyBeginAllowThreads();
35279 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35280 wxPyEndAllowThreads(__tstate);
35281 if (PyErr_Occurred()) SWIG_fail;
35282 }
35283 resultobj = SWIG_From_int(static_cast< int >(result));
35284 return resultobj;
35285 fail:
35286 return NULL;
35287 }
35288
35289
35290 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35291 PyObject *resultobj = 0;
35292 wxWindow *arg1 = (wxWindow *) 0 ;
35293 int result;
35294 void *argp1 = 0 ;
35295 int res1 = 0 ;
35296 PyObject *swig_obj[1] ;
35297
35298 if (!args) SWIG_fail;
35299 swig_obj[0] = args;
35300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35301 if (!SWIG_IsOK(res1)) {
35302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35303 }
35304 arg1 = reinterpret_cast< wxWindow * >(argp1);
35305 {
35306 PyThreadState* __tstate = wxPyBeginAllowThreads();
35307 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35308 wxPyEndAllowThreads(__tstate);
35309 if (PyErr_Occurred()) SWIG_fail;
35310 }
35311 resultobj = SWIG_From_int(static_cast< int >(result));
35312 return resultobj;
35313 fail:
35314 return NULL;
35315 }
35316
35317
35318 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35319 PyObject *resultobj = 0;
35320 wxWindow *arg1 = (wxWindow *) 0 ;
35321 int result;
35322 void *argp1 = 0 ;
35323 int res1 = 0 ;
35324 PyObject *swig_obj[1] ;
35325
35326 if (!args) SWIG_fail;
35327 swig_obj[0] = args;
35328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35329 if (!SWIG_IsOK(res1)) {
35330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35331 }
35332 arg1 = reinterpret_cast< wxWindow * >(argp1);
35333 {
35334 PyThreadState* __tstate = wxPyBeginAllowThreads();
35335 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35336 wxPyEndAllowThreads(__tstate);
35337 if (PyErr_Occurred()) SWIG_fail;
35338 }
35339 resultobj = SWIG_From_int(static_cast< int >(result));
35340 return resultobj;
35341 fail:
35342 return NULL;
35343 }
35344
35345
35346 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35347 PyObject *resultobj = 0;
35348 wxWindow *arg1 = (wxWindow *) 0 ;
35349 wxSize *arg2 = 0 ;
35350 void *argp1 = 0 ;
35351 int res1 = 0 ;
35352 wxSize temp2 ;
35353 PyObject * obj0 = 0 ;
35354 PyObject * obj1 = 0 ;
35355 char * kwnames[] = {
35356 (char *) "self",(char *) "size", NULL
35357 };
35358
35359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35361 if (!SWIG_IsOK(res1)) {
35362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35363 }
35364 arg1 = reinterpret_cast< wxWindow * >(argp1);
35365 {
35366 arg2 = &temp2;
35367 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35368 }
35369 {
35370 PyThreadState* __tstate = wxPyBeginAllowThreads();
35371 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35372 wxPyEndAllowThreads(__tstate);
35373 if (PyErr_Occurred()) SWIG_fail;
35374 }
35375 resultobj = SWIG_Py_Void();
35376 return resultobj;
35377 fail:
35378 return NULL;
35379 }
35380
35381
35382 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35383 PyObject *resultobj = 0;
35384 wxWindow *arg1 = (wxWindow *) 0 ;
35385 int arg2 ;
35386 int arg3 ;
35387 void *argp1 = 0 ;
35388 int res1 = 0 ;
35389 int val2 ;
35390 int ecode2 = 0 ;
35391 int val3 ;
35392 int ecode3 = 0 ;
35393 PyObject * obj0 = 0 ;
35394 PyObject * obj1 = 0 ;
35395 PyObject * obj2 = 0 ;
35396 char * kwnames[] = {
35397 (char *) "self",(char *) "w",(char *) "h", NULL
35398 };
35399
35400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35402 if (!SWIG_IsOK(res1)) {
35403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35404 }
35405 arg1 = reinterpret_cast< wxWindow * >(argp1);
35406 ecode2 = SWIG_AsVal_int(obj1, &val2);
35407 if (!SWIG_IsOK(ecode2)) {
35408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35409 }
35410 arg2 = static_cast< int >(val2);
35411 ecode3 = SWIG_AsVal_int(obj2, &val3);
35412 if (!SWIG_IsOK(ecode3)) {
35413 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35414 }
35415 arg3 = static_cast< int >(val3);
35416 {
35417 PyThreadState* __tstate = wxPyBeginAllowThreads();
35418 (arg1)->SetVirtualSize(arg2,arg3);
35419 wxPyEndAllowThreads(__tstate);
35420 if (PyErr_Occurred()) SWIG_fail;
35421 }
35422 resultobj = SWIG_Py_Void();
35423 return resultobj;
35424 fail:
35425 return NULL;
35426 }
35427
35428
35429 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35430 PyObject *resultobj = 0;
35431 wxWindow *arg1 = (wxWindow *) 0 ;
35432 wxSize result;
35433 void *argp1 = 0 ;
35434 int res1 = 0 ;
35435 PyObject *swig_obj[1] ;
35436
35437 if (!args) SWIG_fail;
35438 swig_obj[0] = args;
35439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35440 if (!SWIG_IsOK(res1)) {
35441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35442 }
35443 arg1 = reinterpret_cast< wxWindow * >(argp1);
35444 {
35445 PyThreadState* __tstate = wxPyBeginAllowThreads();
35446 result = ((wxWindow const *)arg1)->GetVirtualSize();
35447 wxPyEndAllowThreads(__tstate);
35448 if (PyErr_Occurred()) SWIG_fail;
35449 }
35450 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35451 return resultobj;
35452 fail:
35453 return NULL;
35454 }
35455
35456
35457 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35458 PyObject *resultobj = 0;
35459 wxWindow *arg1 = (wxWindow *) 0 ;
35460 int *arg2 = (int *) 0 ;
35461 int *arg3 = (int *) 0 ;
35462 void *argp1 = 0 ;
35463 int res1 = 0 ;
35464 int temp2 ;
35465 int res2 = SWIG_TMPOBJ ;
35466 int temp3 ;
35467 int res3 = SWIG_TMPOBJ ;
35468 PyObject *swig_obj[1] ;
35469
35470 arg2 = &temp2;
35471 arg3 = &temp3;
35472 if (!args) SWIG_fail;
35473 swig_obj[0] = args;
35474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35475 if (!SWIG_IsOK(res1)) {
35476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35477 }
35478 arg1 = reinterpret_cast< wxWindow * >(argp1);
35479 {
35480 PyThreadState* __tstate = wxPyBeginAllowThreads();
35481 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35482 wxPyEndAllowThreads(__tstate);
35483 if (PyErr_Occurred()) SWIG_fail;
35484 }
35485 resultobj = SWIG_Py_Void();
35486 if (SWIG_IsTmpObj(res2)) {
35487 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35488 } else {
35489 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35490 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35491 }
35492 if (SWIG_IsTmpObj(res3)) {
35493 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35494 } else {
35495 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35496 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35497 }
35498 return resultobj;
35499 fail:
35500 return NULL;
35501 }
35502
35503
35504 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35505 PyObject *resultobj = 0;
35506 wxWindow *arg1 = (wxWindow *) 0 ;
35507 wxSize result;
35508 void *argp1 = 0 ;
35509 int res1 = 0 ;
35510 PyObject *swig_obj[1] ;
35511
35512 if (!args) SWIG_fail;
35513 swig_obj[0] = args;
35514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35515 if (!SWIG_IsOK(res1)) {
35516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35517 }
35518 arg1 = reinterpret_cast< wxWindow * >(argp1);
35519 {
35520 PyThreadState* __tstate = wxPyBeginAllowThreads();
35521 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35522 wxPyEndAllowThreads(__tstate);
35523 if (PyErr_Occurred()) SWIG_fail;
35524 }
35525 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35526 return resultobj;
35527 fail:
35528 return NULL;
35529 }
35530
35531
35532 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35533 PyObject *resultobj = 0;
35534 wxWindow *arg1 = (wxWindow *) 0 ;
35535 bool arg2 = (bool) true ;
35536 bool result;
35537 void *argp1 = 0 ;
35538 int res1 = 0 ;
35539 bool val2 ;
35540 int ecode2 = 0 ;
35541 PyObject * obj0 = 0 ;
35542 PyObject * obj1 = 0 ;
35543 char * kwnames[] = {
35544 (char *) "self",(char *) "show", NULL
35545 };
35546
35547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35549 if (!SWIG_IsOK(res1)) {
35550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35551 }
35552 arg1 = reinterpret_cast< wxWindow * >(argp1);
35553 if (obj1) {
35554 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35555 if (!SWIG_IsOK(ecode2)) {
35556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35557 }
35558 arg2 = static_cast< bool >(val2);
35559 }
35560 {
35561 PyThreadState* __tstate = wxPyBeginAllowThreads();
35562 result = (bool)(arg1)->Show(arg2);
35563 wxPyEndAllowThreads(__tstate);
35564 if (PyErr_Occurred()) SWIG_fail;
35565 }
35566 {
35567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35568 }
35569 return resultobj;
35570 fail:
35571 return NULL;
35572 }
35573
35574
35575 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35576 PyObject *resultobj = 0;
35577 wxWindow *arg1 = (wxWindow *) 0 ;
35578 bool result;
35579 void *argp1 = 0 ;
35580 int res1 = 0 ;
35581 PyObject *swig_obj[1] ;
35582
35583 if (!args) SWIG_fail;
35584 swig_obj[0] = args;
35585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35586 if (!SWIG_IsOK(res1)) {
35587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35588 }
35589 arg1 = reinterpret_cast< wxWindow * >(argp1);
35590 {
35591 PyThreadState* __tstate = wxPyBeginAllowThreads();
35592 result = (bool)(arg1)->Hide();
35593 wxPyEndAllowThreads(__tstate);
35594 if (PyErr_Occurred()) SWIG_fail;
35595 }
35596 {
35597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35598 }
35599 return resultobj;
35600 fail:
35601 return NULL;
35602 }
35603
35604
35605 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35606 PyObject *resultobj = 0;
35607 wxWindow *arg1 = (wxWindow *) 0 ;
35608 bool arg2 = (bool) true ;
35609 bool result;
35610 void *argp1 = 0 ;
35611 int res1 = 0 ;
35612 bool val2 ;
35613 int ecode2 = 0 ;
35614 PyObject * obj0 = 0 ;
35615 PyObject * obj1 = 0 ;
35616 char * kwnames[] = {
35617 (char *) "self",(char *) "enable", NULL
35618 };
35619
35620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35622 if (!SWIG_IsOK(res1)) {
35623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35624 }
35625 arg1 = reinterpret_cast< wxWindow * >(argp1);
35626 if (obj1) {
35627 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35628 if (!SWIG_IsOK(ecode2)) {
35629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35630 }
35631 arg2 = static_cast< bool >(val2);
35632 }
35633 {
35634 PyThreadState* __tstate = wxPyBeginAllowThreads();
35635 result = (bool)(arg1)->Enable(arg2);
35636 wxPyEndAllowThreads(__tstate);
35637 if (PyErr_Occurred()) SWIG_fail;
35638 }
35639 {
35640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35641 }
35642 return resultobj;
35643 fail:
35644 return NULL;
35645 }
35646
35647
35648 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35649 PyObject *resultobj = 0;
35650 wxWindow *arg1 = (wxWindow *) 0 ;
35651 bool result;
35652 void *argp1 = 0 ;
35653 int res1 = 0 ;
35654 PyObject *swig_obj[1] ;
35655
35656 if (!args) SWIG_fail;
35657 swig_obj[0] = args;
35658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35659 if (!SWIG_IsOK(res1)) {
35660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35661 }
35662 arg1 = reinterpret_cast< wxWindow * >(argp1);
35663 {
35664 PyThreadState* __tstate = wxPyBeginAllowThreads();
35665 result = (bool)(arg1)->Disable();
35666 wxPyEndAllowThreads(__tstate);
35667 if (PyErr_Occurred()) SWIG_fail;
35668 }
35669 {
35670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35671 }
35672 return resultobj;
35673 fail:
35674 return NULL;
35675 }
35676
35677
35678 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35679 PyObject *resultobj = 0;
35680 wxWindow *arg1 = (wxWindow *) 0 ;
35681 bool result;
35682 void *argp1 = 0 ;
35683 int res1 = 0 ;
35684 PyObject *swig_obj[1] ;
35685
35686 if (!args) SWIG_fail;
35687 swig_obj[0] = args;
35688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35689 if (!SWIG_IsOK(res1)) {
35690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35691 }
35692 arg1 = reinterpret_cast< wxWindow * >(argp1);
35693 {
35694 PyThreadState* __tstate = wxPyBeginAllowThreads();
35695 result = (bool)((wxWindow const *)arg1)->IsShown();
35696 wxPyEndAllowThreads(__tstate);
35697 if (PyErr_Occurred()) SWIG_fail;
35698 }
35699 {
35700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35701 }
35702 return resultobj;
35703 fail:
35704 return NULL;
35705 }
35706
35707
35708 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35709 PyObject *resultobj = 0;
35710 wxWindow *arg1 = (wxWindow *) 0 ;
35711 bool result;
35712 void *argp1 = 0 ;
35713 int res1 = 0 ;
35714 PyObject *swig_obj[1] ;
35715
35716 if (!args) SWIG_fail;
35717 swig_obj[0] = args;
35718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35719 if (!SWIG_IsOK(res1)) {
35720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35721 }
35722 arg1 = reinterpret_cast< wxWindow * >(argp1);
35723 {
35724 PyThreadState* __tstate = wxPyBeginAllowThreads();
35725 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35726 wxPyEndAllowThreads(__tstate);
35727 if (PyErr_Occurred()) SWIG_fail;
35728 }
35729 {
35730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35731 }
35732 return resultobj;
35733 fail:
35734 return NULL;
35735 }
35736
35737
35738 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35739 PyObject *resultobj = 0;
35740 wxWindow *arg1 = (wxWindow *) 0 ;
35741 bool result;
35742 void *argp1 = 0 ;
35743 int res1 = 0 ;
35744 PyObject *swig_obj[1] ;
35745
35746 if (!args) SWIG_fail;
35747 swig_obj[0] = args;
35748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35749 if (!SWIG_IsOK(res1)) {
35750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35751 }
35752 arg1 = reinterpret_cast< wxWindow * >(argp1);
35753 {
35754 PyThreadState* __tstate = wxPyBeginAllowThreads();
35755 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35756 wxPyEndAllowThreads(__tstate);
35757 if (PyErr_Occurred()) SWIG_fail;
35758 }
35759 {
35760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35761 }
35762 return resultobj;
35763 fail:
35764 return NULL;
35765 }
35766
35767
35768 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35769 PyObject *resultobj = 0;
35770 wxWindow *arg1 = (wxWindow *) 0 ;
35771 long arg2 ;
35772 void *argp1 = 0 ;
35773 int res1 = 0 ;
35774 long val2 ;
35775 int ecode2 = 0 ;
35776 PyObject * obj0 = 0 ;
35777 PyObject * obj1 = 0 ;
35778 char * kwnames[] = {
35779 (char *) "self",(char *) "style", NULL
35780 };
35781
35782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35784 if (!SWIG_IsOK(res1)) {
35785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35786 }
35787 arg1 = reinterpret_cast< wxWindow * >(argp1);
35788 ecode2 = SWIG_AsVal_long(obj1, &val2);
35789 if (!SWIG_IsOK(ecode2)) {
35790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35791 }
35792 arg2 = static_cast< long >(val2);
35793 {
35794 PyThreadState* __tstate = wxPyBeginAllowThreads();
35795 (arg1)->SetWindowStyleFlag(arg2);
35796 wxPyEndAllowThreads(__tstate);
35797 if (PyErr_Occurred()) SWIG_fail;
35798 }
35799 resultobj = SWIG_Py_Void();
35800 return resultobj;
35801 fail:
35802 return NULL;
35803 }
35804
35805
35806 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35807 PyObject *resultobj = 0;
35808 wxWindow *arg1 = (wxWindow *) 0 ;
35809 long result;
35810 void *argp1 = 0 ;
35811 int res1 = 0 ;
35812 PyObject *swig_obj[1] ;
35813
35814 if (!args) SWIG_fail;
35815 swig_obj[0] = args;
35816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35817 if (!SWIG_IsOK(res1)) {
35818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35819 }
35820 arg1 = reinterpret_cast< wxWindow * >(argp1);
35821 {
35822 PyThreadState* __tstate = wxPyBeginAllowThreads();
35823 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35824 wxPyEndAllowThreads(__tstate);
35825 if (PyErr_Occurred()) SWIG_fail;
35826 }
35827 resultobj = SWIG_From_long(static_cast< long >(result));
35828 return resultobj;
35829 fail:
35830 return NULL;
35831 }
35832
35833
35834 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35835 PyObject *resultobj = 0;
35836 wxWindow *arg1 = (wxWindow *) 0 ;
35837 int arg2 ;
35838 bool result;
35839 void *argp1 = 0 ;
35840 int res1 = 0 ;
35841 int val2 ;
35842 int ecode2 = 0 ;
35843 PyObject * obj0 = 0 ;
35844 PyObject * obj1 = 0 ;
35845 char * kwnames[] = {
35846 (char *) "self",(char *) "flag", NULL
35847 };
35848
35849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35851 if (!SWIG_IsOK(res1)) {
35852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35853 }
35854 arg1 = reinterpret_cast< wxWindow * >(argp1);
35855 ecode2 = SWIG_AsVal_int(obj1, &val2);
35856 if (!SWIG_IsOK(ecode2)) {
35857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35858 }
35859 arg2 = static_cast< int >(val2);
35860 {
35861 PyThreadState* __tstate = wxPyBeginAllowThreads();
35862 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35863 wxPyEndAllowThreads(__tstate);
35864 if (PyErr_Occurred()) SWIG_fail;
35865 }
35866 {
35867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35868 }
35869 return resultobj;
35870 fail:
35871 return NULL;
35872 }
35873
35874
35875 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35876 PyObject *resultobj = 0;
35877 wxWindow *arg1 = (wxWindow *) 0 ;
35878 bool result;
35879 void *argp1 = 0 ;
35880 int res1 = 0 ;
35881 PyObject *swig_obj[1] ;
35882
35883 if (!args) SWIG_fail;
35884 swig_obj[0] = args;
35885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35886 if (!SWIG_IsOK(res1)) {
35887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
35888 }
35889 arg1 = reinterpret_cast< wxWindow * >(argp1);
35890 {
35891 PyThreadState* __tstate = wxPyBeginAllowThreads();
35892 result = (bool)((wxWindow const *)arg1)->IsRetained();
35893 wxPyEndAllowThreads(__tstate);
35894 if (PyErr_Occurred()) SWIG_fail;
35895 }
35896 {
35897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35898 }
35899 return resultobj;
35900 fail:
35901 return NULL;
35902 }
35903
35904
35905 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35906 PyObject *resultobj = 0;
35907 wxWindow *arg1 = (wxWindow *) 0 ;
35908 long arg2 ;
35909 void *argp1 = 0 ;
35910 int res1 = 0 ;
35911 long val2 ;
35912 int ecode2 = 0 ;
35913 PyObject * obj0 = 0 ;
35914 PyObject * obj1 = 0 ;
35915 char * kwnames[] = {
35916 (char *) "self",(char *) "exStyle", NULL
35917 };
35918
35919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35921 if (!SWIG_IsOK(res1)) {
35922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35923 }
35924 arg1 = reinterpret_cast< wxWindow * >(argp1);
35925 ecode2 = SWIG_AsVal_long(obj1, &val2);
35926 if (!SWIG_IsOK(ecode2)) {
35927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
35928 }
35929 arg2 = static_cast< long >(val2);
35930 {
35931 PyThreadState* __tstate = wxPyBeginAllowThreads();
35932 (arg1)->SetExtraStyle(arg2);
35933 wxPyEndAllowThreads(__tstate);
35934 if (PyErr_Occurred()) SWIG_fail;
35935 }
35936 resultobj = SWIG_Py_Void();
35937 return resultobj;
35938 fail:
35939 return NULL;
35940 }
35941
35942
35943 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35944 PyObject *resultobj = 0;
35945 wxWindow *arg1 = (wxWindow *) 0 ;
35946 long result;
35947 void *argp1 = 0 ;
35948 int res1 = 0 ;
35949 PyObject *swig_obj[1] ;
35950
35951 if (!args) SWIG_fail;
35952 swig_obj[0] = args;
35953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35954 if (!SWIG_IsOK(res1)) {
35955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35956 }
35957 arg1 = reinterpret_cast< wxWindow * >(argp1);
35958 {
35959 PyThreadState* __tstate = wxPyBeginAllowThreads();
35960 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
35961 wxPyEndAllowThreads(__tstate);
35962 if (PyErr_Occurred()) SWIG_fail;
35963 }
35964 resultobj = SWIG_From_long(static_cast< long >(result));
35965 return resultobj;
35966 fail:
35967 return NULL;
35968 }
35969
35970
35971 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35972 PyObject *resultobj = 0;
35973 wxWindow *arg1 = (wxWindow *) 0 ;
35974 bool arg2 = (bool) true ;
35975 void *argp1 = 0 ;
35976 int res1 = 0 ;
35977 bool val2 ;
35978 int ecode2 = 0 ;
35979 PyObject * obj0 = 0 ;
35980 PyObject * obj1 = 0 ;
35981 char * kwnames[] = {
35982 (char *) "self",(char *) "modal", NULL
35983 };
35984
35985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
35986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35987 if (!SWIG_IsOK(res1)) {
35988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
35989 }
35990 arg1 = reinterpret_cast< wxWindow * >(argp1);
35991 if (obj1) {
35992 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35993 if (!SWIG_IsOK(ecode2)) {
35994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
35995 }
35996 arg2 = static_cast< bool >(val2);
35997 }
35998 {
35999 PyThreadState* __tstate = wxPyBeginAllowThreads();
36000 (arg1)->MakeModal(arg2);
36001 wxPyEndAllowThreads(__tstate);
36002 if (PyErr_Occurred()) SWIG_fail;
36003 }
36004 resultobj = SWIG_Py_Void();
36005 return resultobj;
36006 fail:
36007 return NULL;
36008 }
36009
36010
36011 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36012 PyObject *resultobj = 0;
36013 wxWindow *arg1 = (wxWindow *) 0 ;
36014 bool arg2 ;
36015 void *argp1 = 0 ;
36016 int res1 = 0 ;
36017 bool val2 ;
36018 int ecode2 = 0 ;
36019 PyObject * obj0 = 0 ;
36020 PyObject * obj1 = 0 ;
36021 char * kwnames[] = {
36022 (char *) "self",(char *) "enableTheme", NULL
36023 };
36024
36025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
36026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36027 if (!SWIG_IsOK(res1)) {
36028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
36029 }
36030 arg1 = reinterpret_cast< wxWindow * >(argp1);
36031 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36032 if (!SWIG_IsOK(ecode2)) {
36033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36034 }
36035 arg2 = static_cast< bool >(val2);
36036 {
36037 PyThreadState* __tstate = wxPyBeginAllowThreads();
36038 (arg1)->SetThemeEnabled(arg2);
36039 wxPyEndAllowThreads(__tstate);
36040 if (PyErr_Occurred()) SWIG_fail;
36041 }
36042 resultobj = SWIG_Py_Void();
36043 return resultobj;
36044 fail:
36045 return NULL;
36046 }
36047
36048
36049 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36050 PyObject *resultobj = 0;
36051 wxWindow *arg1 = (wxWindow *) 0 ;
36052 bool result;
36053 void *argp1 = 0 ;
36054 int res1 = 0 ;
36055 PyObject *swig_obj[1] ;
36056
36057 if (!args) SWIG_fail;
36058 swig_obj[0] = args;
36059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36060 if (!SWIG_IsOK(res1)) {
36061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36062 }
36063 arg1 = reinterpret_cast< wxWindow * >(argp1);
36064 {
36065 PyThreadState* __tstate = wxPyBeginAllowThreads();
36066 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36067 wxPyEndAllowThreads(__tstate);
36068 if (PyErr_Occurred()) SWIG_fail;
36069 }
36070 {
36071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36072 }
36073 return resultobj;
36074 fail:
36075 return NULL;
36076 }
36077
36078
36079 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36080 PyObject *resultobj = 0;
36081 wxWindow *arg1 = (wxWindow *) 0 ;
36082 void *argp1 = 0 ;
36083 int res1 = 0 ;
36084 PyObject *swig_obj[1] ;
36085
36086 if (!args) SWIG_fail;
36087 swig_obj[0] = args;
36088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36089 if (!SWIG_IsOK(res1)) {
36090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36091 }
36092 arg1 = reinterpret_cast< wxWindow * >(argp1);
36093 {
36094 PyThreadState* __tstate = wxPyBeginAllowThreads();
36095 (arg1)->SetFocus();
36096 wxPyEndAllowThreads(__tstate);
36097 if (PyErr_Occurred()) SWIG_fail;
36098 }
36099 resultobj = SWIG_Py_Void();
36100 return resultobj;
36101 fail:
36102 return NULL;
36103 }
36104
36105
36106 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36107 PyObject *resultobj = 0;
36108 wxWindow *arg1 = (wxWindow *) 0 ;
36109 void *argp1 = 0 ;
36110 int res1 = 0 ;
36111 PyObject *swig_obj[1] ;
36112
36113 if (!args) SWIG_fail;
36114 swig_obj[0] = args;
36115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36116 if (!SWIG_IsOK(res1)) {
36117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36118 }
36119 arg1 = reinterpret_cast< wxWindow * >(argp1);
36120 {
36121 PyThreadState* __tstate = wxPyBeginAllowThreads();
36122 (arg1)->SetFocusFromKbd();
36123 wxPyEndAllowThreads(__tstate);
36124 if (PyErr_Occurred()) SWIG_fail;
36125 }
36126 resultobj = SWIG_Py_Void();
36127 return resultobj;
36128 fail:
36129 return NULL;
36130 }
36131
36132
36133 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36134 PyObject *resultobj = 0;
36135 wxWindow *result = 0 ;
36136
36137 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36138 {
36139 if (!wxPyCheckForApp()) SWIG_fail;
36140 PyThreadState* __tstate = wxPyBeginAllowThreads();
36141 result = (wxWindow *)wxWindow::FindFocus();
36142 wxPyEndAllowThreads(__tstate);
36143 if (PyErr_Occurred()) SWIG_fail;
36144 }
36145 {
36146 resultobj = wxPyMake_wxObject(result, 0);
36147 }
36148 return resultobj;
36149 fail:
36150 return NULL;
36151 }
36152
36153
36154 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36155 PyObject *resultobj = 0;
36156 wxWindow *arg1 = (wxWindow *) 0 ;
36157 bool result;
36158 void *argp1 = 0 ;
36159 int res1 = 0 ;
36160 PyObject *swig_obj[1] ;
36161
36162 if (!args) SWIG_fail;
36163 swig_obj[0] = args;
36164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36165 if (!SWIG_IsOK(res1)) {
36166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36167 }
36168 arg1 = reinterpret_cast< wxWindow * >(argp1);
36169 {
36170 PyThreadState* __tstate = wxPyBeginAllowThreads();
36171 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36172 wxPyEndAllowThreads(__tstate);
36173 if (PyErr_Occurred()) SWIG_fail;
36174 }
36175 {
36176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36177 }
36178 return resultobj;
36179 fail:
36180 return NULL;
36181 }
36182
36183
36184 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36185 PyObject *resultobj = 0;
36186 wxWindow *arg1 = (wxWindow *) 0 ;
36187 bool result;
36188 void *argp1 = 0 ;
36189 int res1 = 0 ;
36190 PyObject *swig_obj[1] ;
36191
36192 if (!args) SWIG_fail;
36193 swig_obj[0] = args;
36194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36195 if (!SWIG_IsOK(res1)) {
36196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36197 }
36198 arg1 = reinterpret_cast< wxWindow * >(argp1);
36199 {
36200 PyThreadState* __tstate = wxPyBeginAllowThreads();
36201 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36202 wxPyEndAllowThreads(__tstate);
36203 if (PyErr_Occurred()) SWIG_fail;
36204 }
36205 {
36206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36207 }
36208 return resultobj;
36209 fail:
36210 return NULL;
36211 }
36212
36213
36214 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36215 PyObject *resultobj = 0;
36216 wxWindow *arg1 = (wxWindow *) 0 ;
36217 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36218 bool result;
36219 void *argp1 = 0 ;
36220 int res1 = 0 ;
36221 int val2 ;
36222 int ecode2 = 0 ;
36223 PyObject * obj0 = 0 ;
36224 PyObject * obj1 = 0 ;
36225 char * kwnames[] = {
36226 (char *) "self",(char *) "flags", NULL
36227 };
36228
36229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36231 if (!SWIG_IsOK(res1)) {
36232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36233 }
36234 arg1 = reinterpret_cast< wxWindow * >(argp1);
36235 if (obj1) {
36236 ecode2 = SWIG_AsVal_int(obj1, &val2);
36237 if (!SWIG_IsOK(ecode2)) {
36238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36239 }
36240 arg2 = static_cast< int >(val2);
36241 }
36242 {
36243 PyThreadState* __tstate = wxPyBeginAllowThreads();
36244 result = (bool)(arg1)->Navigate(arg2);
36245 wxPyEndAllowThreads(__tstate);
36246 if (PyErr_Occurred()) SWIG_fail;
36247 }
36248 {
36249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36250 }
36251 return resultobj;
36252 fail:
36253 return NULL;
36254 }
36255
36256
36257 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36258 PyObject *resultobj = 0;
36259 wxWindow *arg1 = (wxWindow *) 0 ;
36260 wxWindow *arg2 = (wxWindow *) 0 ;
36261 void *argp1 = 0 ;
36262 int res1 = 0 ;
36263 void *argp2 = 0 ;
36264 int res2 = 0 ;
36265 PyObject * obj0 = 0 ;
36266 PyObject * obj1 = 0 ;
36267 char * kwnames[] = {
36268 (char *) "self",(char *) "win", NULL
36269 };
36270
36271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36273 if (!SWIG_IsOK(res1)) {
36274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36275 }
36276 arg1 = reinterpret_cast< wxWindow * >(argp1);
36277 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36278 if (!SWIG_IsOK(res2)) {
36279 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36280 }
36281 arg2 = reinterpret_cast< wxWindow * >(argp2);
36282 {
36283 PyThreadState* __tstate = wxPyBeginAllowThreads();
36284 (arg1)->MoveAfterInTabOrder(arg2);
36285 wxPyEndAllowThreads(__tstate);
36286 if (PyErr_Occurred()) SWIG_fail;
36287 }
36288 resultobj = SWIG_Py_Void();
36289 return resultobj;
36290 fail:
36291 return NULL;
36292 }
36293
36294
36295 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36296 PyObject *resultobj = 0;
36297 wxWindow *arg1 = (wxWindow *) 0 ;
36298 wxWindow *arg2 = (wxWindow *) 0 ;
36299 void *argp1 = 0 ;
36300 int res1 = 0 ;
36301 void *argp2 = 0 ;
36302 int res2 = 0 ;
36303 PyObject * obj0 = 0 ;
36304 PyObject * obj1 = 0 ;
36305 char * kwnames[] = {
36306 (char *) "self",(char *) "win", NULL
36307 };
36308
36309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36311 if (!SWIG_IsOK(res1)) {
36312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36313 }
36314 arg1 = reinterpret_cast< wxWindow * >(argp1);
36315 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36316 if (!SWIG_IsOK(res2)) {
36317 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36318 }
36319 arg2 = reinterpret_cast< wxWindow * >(argp2);
36320 {
36321 PyThreadState* __tstate = wxPyBeginAllowThreads();
36322 (arg1)->MoveBeforeInTabOrder(arg2);
36323 wxPyEndAllowThreads(__tstate);
36324 if (PyErr_Occurred()) SWIG_fail;
36325 }
36326 resultobj = SWIG_Py_Void();
36327 return resultobj;
36328 fail:
36329 return NULL;
36330 }
36331
36332
36333 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36334 PyObject *resultobj = 0;
36335 wxWindow *arg1 = (wxWindow *) 0 ;
36336 PyObject *result = 0 ;
36337 void *argp1 = 0 ;
36338 int res1 = 0 ;
36339 PyObject *swig_obj[1] ;
36340
36341 if (!args) SWIG_fail;
36342 swig_obj[0] = args;
36343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36344 if (!SWIG_IsOK(res1)) {
36345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36346 }
36347 arg1 = reinterpret_cast< wxWindow * >(argp1);
36348 {
36349 PyThreadState* __tstate = wxPyBeginAllowThreads();
36350 result = (PyObject *)wxWindow_GetChildren(arg1);
36351 wxPyEndAllowThreads(__tstate);
36352 if (PyErr_Occurred()) SWIG_fail;
36353 }
36354 resultobj = result;
36355 return resultobj;
36356 fail:
36357 return NULL;
36358 }
36359
36360
36361 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36362 PyObject *resultobj = 0;
36363 wxWindow *arg1 = (wxWindow *) 0 ;
36364 wxWindow *result = 0 ;
36365 void *argp1 = 0 ;
36366 int res1 = 0 ;
36367 PyObject *swig_obj[1] ;
36368
36369 if (!args) SWIG_fail;
36370 swig_obj[0] = args;
36371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36372 if (!SWIG_IsOK(res1)) {
36373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36374 }
36375 arg1 = reinterpret_cast< wxWindow * >(argp1);
36376 {
36377 PyThreadState* __tstate = wxPyBeginAllowThreads();
36378 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36379 wxPyEndAllowThreads(__tstate);
36380 if (PyErr_Occurred()) SWIG_fail;
36381 }
36382 {
36383 resultobj = wxPyMake_wxObject(result, 0);
36384 }
36385 return resultobj;
36386 fail:
36387 return NULL;
36388 }
36389
36390
36391 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36392 PyObject *resultobj = 0;
36393 wxWindow *arg1 = (wxWindow *) 0 ;
36394 wxWindow *result = 0 ;
36395 void *argp1 = 0 ;
36396 int res1 = 0 ;
36397 PyObject *swig_obj[1] ;
36398
36399 if (!args) SWIG_fail;
36400 swig_obj[0] = args;
36401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36402 if (!SWIG_IsOK(res1)) {
36403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36404 }
36405 arg1 = reinterpret_cast< wxWindow * >(argp1);
36406 {
36407 PyThreadState* __tstate = wxPyBeginAllowThreads();
36408 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36409 wxPyEndAllowThreads(__tstate);
36410 if (PyErr_Occurred()) SWIG_fail;
36411 }
36412 {
36413 resultobj = wxPyMake_wxObject(result, 0);
36414 }
36415 return resultobj;
36416 fail:
36417 return NULL;
36418 }
36419
36420
36421 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36422 PyObject *resultobj = 0;
36423 wxWindow *arg1 = (wxWindow *) 0 ;
36424 bool result;
36425 void *argp1 = 0 ;
36426 int res1 = 0 ;
36427 PyObject *swig_obj[1] ;
36428
36429 if (!args) SWIG_fail;
36430 swig_obj[0] = args;
36431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36432 if (!SWIG_IsOK(res1)) {
36433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36434 }
36435 arg1 = reinterpret_cast< wxWindow * >(argp1);
36436 {
36437 PyThreadState* __tstate = wxPyBeginAllowThreads();
36438 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36439 wxPyEndAllowThreads(__tstate);
36440 if (PyErr_Occurred()) SWIG_fail;
36441 }
36442 {
36443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36444 }
36445 return resultobj;
36446 fail:
36447 return NULL;
36448 }
36449
36450
36451 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36452 PyObject *resultobj = 0;
36453 wxWindow *arg1 = (wxWindow *) 0 ;
36454 wxWindow *arg2 = (wxWindow *) 0 ;
36455 bool result;
36456 void *argp1 = 0 ;
36457 int res1 = 0 ;
36458 void *argp2 = 0 ;
36459 int res2 = 0 ;
36460 PyObject * obj0 = 0 ;
36461 PyObject * obj1 = 0 ;
36462 char * kwnames[] = {
36463 (char *) "self",(char *) "newParent", NULL
36464 };
36465
36466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36468 if (!SWIG_IsOK(res1)) {
36469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36470 }
36471 arg1 = reinterpret_cast< wxWindow * >(argp1);
36472 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36473 if (!SWIG_IsOK(res2)) {
36474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36475 }
36476 arg2 = reinterpret_cast< wxWindow * >(argp2);
36477 {
36478 PyThreadState* __tstate = wxPyBeginAllowThreads();
36479 result = (bool)(arg1)->Reparent(arg2);
36480 wxPyEndAllowThreads(__tstate);
36481 if (PyErr_Occurred()) SWIG_fail;
36482 }
36483 {
36484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36485 }
36486 return resultobj;
36487 fail:
36488 return NULL;
36489 }
36490
36491
36492 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36493 PyObject *resultobj = 0;
36494 wxWindow *arg1 = (wxWindow *) 0 ;
36495 wxWindow *arg2 = (wxWindow *) 0 ;
36496 void *argp1 = 0 ;
36497 int res1 = 0 ;
36498 void *argp2 = 0 ;
36499 int res2 = 0 ;
36500 PyObject * obj0 = 0 ;
36501 PyObject * obj1 = 0 ;
36502 char * kwnames[] = {
36503 (char *) "self",(char *) "child", NULL
36504 };
36505
36506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36508 if (!SWIG_IsOK(res1)) {
36509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36510 }
36511 arg1 = reinterpret_cast< wxWindow * >(argp1);
36512 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36513 if (!SWIG_IsOK(res2)) {
36514 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36515 }
36516 arg2 = reinterpret_cast< wxWindow * >(argp2);
36517 {
36518 PyThreadState* __tstate = wxPyBeginAllowThreads();
36519 (arg1)->AddChild(arg2);
36520 wxPyEndAllowThreads(__tstate);
36521 if (PyErr_Occurred()) SWIG_fail;
36522 }
36523 resultobj = SWIG_Py_Void();
36524 return resultobj;
36525 fail:
36526 return NULL;
36527 }
36528
36529
36530 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36531 PyObject *resultobj = 0;
36532 wxWindow *arg1 = (wxWindow *) 0 ;
36533 wxWindow *arg2 = (wxWindow *) 0 ;
36534 void *argp1 = 0 ;
36535 int res1 = 0 ;
36536 void *argp2 = 0 ;
36537 int res2 = 0 ;
36538 PyObject * obj0 = 0 ;
36539 PyObject * obj1 = 0 ;
36540 char * kwnames[] = {
36541 (char *) "self",(char *) "child", NULL
36542 };
36543
36544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36546 if (!SWIG_IsOK(res1)) {
36547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36548 }
36549 arg1 = reinterpret_cast< wxWindow * >(argp1);
36550 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36551 if (!SWIG_IsOK(res2)) {
36552 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36553 }
36554 arg2 = reinterpret_cast< wxWindow * >(argp2);
36555 {
36556 PyThreadState* __tstate = wxPyBeginAllowThreads();
36557 (arg1)->RemoveChild(arg2);
36558 wxPyEndAllowThreads(__tstate);
36559 if (PyErr_Occurred()) SWIG_fail;
36560 }
36561 resultobj = SWIG_Py_Void();
36562 return resultobj;
36563 fail:
36564 return NULL;
36565 }
36566
36567
36568 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36569 PyObject *resultobj = 0;
36570 wxWindow *arg1 = (wxWindow *) 0 ;
36571 bool arg2 ;
36572 void *argp1 = 0 ;
36573 int res1 = 0 ;
36574 bool val2 ;
36575 int ecode2 = 0 ;
36576 PyObject * obj0 = 0 ;
36577 PyObject * obj1 = 0 ;
36578 char * kwnames[] = {
36579 (char *) "self",(char *) "on", NULL
36580 };
36581
36582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36584 if (!SWIG_IsOK(res1)) {
36585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36586 }
36587 arg1 = reinterpret_cast< wxWindow * >(argp1);
36588 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36589 if (!SWIG_IsOK(ecode2)) {
36590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36591 }
36592 arg2 = static_cast< bool >(val2);
36593 {
36594 PyThreadState* __tstate = wxPyBeginAllowThreads();
36595 wxWindow_SetDoubleBuffered(arg1,arg2);
36596 wxPyEndAllowThreads(__tstate);
36597 if (PyErr_Occurred()) SWIG_fail;
36598 }
36599 resultobj = SWIG_Py_Void();
36600 return resultobj;
36601 fail:
36602 return NULL;
36603 }
36604
36605
36606 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36607 PyObject *resultobj = 0;
36608 wxWindow *arg1 = (wxWindow *) 0 ;
36609 long arg2 ;
36610 wxWindow *result = 0 ;
36611 void *argp1 = 0 ;
36612 int res1 = 0 ;
36613 long val2 ;
36614 int ecode2 = 0 ;
36615 PyObject * obj0 = 0 ;
36616 PyObject * obj1 = 0 ;
36617 char * kwnames[] = {
36618 (char *) "self",(char *) "winid", NULL
36619 };
36620
36621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36623 if (!SWIG_IsOK(res1)) {
36624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36625 }
36626 arg1 = reinterpret_cast< wxWindow * >(argp1);
36627 ecode2 = SWIG_AsVal_long(obj1, &val2);
36628 if (!SWIG_IsOK(ecode2)) {
36629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36630 }
36631 arg2 = static_cast< long >(val2);
36632 {
36633 PyThreadState* __tstate = wxPyBeginAllowThreads();
36634 result = (wxWindow *)(arg1)->FindWindow(arg2);
36635 wxPyEndAllowThreads(__tstate);
36636 if (PyErr_Occurred()) SWIG_fail;
36637 }
36638 {
36639 resultobj = wxPyMake_wxObject(result, 0);
36640 }
36641 return resultobj;
36642 fail:
36643 return NULL;
36644 }
36645
36646
36647 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36648 PyObject *resultobj = 0;
36649 wxWindow *arg1 = (wxWindow *) 0 ;
36650 wxString *arg2 = 0 ;
36651 wxWindow *result = 0 ;
36652 void *argp1 = 0 ;
36653 int res1 = 0 ;
36654 bool temp2 = false ;
36655 PyObject * obj0 = 0 ;
36656 PyObject * obj1 = 0 ;
36657 char * kwnames[] = {
36658 (char *) "self",(char *) "name", NULL
36659 };
36660
36661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36663 if (!SWIG_IsOK(res1)) {
36664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36665 }
36666 arg1 = reinterpret_cast< wxWindow * >(argp1);
36667 {
36668 arg2 = wxString_in_helper(obj1);
36669 if (arg2 == NULL) SWIG_fail;
36670 temp2 = true;
36671 }
36672 {
36673 PyThreadState* __tstate = wxPyBeginAllowThreads();
36674 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36675 wxPyEndAllowThreads(__tstate);
36676 if (PyErr_Occurred()) SWIG_fail;
36677 }
36678 {
36679 resultobj = wxPyMake_wxObject(result, 0);
36680 }
36681 {
36682 if (temp2)
36683 delete arg2;
36684 }
36685 return resultobj;
36686 fail:
36687 {
36688 if (temp2)
36689 delete arg2;
36690 }
36691 return NULL;
36692 }
36693
36694
36695 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36696 PyObject *resultobj = 0;
36697 wxWindow *arg1 = (wxWindow *) 0 ;
36698 wxEvtHandler *result = 0 ;
36699 void *argp1 = 0 ;
36700 int res1 = 0 ;
36701 PyObject *swig_obj[1] ;
36702
36703 if (!args) SWIG_fail;
36704 swig_obj[0] = args;
36705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36706 if (!SWIG_IsOK(res1)) {
36707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36708 }
36709 arg1 = reinterpret_cast< wxWindow * >(argp1);
36710 {
36711 PyThreadState* __tstate = wxPyBeginAllowThreads();
36712 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36713 wxPyEndAllowThreads(__tstate);
36714 if (PyErr_Occurred()) SWIG_fail;
36715 }
36716 {
36717 resultobj = wxPyMake_wxObject(result, 0);
36718 }
36719 return resultobj;
36720 fail:
36721 return NULL;
36722 }
36723
36724
36725 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36726 PyObject *resultobj = 0;
36727 wxWindow *arg1 = (wxWindow *) 0 ;
36728 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36729 void *argp1 = 0 ;
36730 int res1 = 0 ;
36731 void *argp2 = 0 ;
36732 int res2 = 0 ;
36733 PyObject * obj0 = 0 ;
36734 PyObject * obj1 = 0 ;
36735 char * kwnames[] = {
36736 (char *) "self",(char *) "handler", NULL
36737 };
36738
36739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36741 if (!SWIG_IsOK(res1)) {
36742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36743 }
36744 arg1 = reinterpret_cast< wxWindow * >(argp1);
36745 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36746 if (!SWIG_IsOK(res2)) {
36747 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36748 }
36749 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36750 {
36751 PyThreadState* __tstate = wxPyBeginAllowThreads();
36752 (arg1)->SetEventHandler(arg2);
36753 wxPyEndAllowThreads(__tstate);
36754 if (PyErr_Occurred()) SWIG_fail;
36755 }
36756 resultobj = SWIG_Py_Void();
36757 return resultobj;
36758 fail:
36759 return NULL;
36760 }
36761
36762
36763 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36764 PyObject *resultobj = 0;
36765 wxWindow *arg1 = (wxWindow *) 0 ;
36766 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36767 void *argp1 = 0 ;
36768 int res1 = 0 ;
36769 void *argp2 = 0 ;
36770 int res2 = 0 ;
36771 PyObject * obj0 = 0 ;
36772 PyObject * obj1 = 0 ;
36773 char * kwnames[] = {
36774 (char *) "self",(char *) "handler", NULL
36775 };
36776
36777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36779 if (!SWIG_IsOK(res1)) {
36780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36781 }
36782 arg1 = reinterpret_cast< wxWindow * >(argp1);
36783 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36784 if (!SWIG_IsOK(res2)) {
36785 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36786 }
36787 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36788 {
36789 PyThreadState* __tstate = wxPyBeginAllowThreads();
36790 (arg1)->PushEventHandler(arg2);
36791 wxPyEndAllowThreads(__tstate);
36792 if (PyErr_Occurred()) SWIG_fail;
36793 }
36794 resultobj = SWIG_Py_Void();
36795 return resultobj;
36796 fail:
36797 return NULL;
36798 }
36799
36800
36801 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36802 PyObject *resultobj = 0;
36803 wxWindow *arg1 = (wxWindow *) 0 ;
36804 bool arg2 = (bool) false ;
36805 wxEvtHandler *result = 0 ;
36806 void *argp1 = 0 ;
36807 int res1 = 0 ;
36808 bool val2 ;
36809 int ecode2 = 0 ;
36810 PyObject * obj0 = 0 ;
36811 PyObject * obj1 = 0 ;
36812 char * kwnames[] = {
36813 (char *) "self",(char *) "deleteHandler", NULL
36814 };
36815
36816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36818 if (!SWIG_IsOK(res1)) {
36819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36820 }
36821 arg1 = reinterpret_cast< wxWindow * >(argp1);
36822 if (obj1) {
36823 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36824 if (!SWIG_IsOK(ecode2)) {
36825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
36826 }
36827 arg2 = static_cast< bool >(val2);
36828 }
36829 {
36830 PyThreadState* __tstate = wxPyBeginAllowThreads();
36831 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
36832 wxPyEndAllowThreads(__tstate);
36833 if (PyErr_Occurred()) SWIG_fail;
36834 }
36835 {
36836 resultobj = wxPyMake_wxObject(result, 0);
36837 }
36838 return resultobj;
36839 fail:
36840 return NULL;
36841 }
36842
36843
36844 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36845 PyObject *resultobj = 0;
36846 wxWindow *arg1 = (wxWindow *) 0 ;
36847 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36848 bool result;
36849 void *argp1 = 0 ;
36850 int res1 = 0 ;
36851 void *argp2 = 0 ;
36852 int res2 = 0 ;
36853 PyObject * obj0 = 0 ;
36854 PyObject * obj1 = 0 ;
36855 char * kwnames[] = {
36856 (char *) "self",(char *) "handler", NULL
36857 };
36858
36859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36861 if (!SWIG_IsOK(res1)) {
36862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36863 }
36864 arg1 = reinterpret_cast< wxWindow * >(argp1);
36865 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36866 if (!SWIG_IsOK(res2)) {
36867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36868 }
36869 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36870 {
36871 PyThreadState* __tstate = wxPyBeginAllowThreads();
36872 result = (bool)(arg1)->RemoveEventHandler(arg2);
36873 wxPyEndAllowThreads(__tstate);
36874 if (PyErr_Occurred()) SWIG_fail;
36875 }
36876 {
36877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36878 }
36879 return resultobj;
36880 fail:
36881 return NULL;
36882 }
36883
36884
36885 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36886 PyObject *resultobj = 0;
36887 wxWindow *arg1 = (wxWindow *) 0 ;
36888 wxValidator *arg2 = 0 ;
36889 void *argp1 = 0 ;
36890 int res1 = 0 ;
36891 void *argp2 = 0 ;
36892 int res2 = 0 ;
36893 PyObject * obj0 = 0 ;
36894 PyObject * obj1 = 0 ;
36895 char * kwnames[] = {
36896 (char *) "self",(char *) "validator", NULL
36897 };
36898
36899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
36900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36901 if (!SWIG_IsOK(res1)) {
36902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36903 }
36904 arg1 = reinterpret_cast< wxWindow * >(argp1);
36905 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
36906 if (!SWIG_IsOK(res2)) {
36907 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36908 }
36909 if (!argp2) {
36910 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36911 }
36912 arg2 = reinterpret_cast< wxValidator * >(argp2);
36913 {
36914 PyThreadState* __tstate = wxPyBeginAllowThreads();
36915 (arg1)->SetValidator((wxValidator const &)*arg2);
36916 wxPyEndAllowThreads(__tstate);
36917 if (PyErr_Occurred()) SWIG_fail;
36918 }
36919 resultobj = SWIG_Py_Void();
36920 return resultobj;
36921 fail:
36922 return NULL;
36923 }
36924
36925
36926 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36927 PyObject *resultobj = 0;
36928 wxWindow *arg1 = (wxWindow *) 0 ;
36929 wxValidator *result = 0 ;
36930 void *argp1 = 0 ;
36931 int res1 = 0 ;
36932 PyObject *swig_obj[1] ;
36933
36934 if (!args) SWIG_fail;
36935 swig_obj[0] = args;
36936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36937 if (!SWIG_IsOK(res1)) {
36938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36939 }
36940 arg1 = reinterpret_cast< wxWindow * >(argp1);
36941 {
36942 PyThreadState* __tstate = wxPyBeginAllowThreads();
36943 result = (wxValidator *)(arg1)->GetValidator();
36944 wxPyEndAllowThreads(__tstate);
36945 if (PyErr_Occurred()) SWIG_fail;
36946 }
36947 {
36948 resultobj = wxPyMake_wxObject(result, (bool)0);
36949 }
36950 return resultobj;
36951 fail:
36952 return NULL;
36953 }
36954
36955
36956 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36957 PyObject *resultobj = 0;
36958 wxWindow *arg1 = (wxWindow *) 0 ;
36959 bool result;
36960 void *argp1 = 0 ;
36961 int res1 = 0 ;
36962 PyObject *swig_obj[1] ;
36963
36964 if (!args) SWIG_fail;
36965 swig_obj[0] = args;
36966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36967 if (!SWIG_IsOK(res1)) {
36968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
36969 }
36970 arg1 = reinterpret_cast< wxWindow * >(argp1);
36971 {
36972 PyThreadState* __tstate = wxPyBeginAllowThreads();
36973 result = (bool)(arg1)->Validate();
36974 wxPyEndAllowThreads(__tstate);
36975 if (PyErr_Occurred()) SWIG_fail;
36976 }
36977 {
36978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36979 }
36980 return resultobj;
36981 fail:
36982 return NULL;
36983 }
36984
36985
36986 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36987 PyObject *resultobj = 0;
36988 wxWindow *arg1 = (wxWindow *) 0 ;
36989 bool result;
36990 void *argp1 = 0 ;
36991 int res1 = 0 ;
36992 PyObject *swig_obj[1] ;
36993
36994 if (!args) SWIG_fail;
36995 swig_obj[0] = args;
36996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36997 if (!SWIG_IsOK(res1)) {
36998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36999 }
37000 arg1 = reinterpret_cast< wxWindow * >(argp1);
37001 {
37002 PyThreadState* __tstate = wxPyBeginAllowThreads();
37003 result = (bool)(arg1)->TransferDataToWindow();
37004 wxPyEndAllowThreads(__tstate);
37005 if (PyErr_Occurred()) SWIG_fail;
37006 }
37007 {
37008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37009 }
37010 return resultobj;
37011 fail:
37012 return NULL;
37013 }
37014
37015
37016 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37017 PyObject *resultobj = 0;
37018 wxWindow *arg1 = (wxWindow *) 0 ;
37019 bool result;
37020 void *argp1 = 0 ;
37021 int res1 = 0 ;
37022 PyObject *swig_obj[1] ;
37023
37024 if (!args) SWIG_fail;
37025 swig_obj[0] = args;
37026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37027 if (!SWIG_IsOK(res1)) {
37028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37029 }
37030 arg1 = reinterpret_cast< wxWindow * >(argp1);
37031 {
37032 PyThreadState* __tstate = wxPyBeginAllowThreads();
37033 result = (bool)(arg1)->TransferDataFromWindow();
37034 wxPyEndAllowThreads(__tstate);
37035 if (PyErr_Occurred()) SWIG_fail;
37036 }
37037 {
37038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37039 }
37040 return resultobj;
37041 fail:
37042 return NULL;
37043 }
37044
37045
37046 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37047 PyObject *resultobj = 0;
37048 wxWindow *arg1 = (wxWindow *) 0 ;
37049 void *argp1 = 0 ;
37050 int res1 = 0 ;
37051 PyObject *swig_obj[1] ;
37052
37053 if (!args) SWIG_fail;
37054 swig_obj[0] = args;
37055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37056 if (!SWIG_IsOK(res1)) {
37057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37058 }
37059 arg1 = reinterpret_cast< wxWindow * >(argp1);
37060 {
37061 PyThreadState* __tstate = wxPyBeginAllowThreads();
37062 (arg1)->InitDialog();
37063 wxPyEndAllowThreads(__tstate);
37064 if (PyErr_Occurred()) SWIG_fail;
37065 }
37066 resultobj = SWIG_Py_Void();
37067 return resultobj;
37068 fail:
37069 return NULL;
37070 }
37071
37072
37073 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37074 PyObject *resultobj = 0;
37075 wxWindow *arg1 = (wxWindow *) 0 ;
37076 wxAcceleratorTable *arg2 = 0 ;
37077 void *argp1 = 0 ;
37078 int res1 = 0 ;
37079 void *argp2 = 0 ;
37080 int res2 = 0 ;
37081 PyObject * obj0 = 0 ;
37082 PyObject * obj1 = 0 ;
37083 char * kwnames[] = {
37084 (char *) "self",(char *) "accel", NULL
37085 };
37086
37087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37089 if (!SWIG_IsOK(res1)) {
37090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37091 }
37092 arg1 = reinterpret_cast< wxWindow * >(argp1);
37093 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37094 if (!SWIG_IsOK(res2)) {
37095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37096 }
37097 if (!argp2) {
37098 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37099 }
37100 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37101 {
37102 PyThreadState* __tstate = wxPyBeginAllowThreads();
37103 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37104 wxPyEndAllowThreads(__tstate);
37105 if (PyErr_Occurred()) SWIG_fail;
37106 }
37107 resultobj = SWIG_Py_Void();
37108 return resultobj;
37109 fail:
37110 return NULL;
37111 }
37112
37113
37114 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37115 PyObject *resultobj = 0;
37116 wxWindow *arg1 = (wxWindow *) 0 ;
37117 wxAcceleratorTable *result = 0 ;
37118 void *argp1 = 0 ;
37119 int res1 = 0 ;
37120 PyObject *swig_obj[1] ;
37121
37122 if (!args) SWIG_fail;
37123 swig_obj[0] = args;
37124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37125 if (!SWIG_IsOK(res1)) {
37126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37127 }
37128 arg1 = reinterpret_cast< wxWindow * >(argp1);
37129 {
37130 PyThreadState* __tstate = wxPyBeginAllowThreads();
37131 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37132 wxPyEndAllowThreads(__tstate);
37133 if (PyErr_Occurred()) SWIG_fail;
37134 }
37135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37136 return resultobj;
37137 fail:
37138 return NULL;
37139 }
37140
37141
37142 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37143 PyObject *resultobj = 0;
37144 wxWindow *arg1 = (wxWindow *) 0 ;
37145 int arg2 ;
37146 int arg3 ;
37147 int arg4 ;
37148 bool result;
37149 void *argp1 = 0 ;
37150 int res1 = 0 ;
37151 int val2 ;
37152 int ecode2 = 0 ;
37153 int val3 ;
37154 int ecode3 = 0 ;
37155 int val4 ;
37156 int ecode4 = 0 ;
37157 PyObject * obj0 = 0 ;
37158 PyObject * obj1 = 0 ;
37159 PyObject * obj2 = 0 ;
37160 PyObject * obj3 = 0 ;
37161 char * kwnames[] = {
37162 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37163 };
37164
37165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37167 if (!SWIG_IsOK(res1)) {
37168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37169 }
37170 arg1 = reinterpret_cast< wxWindow * >(argp1);
37171 ecode2 = SWIG_AsVal_int(obj1, &val2);
37172 if (!SWIG_IsOK(ecode2)) {
37173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37174 }
37175 arg2 = static_cast< int >(val2);
37176 ecode3 = SWIG_AsVal_int(obj2, &val3);
37177 if (!SWIG_IsOK(ecode3)) {
37178 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37179 }
37180 arg3 = static_cast< int >(val3);
37181 ecode4 = SWIG_AsVal_int(obj3, &val4);
37182 if (!SWIG_IsOK(ecode4)) {
37183 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37184 }
37185 arg4 = static_cast< int >(val4);
37186 {
37187 PyThreadState* __tstate = wxPyBeginAllowThreads();
37188 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37189 wxPyEndAllowThreads(__tstate);
37190 if (PyErr_Occurred()) SWIG_fail;
37191 }
37192 {
37193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37194 }
37195 return resultobj;
37196 fail:
37197 return NULL;
37198 }
37199
37200
37201 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37202 PyObject *resultobj = 0;
37203 wxWindow *arg1 = (wxWindow *) 0 ;
37204 int arg2 ;
37205 bool result;
37206 void *argp1 = 0 ;
37207 int res1 = 0 ;
37208 int val2 ;
37209 int ecode2 = 0 ;
37210 PyObject * obj0 = 0 ;
37211 PyObject * obj1 = 0 ;
37212 char * kwnames[] = {
37213 (char *) "self",(char *) "hotkeyId", NULL
37214 };
37215
37216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37218 if (!SWIG_IsOK(res1)) {
37219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37220 }
37221 arg1 = reinterpret_cast< wxWindow * >(argp1);
37222 ecode2 = SWIG_AsVal_int(obj1, &val2);
37223 if (!SWIG_IsOK(ecode2)) {
37224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37225 }
37226 arg2 = static_cast< int >(val2);
37227 {
37228 PyThreadState* __tstate = wxPyBeginAllowThreads();
37229 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37230 wxPyEndAllowThreads(__tstate);
37231 if (PyErr_Occurred()) SWIG_fail;
37232 }
37233 {
37234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37235 }
37236 return resultobj;
37237 fail:
37238 return NULL;
37239 }
37240
37241
37242 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37243 PyObject *resultobj = 0;
37244 wxWindow *arg1 = (wxWindow *) 0 ;
37245 wxPoint *arg2 = 0 ;
37246 wxPoint result;
37247 void *argp1 = 0 ;
37248 int res1 = 0 ;
37249 wxPoint temp2 ;
37250 PyObject * obj0 = 0 ;
37251 PyObject * obj1 = 0 ;
37252 char * kwnames[] = {
37253 (char *) "self",(char *) "pt", NULL
37254 };
37255
37256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37258 if (!SWIG_IsOK(res1)) {
37259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37260 }
37261 arg1 = reinterpret_cast< wxWindow * >(argp1);
37262 {
37263 arg2 = &temp2;
37264 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37265 }
37266 {
37267 PyThreadState* __tstate = wxPyBeginAllowThreads();
37268 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37269 wxPyEndAllowThreads(__tstate);
37270 if (PyErr_Occurred()) SWIG_fail;
37271 }
37272 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37273 return resultobj;
37274 fail:
37275 return NULL;
37276 }
37277
37278
37279 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37280 PyObject *resultobj = 0;
37281 wxWindow *arg1 = (wxWindow *) 0 ;
37282 wxSize *arg2 = 0 ;
37283 wxSize result;
37284 void *argp1 = 0 ;
37285 int res1 = 0 ;
37286 wxSize temp2 ;
37287 PyObject * obj0 = 0 ;
37288 PyObject * obj1 = 0 ;
37289 char * kwnames[] = {
37290 (char *) "self",(char *) "sz", NULL
37291 };
37292
37293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37295 if (!SWIG_IsOK(res1)) {
37296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37297 }
37298 arg1 = reinterpret_cast< wxWindow * >(argp1);
37299 {
37300 arg2 = &temp2;
37301 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37302 }
37303 {
37304 PyThreadState* __tstate = wxPyBeginAllowThreads();
37305 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37306 wxPyEndAllowThreads(__tstate);
37307 if (PyErr_Occurred()) SWIG_fail;
37308 }
37309 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37310 return resultobj;
37311 fail:
37312 return NULL;
37313 }
37314
37315
37316 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37317 PyObject *resultobj = 0;
37318 wxWindow *arg1 = (wxWindow *) 0 ;
37319 wxPoint *arg2 = 0 ;
37320 wxPoint result;
37321 void *argp1 = 0 ;
37322 int res1 = 0 ;
37323 wxPoint temp2 ;
37324 PyObject * obj0 = 0 ;
37325 PyObject * obj1 = 0 ;
37326 char * kwnames[] = {
37327 (char *) "self",(char *) "pt", NULL
37328 };
37329
37330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37332 if (!SWIG_IsOK(res1)) {
37333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37334 }
37335 arg1 = reinterpret_cast< wxWindow * >(argp1);
37336 {
37337 arg2 = &temp2;
37338 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37339 }
37340 {
37341 PyThreadState* __tstate = wxPyBeginAllowThreads();
37342 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37343 wxPyEndAllowThreads(__tstate);
37344 if (PyErr_Occurred()) SWIG_fail;
37345 }
37346 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37347 return resultobj;
37348 fail:
37349 return NULL;
37350 }
37351
37352
37353 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37354 PyObject *resultobj = 0;
37355 wxWindow *arg1 = (wxWindow *) 0 ;
37356 wxSize *arg2 = 0 ;
37357 wxSize result;
37358 void *argp1 = 0 ;
37359 int res1 = 0 ;
37360 wxSize temp2 ;
37361 PyObject * obj0 = 0 ;
37362 PyObject * obj1 = 0 ;
37363 char * kwnames[] = {
37364 (char *) "self",(char *) "sz", NULL
37365 };
37366
37367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37369 if (!SWIG_IsOK(res1)) {
37370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37371 }
37372 arg1 = reinterpret_cast< wxWindow * >(argp1);
37373 {
37374 arg2 = &temp2;
37375 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37376 }
37377 {
37378 PyThreadState* __tstate = wxPyBeginAllowThreads();
37379 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37380 wxPyEndAllowThreads(__tstate);
37381 if (PyErr_Occurred()) SWIG_fail;
37382 }
37383 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37384 return resultobj;
37385 fail:
37386 return NULL;
37387 }
37388
37389
37390 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37391 PyObject *resultobj = 0;
37392 wxWindow *arg1 = (wxWindow *) 0 ;
37393 wxPoint *arg2 = 0 ;
37394 wxPoint result;
37395 void *argp1 = 0 ;
37396 int res1 = 0 ;
37397 wxPoint temp2 ;
37398 PyObject * obj0 = 0 ;
37399 PyObject * obj1 = 0 ;
37400 char * kwnames[] = {
37401 (char *) "self",(char *) "pt", NULL
37402 };
37403
37404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37406 if (!SWIG_IsOK(res1)) {
37407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37408 }
37409 arg1 = reinterpret_cast< wxWindow * >(argp1);
37410 {
37411 arg2 = &temp2;
37412 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37413 }
37414 {
37415 PyThreadState* __tstate = wxPyBeginAllowThreads();
37416 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37417 wxPyEndAllowThreads(__tstate);
37418 if (PyErr_Occurred()) SWIG_fail;
37419 }
37420 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37421 return resultobj;
37422 fail:
37423 return NULL;
37424 }
37425
37426
37427 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37428 PyObject *resultobj = 0;
37429 wxWindow *arg1 = (wxWindow *) 0 ;
37430 wxSize *arg2 = 0 ;
37431 wxSize result;
37432 void *argp1 = 0 ;
37433 int res1 = 0 ;
37434 wxSize temp2 ;
37435 PyObject * obj0 = 0 ;
37436 PyObject * obj1 = 0 ;
37437 char * kwnames[] = {
37438 (char *) "self",(char *) "sz", NULL
37439 };
37440
37441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37443 if (!SWIG_IsOK(res1)) {
37444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37445 }
37446 arg1 = reinterpret_cast< wxWindow * >(argp1);
37447 {
37448 arg2 = &temp2;
37449 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37450 }
37451 {
37452 PyThreadState* __tstate = wxPyBeginAllowThreads();
37453 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37454 wxPyEndAllowThreads(__tstate);
37455 if (PyErr_Occurred()) SWIG_fail;
37456 }
37457 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37458 return resultobj;
37459 fail:
37460 return NULL;
37461 }
37462
37463
37464 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37465 PyObject *resultobj = 0;
37466 wxWindow *arg1 = (wxWindow *) 0 ;
37467 int arg2 ;
37468 int arg3 ;
37469 void *argp1 = 0 ;
37470 int res1 = 0 ;
37471 int val2 ;
37472 int ecode2 = 0 ;
37473 int val3 ;
37474 int ecode3 = 0 ;
37475 PyObject * obj0 = 0 ;
37476 PyObject * obj1 = 0 ;
37477 PyObject * obj2 = 0 ;
37478 char * kwnames[] = {
37479 (char *) "self",(char *) "x",(char *) "y", NULL
37480 };
37481
37482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37484 if (!SWIG_IsOK(res1)) {
37485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37486 }
37487 arg1 = reinterpret_cast< wxWindow * >(argp1);
37488 ecode2 = SWIG_AsVal_int(obj1, &val2);
37489 if (!SWIG_IsOK(ecode2)) {
37490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37491 }
37492 arg2 = static_cast< int >(val2);
37493 ecode3 = SWIG_AsVal_int(obj2, &val3);
37494 if (!SWIG_IsOK(ecode3)) {
37495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37496 }
37497 arg3 = static_cast< int >(val3);
37498 {
37499 PyThreadState* __tstate = wxPyBeginAllowThreads();
37500 (arg1)->WarpPointer(arg2,arg3);
37501 wxPyEndAllowThreads(__tstate);
37502 if (PyErr_Occurred()) SWIG_fail;
37503 }
37504 resultobj = SWIG_Py_Void();
37505 return resultobj;
37506 fail:
37507 return NULL;
37508 }
37509
37510
37511 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37512 PyObject *resultobj = 0;
37513 wxWindow *arg1 = (wxWindow *) 0 ;
37514 void *argp1 = 0 ;
37515 int res1 = 0 ;
37516 PyObject *swig_obj[1] ;
37517
37518 if (!args) SWIG_fail;
37519 swig_obj[0] = args;
37520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37521 if (!SWIG_IsOK(res1)) {
37522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37523 }
37524 arg1 = reinterpret_cast< wxWindow * >(argp1);
37525 {
37526 PyThreadState* __tstate = wxPyBeginAllowThreads();
37527 (arg1)->CaptureMouse();
37528 wxPyEndAllowThreads(__tstate);
37529 if (PyErr_Occurred()) SWIG_fail;
37530 }
37531 resultobj = SWIG_Py_Void();
37532 return resultobj;
37533 fail:
37534 return NULL;
37535 }
37536
37537
37538 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37539 PyObject *resultobj = 0;
37540 wxWindow *arg1 = (wxWindow *) 0 ;
37541 void *argp1 = 0 ;
37542 int res1 = 0 ;
37543 PyObject *swig_obj[1] ;
37544
37545 if (!args) SWIG_fail;
37546 swig_obj[0] = args;
37547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37548 if (!SWIG_IsOK(res1)) {
37549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37550 }
37551 arg1 = reinterpret_cast< wxWindow * >(argp1);
37552 {
37553 PyThreadState* __tstate = wxPyBeginAllowThreads();
37554 (arg1)->ReleaseMouse();
37555 wxPyEndAllowThreads(__tstate);
37556 if (PyErr_Occurred()) SWIG_fail;
37557 }
37558 resultobj = SWIG_Py_Void();
37559 return resultobj;
37560 fail:
37561 return NULL;
37562 }
37563
37564
37565 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37566 PyObject *resultobj = 0;
37567 wxWindow *result = 0 ;
37568
37569 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37570 {
37571 if (!wxPyCheckForApp()) SWIG_fail;
37572 PyThreadState* __tstate = wxPyBeginAllowThreads();
37573 result = (wxWindow *)wxWindow::GetCapture();
37574 wxPyEndAllowThreads(__tstate);
37575 if (PyErr_Occurred()) SWIG_fail;
37576 }
37577 {
37578 resultobj = wxPyMake_wxObject(result, 0);
37579 }
37580 return resultobj;
37581 fail:
37582 return NULL;
37583 }
37584
37585
37586 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37587 PyObject *resultobj = 0;
37588 wxWindow *arg1 = (wxWindow *) 0 ;
37589 bool result;
37590 void *argp1 = 0 ;
37591 int res1 = 0 ;
37592 PyObject *swig_obj[1] ;
37593
37594 if (!args) SWIG_fail;
37595 swig_obj[0] = args;
37596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37597 if (!SWIG_IsOK(res1)) {
37598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37599 }
37600 arg1 = reinterpret_cast< wxWindow * >(argp1);
37601 {
37602 PyThreadState* __tstate = wxPyBeginAllowThreads();
37603 result = (bool)((wxWindow const *)arg1)->HasCapture();
37604 wxPyEndAllowThreads(__tstate);
37605 if (PyErr_Occurred()) SWIG_fail;
37606 }
37607 {
37608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37609 }
37610 return resultobj;
37611 fail:
37612 return NULL;
37613 }
37614
37615
37616 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37617 PyObject *resultobj = 0;
37618 wxWindow *arg1 = (wxWindow *) 0 ;
37619 bool arg2 = (bool) true ;
37620 wxRect *arg3 = (wxRect *) NULL ;
37621 void *argp1 = 0 ;
37622 int res1 = 0 ;
37623 bool val2 ;
37624 int ecode2 = 0 ;
37625 void *argp3 = 0 ;
37626 int res3 = 0 ;
37627 PyObject * obj0 = 0 ;
37628 PyObject * obj1 = 0 ;
37629 PyObject * obj2 = 0 ;
37630 char * kwnames[] = {
37631 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37632 };
37633
37634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37636 if (!SWIG_IsOK(res1)) {
37637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37638 }
37639 arg1 = reinterpret_cast< wxWindow * >(argp1);
37640 if (obj1) {
37641 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37642 if (!SWIG_IsOK(ecode2)) {
37643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37644 }
37645 arg2 = static_cast< bool >(val2);
37646 }
37647 if (obj2) {
37648 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37649 if (!SWIG_IsOK(res3)) {
37650 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37651 }
37652 arg3 = reinterpret_cast< wxRect * >(argp3);
37653 }
37654 {
37655 PyThreadState* __tstate = wxPyBeginAllowThreads();
37656 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37657 wxPyEndAllowThreads(__tstate);
37658 if (PyErr_Occurred()) SWIG_fail;
37659 }
37660 resultobj = SWIG_Py_Void();
37661 return resultobj;
37662 fail:
37663 return NULL;
37664 }
37665
37666
37667 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37668 PyObject *resultobj = 0;
37669 wxWindow *arg1 = (wxWindow *) 0 ;
37670 wxRect *arg2 = 0 ;
37671 bool arg3 = (bool) true ;
37672 void *argp1 = 0 ;
37673 int res1 = 0 ;
37674 wxRect temp2 ;
37675 bool val3 ;
37676 int ecode3 = 0 ;
37677 PyObject * obj0 = 0 ;
37678 PyObject * obj1 = 0 ;
37679 PyObject * obj2 = 0 ;
37680 char * kwnames[] = {
37681 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37682 };
37683
37684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37686 if (!SWIG_IsOK(res1)) {
37687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37688 }
37689 arg1 = reinterpret_cast< wxWindow * >(argp1);
37690 {
37691 arg2 = &temp2;
37692 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37693 }
37694 if (obj2) {
37695 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37696 if (!SWIG_IsOK(ecode3)) {
37697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37698 }
37699 arg3 = static_cast< bool >(val3);
37700 }
37701 {
37702 PyThreadState* __tstate = wxPyBeginAllowThreads();
37703 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37704 wxPyEndAllowThreads(__tstate);
37705 if (PyErr_Occurred()) SWIG_fail;
37706 }
37707 resultobj = SWIG_Py_Void();
37708 return resultobj;
37709 fail:
37710 return NULL;
37711 }
37712
37713
37714 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37715 PyObject *resultobj = 0;
37716 wxWindow *arg1 = (wxWindow *) 0 ;
37717 void *argp1 = 0 ;
37718 int res1 = 0 ;
37719 PyObject *swig_obj[1] ;
37720
37721 if (!args) SWIG_fail;
37722 swig_obj[0] = args;
37723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37724 if (!SWIG_IsOK(res1)) {
37725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
37726 }
37727 arg1 = reinterpret_cast< wxWindow * >(argp1);
37728 {
37729 PyThreadState* __tstate = wxPyBeginAllowThreads();
37730 (arg1)->Update();
37731 wxPyEndAllowThreads(__tstate);
37732 if (PyErr_Occurred()) SWIG_fail;
37733 }
37734 resultobj = SWIG_Py_Void();
37735 return resultobj;
37736 fail:
37737 return NULL;
37738 }
37739
37740
37741 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37742 PyObject *resultobj = 0;
37743 wxWindow *arg1 = (wxWindow *) 0 ;
37744 void *argp1 = 0 ;
37745 int res1 = 0 ;
37746 PyObject *swig_obj[1] ;
37747
37748 if (!args) SWIG_fail;
37749 swig_obj[0] = args;
37750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37751 if (!SWIG_IsOK(res1)) {
37752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
37753 }
37754 arg1 = reinterpret_cast< wxWindow * >(argp1);
37755 {
37756 PyThreadState* __tstate = wxPyBeginAllowThreads();
37757 (arg1)->ClearBackground();
37758 wxPyEndAllowThreads(__tstate);
37759 if (PyErr_Occurred()) SWIG_fail;
37760 }
37761 resultobj = SWIG_Py_Void();
37762 return resultobj;
37763 fail:
37764 return NULL;
37765 }
37766
37767
37768 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37769 PyObject *resultobj = 0;
37770 wxWindow *arg1 = (wxWindow *) 0 ;
37771 void *argp1 = 0 ;
37772 int res1 = 0 ;
37773 PyObject *swig_obj[1] ;
37774
37775 if (!args) SWIG_fail;
37776 swig_obj[0] = args;
37777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37778 if (!SWIG_IsOK(res1)) {
37779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
37780 }
37781 arg1 = reinterpret_cast< wxWindow * >(argp1);
37782 {
37783 PyThreadState* __tstate = wxPyBeginAllowThreads();
37784 (arg1)->Freeze();
37785 wxPyEndAllowThreads(__tstate);
37786 if (PyErr_Occurred()) SWIG_fail;
37787 }
37788 resultobj = SWIG_Py_Void();
37789 return resultobj;
37790 fail:
37791 return NULL;
37792 }
37793
37794
37795 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37796 PyObject *resultobj = 0;
37797 wxWindow *arg1 = (wxWindow *) 0 ;
37798 bool result;
37799 void *argp1 = 0 ;
37800 int res1 = 0 ;
37801 PyObject *swig_obj[1] ;
37802
37803 if (!args) SWIG_fail;
37804 swig_obj[0] = args;
37805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37806 if (!SWIG_IsOK(res1)) {
37807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37808 }
37809 arg1 = reinterpret_cast< wxWindow * >(argp1);
37810 {
37811 PyThreadState* __tstate = wxPyBeginAllowThreads();
37812 result = (bool)((wxWindow const *)arg1)->IsFrozen();
37813 wxPyEndAllowThreads(__tstate);
37814 if (PyErr_Occurred()) SWIG_fail;
37815 }
37816 {
37817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37818 }
37819 return resultobj;
37820 fail:
37821 return NULL;
37822 }
37823
37824
37825 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37826 PyObject *resultobj = 0;
37827 wxWindow *arg1 = (wxWindow *) 0 ;
37828 void *argp1 = 0 ;
37829 int res1 = 0 ;
37830 PyObject *swig_obj[1] ;
37831
37832 if (!args) SWIG_fail;
37833 swig_obj[0] = args;
37834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37835 if (!SWIG_IsOK(res1)) {
37836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
37837 }
37838 arg1 = reinterpret_cast< wxWindow * >(argp1);
37839 {
37840 PyThreadState* __tstate = wxPyBeginAllowThreads();
37841 (arg1)->Thaw();
37842 wxPyEndAllowThreads(__tstate);
37843 if (PyErr_Occurred()) SWIG_fail;
37844 }
37845 resultobj = SWIG_Py_Void();
37846 return resultobj;
37847 fail:
37848 return NULL;
37849 }
37850
37851
37852 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37853 PyObject *resultobj = 0;
37854 wxWindow *arg1 = (wxWindow *) 0 ;
37855 wxDC *arg2 = 0 ;
37856 void *argp1 = 0 ;
37857 int res1 = 0 ;
37858 void *argp2 = 0 ;
37859 int res2 = 0 ;
37860 PyObject * obj0 = 0 ;
37861 PyObject * obj1 = 0 ;
37862 char * kwnames[] = {
37863 (char *) "self",(char *) "dc", NULL
37864 };
37865
37866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
37867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37868 if (!SWIG_IsOK(res1)) {
37869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
37870 }
37871 arg1 = reinterpret_cast< wxWindow * >(argp1);
37872 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
37873 if (!SWIG_IsOK(res2)) {
37874 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37875 }
37876 if (!argp2) {
37877 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37878 }
37879 arg2 = reinterpret_cast< wxDC * >(argp2);
37880 {
37881 PyThreadState* __tstate = wxPyBeginAllowThreads();
37882 (arg1)->PrepareDC(*arg2);
37883 wxPyEndAllowThreads(__tstate);
37884 if (PyErr_Occurred()) SWIG_fail;
37885 }
37886 resultobj = SWIG_Py_Void();
37887 return resultobj;
37888 fail:
37889 return NULL;
37890 }
37891
37892
37893 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37894 PyObject *resultobj = 0;
37895 wxWindow *arg1 = (wxWindow *) 0 ;
37896 bool result;
37897 void *argp1 = 0 ;
37898 int res1 = 0 ;
37899 PyObject *swig_obj[1] ;
37900
37901 if (!args) SWIG_fail;
37902 swig_obj[0] = args;
37903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37904 if (!SWIG_IsOK(res1)) {
37905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
37906 }
37907 arg1 = reinterpret_cast< wxWindow * >(argp1);
37908 {
37909 PyThreadState* __tstate = wxPyBeginAllowThreads();
37910 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
37911 wxPyEndAllowThreads(__tstate);
37912 if (PyErr_Occurred()) SWIG_fail;
37913 }
37914 {
37915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37916 }
37917 return resultobj;
37918 fail:
37919 return NULL;
37920 }
37921
37922
37923 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37924 PyObject *resultobj = 0;
37925 wxWindow *arg1 = (wxWindow *) 0 ;
37926 wxRegion *result = 0 ;
37927 void *argp1 = 0 ;
37928 int res1 = 0 ;
37929 PyObject *swig_obj[1] ;
37930
37931 if (!args) SWIG_fail;
37932 swig_obj[0] = args;
37933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37934 if (!SWIG_IsOK(res1)) {
37935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
37936 }
37937 arg1 = reinterpret_cast< wxWindow * >(argp1);
37938 {
37939 PyThreadState* __tstate = wxPyBeginAllowThreads();
37940 {
37941 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
37942 result = (wxRegion *) &_result_ref;
37943 }
37944 wxPyEndAllowThreads(__tstate);
37945 if (PyErr_Occurred()) SWIG_fail;
37946 }
37947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
37948 return resultobj;
37949 fail:
37950 return NULL;
37951 }
37952
37953
37954 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37955 PyObject *resultobj = 0;
37956 wxWindow *arg1 = (wxWindow *) 0 ;
37957 wxRect result;
37958 void *argp1 = 0 ;
37959 int res1 = 0 ;
37960 PyObject *swig_obj[1] ;
37961
37962 if (!args) SWIG_fail;
37963 swig_obj[0] = args;
37964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37965 if (!SWIG_IsOK(res1)) {
37966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
37967 }
37968 arg1 = reinterpret_cast< wxWindow * >(argp1);
37969 {
37970 PyThreadState* __tstate = wxPyBeginAllowThreads();
37971 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
37972 wxPyEndAllowThreads(__tstate);
37973 if (PyErr_Occurred()) SWIG_fail;
37974 }
37975 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
37976 return resultobj;
37977 fail:
37978 return NULL;
37979 }
37980
37981
37982 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37983 PyObject *resultobj = 0;
37984 wxWindow *arg1 = (wxWindow *) 0 ;
37985 int arg2 ;
37986 int arg3 ;
37987 int arg4 = (int) 1 ;
37988 int arg5 = (int) 1 ;
37989 bool result;
37990 void *argp1 = 0 ;
37991 int res1 = 0 ;
37992 int val2 ;
37993 int ecode2 = 0 ;
37994 int val3 ;
37995 int ecode3 = 0 ;
37996 int val4 ;
37997 int ecode4 = 0 ;
37998 int val5 ;
37999 int ecode5 = 0 ;
38000 PyObject * obj0 = 0 ;
38001 PyObject * obj1 = 0 ;
38002 PyObject * obj2 = 0 ;
38003 PyObject * obj3 = 0 ;
38004 PyObject * obj4 = 0 ;
38005 char * kwnames[] = {
38006 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
38007 };
38008
38009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38011 if (!SWIG_IsOK(res1)) {
38012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
38013 }
38014 arg1 = reinterpret_cast< wxWindow * >(argp1);
38015 ecode2 = SWIG_AsVal_int(obj1, &val2);
38016 if (!SWIG_IsOK(ecode2)) {
38017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
38018 }
38019 arg2 = static_cast< int >(val2);
38020 ecode3 = SWIG_AsVal_int(obj2, &val3);
38021 if (!SWIG_IsOK(ecode3)) {
38022 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
38023 }
38024 arg3 = static_cast< int >(val3);
38025 if (obj3) {
38026 ecode4 = SWIG_AsVal_int(obj3, &val4);
38027 if (!SWIG_IsOK(ecode4)) {
38028 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
38029 }
38030 arg4 = static_cast< int >(val4);
38031 }
38032 if (obj4) {
38033 ecode5 = SWIG_AsVal_int(obj4, &val5);
38034 if (!SWIG_IsOK(ecode5)) {
38035 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38036 }
38037 arg5 = static_cast< int >(val5);
38038 }
38039 {
38040 PyThreadState* __tstate = wxPyBeginAllowThreads();
38041 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38042 wxPyEndAllowThreads(__tstate);
38043 if (PyErr_Occurred()) SWIG_fail;
38044 }
38045 {
38046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38047 }
38048 return resultobj;
38049 fail:
38050 return NULL;
38051 }
38052
38053
38054 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38055 PyObject *resultobj = 0;
38056 wxWindow *arg1 = (wxWindow *) 0 ;
38057 wxPoint *arg2 = 0 ;
38058 bool result;
38059 void *argp1 = 0 ;
38060 int res1 = 0 ;
38061 wxPoint temp2 ;
38062 PyObject * obj0 = 0 ;
38063 PyObject * obj1 = 0 ;
38064 char * kwnames[] = {
38065 (char *) "self",(char *) "pt", NULL
38066 };
38067
38068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38070 if (!SWIG_IsOK(res1)) {
38071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38072 }
38073 arg1 = reinterpret_cast< wxWindow * >(argp1);
38074 {
38075 arg2 = &temp2;
38076 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38077 }
38078 {
38079 PyThreadState* __tstate = wxPyBeginAllowThreads();
38080 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38081 wxPyEndAllowThreads(__tstate);
38082 if (PyErr_Occurred()) SWIG_fail;
38083 }
38084 {
38085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38086 }
38087 return resultobj;
38088 fail:
38089 return NULL;
38090 }
38091
38092
38093 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38094 PyObject *resultobj = 0;
38095 wxWindow *arg1 = (wxWindow *) 0 ;
38096 wxRect *arg2 = 0 ;
38097 bool result;
38098 void *argp1 = 0 ;
38099 int res1 = 0 ;
38100 wxRect temp2 ;
38101 PyObject * obj0 = 0 ;
38102 PyObject * obj1 = 0 ;
38103 char * kwnames[] = {
38104 (char *) "self",(char *) "rect", NULL
38105 };
38106
38107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38109 if (!SWIG_IsOK(res1)) {
38110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38111 }
38112 arg1 = reinterpret_cast< wxWindow * >(argp1);
38113 {
38114 arg2 = &temp2;
38115 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38116 }
38117 {
38118 PyThreadState* __tstate = wxPyBeginAllowThreads();
38119 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38120 wxPyEndAllowThreads(__tstate);
38121 if (PyErr_Occurred()) SWIG_fail;
38122 }
38123 {
38124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38125 }
38126 return resultobj;
38127 fail:
38128 return NULL;
38129 }
38130
38131
38132 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38133 PyObject *resultobj = 0;
38134 wxWindow *arg1 = (wxWindow *) 0 ;
38135 SwigValueWrapper<wxVisualAttributes > result;
38136 void *argp1 = 0 ;
38137 int res1 = 0 ;
38138 PyObject *swig_obj[1] ;
38139
38140 if (!args) SWIG_fail;
38141 swig_obj[0] = args;
38142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38143 if (!SWIG_IsOK(res1)) {
38144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38145 }
38146 arg1 = reinterpret_cast< wxWindow * >(argp1);
38147 {
38148 PyThreadState* __tstate = wxPyBeginAllowThreads();
38149 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38150 wxPyEndAllowThreads(__tstate);
38151 if (PyErr_Occurred()) SWIG_fail;
38152 }
38153 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38154 return resultobj;
38155 fail:
38156 return NULL;
38157 }
38158
38159
38160 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38161 PyObject *resultobj = 0;
38162 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38163 SwigValueWrapper<wxVisualAttributes > result;
38164 int val1 ;
38165 int ecode1 = 0 ;
38166 PyObject * obj0 = 0 ;
38167 char * kwnames[] = {
38168 (char *) "variant", NULL
38169 };
38170
38171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38172 if (obj0) {
38173 ecode1 = SWIG_AsVal_int(obj0, &val1);
38174 if (!SWIG_IsOK(ecode1)) {
38175 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38176 }
38177 arg1 = static_cast< wxWindowVariant >(val1);
38178 }
38179 {
38180 if (!wxPyCheckForApp()) SWIG_fail;
38181 PyThreadState* __tstate = wxPyBeginAllowThreads();
38182 result = wxWindow::GetClassDefaultAttributes(arg1);
38183 wxPyEndAllowThreads(__tstate);
38184 if (PyErr_Occurred()) SWIG_fail;
38185 }
38186 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38187 return resultobj;
38188 fail:
38189 return NULL;
38190 }
38191
38192
38193 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38194 PyObject *resultobj = 0;
38195 wxWindow *arg1 = (wxWindow *) 0 ;
38196 wxColour *arg2 = 0 ;
38197 bool result;
38198 void *argp1 = 0 ;
38199 int res1 = 0 ;
38200 wxColour temp2 ;
38201 PyObject * obj0 = 0 ;
38202 PyObject * obj1 = 0 ;
38203 char * kwnames[] = {
38204 (char *) "self",(char *) "colour", NULL
38205 };
38206
38207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38209 if (!SWIG_IsOK(res1)) {
38210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38211 }
38212 arg1 = reinterpret_cast< wxWindow * >(argp1);
38213 {
38214 arg2 = &temp2;
38215 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38216 }
38217 {
38218 PyThreadState* __tstate = wxPyBeginAllowThreads();
38219 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38220 wxPyEndAllowThreads(__tstate);
38221 if (PyErr_Occurred()) SWIG_fail;
38222 }
38223 {
38224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38225 }
38226 return resultobj;
38227 fail:
38228 return NULL;
38229 }
38230
38231
38232 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38233 PyObject *resultobj = 0;
38234 wxWindow *arg1 = (wxWindow *) 0 ;
38235 wxColour *arg2 = 0 ;
38236 void *argp1 = 0 ;
38237 int res1 = 0 ;
38238 wxColour temp2 ;
38239 PyObject * obj0 = 0 ;
38240 PyObject * obj1 = 0 ;
38241 char * kwnames[] = {
38242 (char *) "self",(char *) "colour", NULL
38243 };
38244
38245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38247 if (!SWIG_IsOK(res1)) {
38248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38249 }
38250 arg1 = reinterpret_cast< wxWindow * >(argp1);
38251 {
38252 arg2 = &temp2;
38253 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38254 }
38255 {
38256 PyThreadState* __tstate = wxPyBeginAllowThreads();
38257 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38258 wxPyEndAllowThreads(__tstate);
38259 if (PyErr_Occurred()) SWIG_fail;
38260 }
38261 resultobj = SWIG_Py_Void();
38262 return resultobj;
38263 fail:
38264 return NULL;
38265 }
38266
38267
38268 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38269 PyObject *resultobj = 0;
38270 wxWindow *arg1 = (wxWindow *) 0 ;
38271 wxColour *arg2 = 0 ;
38272 bool result;
38273 void *argp1 = 0 ;
38274 int res1 = 0 ;
38275 wxColour temp2 ;
38276 PyObject * obj0 = 0 ;
38277 PyObject * obj1 = 0 ;
38278 char * kwnames[] = {
38279 (char *) "self",(char *) "colour", NULL
38280 };
38281
38282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38284 if (!SWIG_IsOK(res1)) {
38285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38286 }
38287 arg1 = reinterpret_cast< wxWindow * >(argp1);
38288 {
38289 arg2 = &temp2;
38290 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38291 }
38292 {
38293 PyThreadState* __tstate = wxPyBeginAllowThreads();
38294 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38295 wxPyEndAllowThreads(__tstate);
38296 if (PyErr_Occurred()) SWIG_fail;
38297 }
38298 {
38299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38300 }
38301 return resultobj;
38302 fail:
38303 return NULL;
38304 }
38305
38306
38307 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38308 PyObject *resultobj = 0;
38309 wxWindow *arg1 = (wxWindow *) 0 ;
38310 wxColour *arg2 = 0 ;
38311 void *argp1 = 0 ;
38312 int res1 = 0 ;
38313 wxColour temp2 ;
38314 PyObject * obj0 = 0 ;
38315 PyObject * obj1 = 0 ;
38316 char * kwnames[] = {
38317 (char *) "self",(char *) "colour", NULL
38318 };
38319
38320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38322 if (!SWIG_IsOK(res1)) {
38323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38324 }
38325 arg1 = reinterpret_cast< wxWindow * >(argp1);
38326 {
38327 arg2 = &temp2;
38328 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38329 }
38330 {
38331 PyThreadState* __tstate = wxPyBeginAllowThreads();
38332 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38333 wxPyEndAllowThreads(__tstate);
38334 if (PyErr_Occurred()) SWIG_fail;
38335 }
38336 resultobj = SWIG_Py_Void();
38337 return resultobj;
38338 fail:
38339 return NULL;
38340 }
38341
38342
38343 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38344 PyObject *resultobj = 0;
38345 wxWindow *arg1 = (wxWindow *) 0 ;
38346 wxColour result;
38347 void *argp1 = 0 ;
38348 int res1 = 0 ;
38349 PyObject *swig_obj[1] ;
38350
38351 if (!args) SWIG_fail;
38352 swig_obj[0] = args;
38353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38354 if (!SWIG_IsOK(res1)) {
38355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38356 }
38357 arg1 = reinterpret_cast< wxWindow * >(argp1);
38358 {
38359 PyThreadState* __tstate = wxPyBeginAllowThreads();
38360 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38361 wxPyEndAllowThreads(__tstate);
38362 if (PyErr_Occurred()) SWIG_fail;
38363 }
38364 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38365 return resultobj;
38366 fail:
38367 return NULL;
38368 }
38369
38370
38371 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38372 PyObject *resultobj = 0;
38373 wxWindow *arg1 = (wxWindow *) 0 ;
38374 wxColour result;
38375 void *argp1 = 0 ;
38376 int res1 = 0 ;
38377 PyObject *swig_obj[1] ;
38378
38379 if (!args) SWIG_fail;
38380 swig_obj[0] = args;
38381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38382 if (!SWIG_IsOK(res1)) {
38383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38384 }
38385 arg1 = reinterpret_cast< wxWindow * >(argp1);
38386 {
38387 PyThreadState* __tstate = wxPyBeginAllowThreads();
38388 result = ((wxWindow const *)arg1)->GetForegroundColour();
38389 wxPyEndAllowThreads(__tstate);
38390 if (PyErr_Occurred()) SWIG_fail;
38391 }
38392 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38393 return resultobj;
38394 fail:
38395 return NULL;
38396 }
38397
38398
38399 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38400 PyObject *resultobj = 0;
38401 wxWindow *arg1 = (wxWindow *) 0 ;
38402 bool result;
38403 void *argp1 = 0 ;
38404 int res1 = 0 ;
38405 PyObject *swig_obj[1] ;
38406
38407 if (!args) SWIG_fail;
38408 swig_obj[0] = args;
38409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38410 if (!SWIG_IsOK(res1)) {
38411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38412 }
38413 arg1 = reinterpret_cast< wxWindow * >(argp1);
38414 {
38415 PyThreadState* __tstate = wxPyBeginAllowThreads();
38416 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38417 wxPyEndAllowThreads(__tstate);
38418 if (PyErr_Occurred()) SWIG_fail;
38419 }
38420 {
38421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38422 }
38423 return resultobj;
38424 fail:
38425 return NULL;
38426 }
38427
38428
38429 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38430 PyObject *resultobj = 0;
38431 wxWindow *arg1 = (wxWindow *) 0 ;
38432 bool result;
38433 void *argp1 = 0 ;
38434 int res1 = 0 ;
38435 PyObject *swig_obj[1] ;
38436
38437 if (!args) SWIG_fail;
38438 swig_obj[0] = args;
38439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38440 if (!SWIG_IsOK(res1)) {
38441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38442 }
38443 arg1 = reinterpret_cast< wxWindow * >(argp1);
38444 {
38445 PyThreadState* __tstate = wxPyBeginAllowThreads();
38446 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38447 wxPyEndAllowThreads(__tstate);
38448 if (PyErr_Occurred()) SWIG_fail;
38449 }
38450 {
38451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38452 }
38453 return resultobj;
38454 fail:
38455 return NULL;
38456 }
38457
38458
38459 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38460 PyObject *resultobj = 0;
38461 wxWindow *arg1 = (wxWindow *) 0 ;
38462 wxBackgroundStyle arg2 ;
38463 bool result;
38464 void *argp1 = 0 ;
38465 int res1 = 0 ;
38466 int val2 ;
38467 int ecode2 = 0 ;
38468 PyObject * obj0 = 0 ;
38469 PyObject * obj1 = 0 ;
38470 char * kwnames[] = {
38471 (char *) "self",(char *) "style", NULL
38472 };
38473
38474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38476 if (!SWIG_IsOK(res1)) {
38477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38478 }
38479 arg1 = reinterpret_cast< wxWindow * >(argp1);
38480 ecode2 = SWIG_AsVal_int(obj1, &val2);
38481 if (!SWIG_IsOK(ecode2)) {
38482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38483 }
38484 arg2 = static_cast< wxBackgroundStyle >(val2);
38485 {
38486 PyThreadState* __tstate = wxPyBeginAllowThreads();
38487 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38488 wxPyEndAllowThreads(__tstate);
38489 if (PyErr_Occurred()) SWIG_fail;
38490 }
38491 {
38492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38493 }
38494 return resultobj;
38495 fail:
38496 return NULL;
38497 }
38498
38499
38500 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38501 PyObject *resultobj = 0;
38502 wxWindow *arg1 = (wxWindow *) 0 ;
38503 wxBackgroundStyle result;
38504 void *argp1 = 0 ;
38505 int res1 = 0 ;
38506 PyObject *swig_obj[1] ;
38507
38508 if (!args) SWIG_fail;
38509 swig_obj[0] = args;
38510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38511 if (!SWIG_IsOK(res1)) {
38512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38513 }
38514 arg1 = reinterpret_cast< wxWindow * >(argp1);
38515 {
38516 PyThreadState* __tstate = wxPyBeginAllowThreads();
38517 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38518 wxPyEndAllowThreads(__tstate);
38519 if (PyErr_Occurred()) SWIG_fail;
38520 }
38521 resultobj = SWIG_From_int(static_cast< int >(result));
38522 return resultobj;
38523 fail:
38524 return NULL;
38525 }
38526
38527
38528 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38529 PyObject *resultobj = 0;
38530 wxWindow *arg1 = (wxWindow *) 0 ;
38531 bool result;
38532 void *argp1 = 0 ;
38533 int res1 = 0 ;
38534 PyObject *swig_obj[1] ;
38535
38536 if (!args) SWIG_fail;
38537 swig_obj[0] = args;
38538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38539 if (!SWIG_IsOK(res1)) {
38540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38541 }
38542 arg1 = reinterpret_cast< wxWindow * >(argp1);
38543 {
38544 PyThreadState* __tstate = wxPyBeginAllowThreads();
38545 result = (bool)(arg1)->HasTransparentBackground();
38546 wxPyEndAllowThreads(__tstate);
38547 if (PyErr_Occurred()) SWIG_fail;
38548 }
38549 {
38550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38551 }
38552 return resultobj;
38553 fail:
38554 return NULL;
38555 }
38556
38557
38558 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38559 PyObject *resultobj = 0;
38560 wxWindow *arg1 = (wxWindow *) 0 ;
38561 wxCursor *arg2 = 0 ;
38562 bool result;
38563 void *argp1 = 0 ;
38564 int res1 = 0 ;
38565 void *argp2 = 0 ;
38566 int res2 = 0 ;
38567 PyObject * obj0 = 0 ;
38568 PyObject * obj1 = 0 ;
38569 char * kwnames[] = {
38570 (char *) "self",(char *) "cursor", NULL
38571 };
38572
38573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38575 if (!SWIG_IsOK(res1)) {
38576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38577 }
38578 arg1 = reinterpret_cast< wxWindow * >(argp1);
38579 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38580 if (!SWIG_IsOK(res2)) {
38581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38582 }
38583 if (!argp2) {
38584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38585 }
38586 arg2 = reinterpret_cast< wxCursor * >(argp2);
38587 {
38588 PyThreadState* __tstate = wxPyBeginAllowThreads();
38589 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38590 wxPyEndAllowThreads(__tstate);
38591 if (PyErr_Occurred()) SWIG_fail;
38592 }
38593 {
38594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38595 }
38596 return resultobj;
38597 fail:
38598 return NULL;
38599 }
38600
38601
38602 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38603 PyObject *resultobj = 0;
38604 wxWindow *arg1 = (wxWindow *) 0 ;
38605 wxCursor result;
38606 void *argp1 = 0 ;
38607 int res1 = 0 ;
38608 PyObject *swig_obj[1] ;
38609
38610 if (!args) SWIG_fail;
38611 swig_obj[0] = args;
38612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38613 if (!SWIG_IsOK(res1)) {
38614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38615 }
38616 arg1 = reinterpret_cast< wxWindow * >(argp1);
38617 {
38618 PyThreadState* __tstate = wxPyBeginAllowThreads();
38619 result = (arg1)->GetCursor();
38620 wxPyEndAllowThreads(__tstate);
38621 if (PyErr_Occurred()) SWIG_fail;
38622 }
38623 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38624 return resultobj;
38625 fail:
38626 return NULL;
38627 }
38628
38629
38630 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38631 PyObject *resultobj = 0;
38632 wxWindow *arg1 = (wxWindow *) 0 ;
38633 wxFont *arg2 = 0 ;
38634 bool result;
38635 void *argp1 = 0 ;
38636 int res1 = 0 ;
38637 void *argp2 = 0 ;
38638 int res2 = 0 ;
38639 PyObject * obj0 = 0 ;
38640 PyObject * obj1 = 0 ;
38641 char * kwnames[] = {
38642 (char *) "self",(char *) "font", NULL
38643 };
38644
38645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38647 if (!SWIG_IsOK(res1)) {
38648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38649 }
38650 arg1 = reinterpret_cast< wxWindow * >(argp1);
38651 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38652 if (!SWIG_IsOK(res2)) {
38653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38654 }
38655 if (!argp2) {
38656 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38657 }
38658 arg2 = reinterpret_cast< wxFont * >(argp2);
38659 {
38660 PyThreadState* __tstate = wxPyBeginAllowThreads();
38661 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38662 wxPyEndAllowThreads(__tstate);
38663 if (PyErr_Occurred()) SWIG_fail;
38664 }
38665 {
38666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38667 }
38668 return resultobj;
38669 fail:
38670 return NULL;
38671 }
38672
38673
38674 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38675 PyObject *resultobj = 0;
38676 wxWindow *arg1 = (wxWindow *) 0 ;
38677 wxFont *arg2 = 0 ;
38678 void *argp1 = 0 ;
38679 int res1 = 0 ;
38680 void *argp2 = 0 ;
38681 int res2 = 0 ;
38682 PyObject * obj0 = 0 ;
38683 PyObject * obj1 = 0 ;
38684 char * kwnames[] = {
38685 (char *) "self",(char *) "font", NULL
38686 };
38687
38688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38690 if (!SWIG_IsOK(res1)) {
38691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38692 }
38693 arg1 = reinterpret_cast< wxWindow * >(argp1);
38694 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38695 if (!SWIG_IsOK(res2)) {
38696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38697 }
38698 if (!argp2) {
38699 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38700 }
38701 arg2 = reinterpret_cast< wxFont * >(argp2);
38702 {
38703 PyThreadState* __tstate = wxPyBeginAllowThreads();
38704 (arg1)->SetOwnFont((wxFont const &)*arg2);
38705 wxPyEndAllowThreads(__tstate);
38706 if (PyErr_Occurred()) SWIG_fail;
38707 }
38708 resultobj = SWIG_Py_Void();
38709 return resultobj;
38710 fail:
38711 return NULL;
38712 }
38713
38714
38715 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38716 PyObject *resultobj = 0;
38717 wxWindow *arg1 = (wxWindow *) 0 ;
38718 wxFont result;
38719 void *argp1 = 0 ;
38720 int res1 = 0 ;
38721 PyObject *swig_obj[1] ;
38722
38723 if (!args) SWIG_fail;
38724 swig_obj[0] = args;
38725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38726 if (!SWIG_IsOK(res1)) {
38727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38728 }
38729 arg1 = reinterpret_cast< wxWindow * >(argp1);
38730 {
38731 PyThreadState* __tstate = wxPyBeginAllowThreads();
38732 result = (arg1)->GetFont();
38733 wxPyEndAllowThreads(__tstate);
38734 if (PyErr_Occurred()) SWIG_fail;
38735 }
38736 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
38737 return resultobj;
38738 fail:
38739 return NULL;
38740 }
38741
38742
38743 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38744 PyObject *resultobj = 0;
38745 wxWindow *arg1 = (wxWindow *) 0 ;
38746 wxCaret *arg2 = (wxCaret *) 0 ;
38747 void *argp1 = 0 ;
38748 int res1 = 0 ;
38749 int res2 = 0 ;
38750 PyObject * obj0 = 0 ;
38751 PyObject * obj1 = 0 ;
38752 char * kwnames[] = {
38753 (char *) "self",(char *) "caret", NULL
38754 };
38755
38756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
38757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38758 if (!SWIG_IsOK(res1)) {
38759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
38760 }
38761 arg1 = reinterpret_cast< wxWindow * >(argp1);
38762 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
38763 if (!SWIG_IsOK(res2)) {
38764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
38765 }
38766 {
38767 PyThreadState* __tstate = wxPyBeginAllowThreads();
38768 (arg1)->SetCaret(arg2);
38769 wxPyEndAllowThreads(__tstate);
38770 if (PyErr_Occurred()) SWIG_fail;
38771 }
38772 resultobj = SWIG_Py_Void();
38773 return resultobj;
38774 fail:
38775 return NULL;
38776 }
38777
38778
38779 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38780 PyObject *resultobj = 0;
38781 wxWindow *arg1 = (wxWindow *) 0 ;
38782 wxCaret *result = 0 ;
38783 void *argp1 = 0 ;
38784 int res1 = 0 ;
38785 PyObject *swig_obj[1] ;
38786
38787 if (!args) SWIG_fail;
38788 swig_obj[0] = args;
38789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38790 if (!SWIG_IsOK(res1)) {
38791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
38792 }
38793 arg1 = reinterpret_cast< wxWindow * >(argp1);
38794 {
38795 PyThreadState* __tstate = wxPyBeginAllowThreads();
38796 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
38797 wxPyEndAllowThreads(__tstate);
38798 if (PyErr_Occurred()) SWIG_fail;
38799 }
38800 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
38801 return resultobj;
38802 fail:
38803 return NULL;
38804 }
38805
38806
38807 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38808 PyObject *resultobj = 0;
38809 wxWindow *arg1 = (wxWindow *) 0 ;
38810 int result;
38811 void *argp1 = 0 ;
38812 int res1 = 0 ;
38813 PyObject *swig_obj[1] ;
38814
38815 if (!args) SWIG_fail;
38816 swig_obj[0] = args;
38817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38818 if (!SWIG_IsOK(res1)) {
38819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
38820 }
38821 arg1 = reinterpret_cast< wxWindow * >(argp1);
38822 {
38823 PyThreadState* __tstate = wxPyBeginAllowThreads();
38824 result = (int)((wxWindow const *)arg1)->GetCharHeight();
38825 wxPyEndAllowThreads(__tstate);
38826 if (PyErr_Occurred()) SWIG_fail;
38827 }
38828 resultobj = SWIG_From_int(static_cast< int >(result));
38829 return resultobj;
38830 fail:
38831 return NULL;
38832 }
38833
38834
38835 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38836 PyObject *resultobj = 0;
38837 wxWindow *arg1 = (wxWindow *) 0 ;
38838 int result;
38839 void *argp1 = 0 ;
38840 int res1 = 0 ;
38841 PyObject *swig_obj[1] ;
38842
38843 if (!args) SWIG_fail;
38844 swig_obj[0] = args;
38845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38846 if (!SWIG_IsOK(res1)) {
38847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
38848 }
38849 arg1 = reinterpret_cast< wxWindow * >(argp1);
38850 {
38851 PyThreadState* __tstate = wxPyBeginAllowThreads();
38852 result = (int)((wxWindow const *)arg1)->GetCharWidth();
38853 wxPyEndAllowThreads(__tstate);
38854 if (PyErr_Occurred()) SWIG_fail;
38855 }
38856 resultobj = SWIG_From_int(static_cast< int >(result));
38857 return resultobj;
38858 fail:
38859 return NULL;
38860 }
38861
38862
38863 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38864 PyObject *resultobj = 0;
38865 wxWindow *arg1 = (wxWindow *) 0 ;
38866 wxString *arg2 = 0 ;
38867 int *arg3 = (int *) 0 ;
38868 int *arg4 = (int *) 0 ;
38869 void *argp1 = 0 ;
38870 int res1 = 0 ;
38871 bool temp2 = false ;
38872 int temp3 ;
38873 int res3 = SWIG_TMPOBJ ;
38874 int temp4 ;
38875 int res4 = SWIG_TMPOBJ ;
38876 PyObject * obj0 = 0 ;
38877 PyObject * obj1 = 0 ;
38878 char * kwnames[] = {
38879 (char *) "self",(char *) "string", NULL
38880 };
38881
38882 arg3 = &temp3;
38883 arg4 = &temp4;
38884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
38885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38886 if (!SWIG_IsOK(res1)) {
38887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38888 }
38889 arg1 = reinterpret_cast< wxWindow * >(argp1);
38890 {
38891 arg2 = wxString_in_helper(obj1);
38892 if (arg2 == NULL) SWIG_fail;
38893 temp2 = true;
38894 }
38895 {
38896 PyThreadState* __tstate = wxPyBeginAllowThreads();
38897 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
38898 wxPyEndAllowThreads(__tstate);
38899 if (PyErr_Occurred()) SWIG_fail;
38900 }
38901 resultobj = SWIG_Py_Void();
38902 if (SWIG_IsTmpObj(res3)) {
38903 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38904 } else {
38905 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38906 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38907 }
38908 if (SWIG_IsTmpObj(res4)) {
38909 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38910 } else {
38911 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38912 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38913 }
38914 {
38915 if (temp2)
38916 delete arg2;
38917 }
38918 return resultobj;
38919 fail:
38920 {
38921 if (temp2)
38922 delete arg2;
38923 }
38924 return NULL;
38925 }
38926
38927
38928 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38929 PyObject *resultobj = 0;
38930 wxWindow *arg1 = (wxWindow *) 0 ;
38931 wxString *arg2 = 0 ;
38932 int *arg3 = (int *) 0 ;
38933 int *arg4 = (int *) 0 ;
38934 int *arg5 = (int *) 0 ;
38935 int *arg6 = (int *) 0 ;
38936 wxFont *arg7 = (wxFont *) NULL ;
38937 void *argp1 = 0 ;
38938 int res1 = 0 ;
38939 bool temp2 = false ;
38940 int temp3 ;
38941 int res3 = SWIG_TMPOBJ ;
38942 int temp4 ;
38943 int res4 = SWIG_TMPOBJ ;
38944 int temp5 ;
38945 int res5 = SWIG_TMPOBJ ;
38946 int temp6 ;
38947 int res6 = SWIG_TMPOBJ ;
38948 void *argp7 = 0 ;
38949 int res7 = 0 ;
38950 PyObject * obj0 = 0 ;
38951 PyObject * obj1 = 0 ;
38952 PyObject * obj2 = 0 ;
38953 char * kwnames[] = {
38954 (char *) "self",(char *) "string",(char *) "font", NULL
38955 };
38956
38957 arg3 = &temp3;
38958 arg4 = &temp4;
38959 arg5 = &temp5;
38960 arg6 = &temp6;
38961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38963 if (!SWIG_IsOK(res1)) {
38964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38965 }
38966 arg1 = reinterpret_cast< wxWindow * >(argp1);
38967 {
38968 arg2 = wxString_in_helper(obj1);
38969 if (arg2 == NULL) SWIG_fail;
38970 temp2 = true;
38971 }
38972 if (obj2) {
38973 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
38974 if (!SWIG_IsOK(res7)) {
38975 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
38976 }
38977 arg7 = reinterpret_cast< wxFont * >(argp7);
38978 }
38979 {
38980 PyThreadState* __tstate = wxPyBeginAllowThreads();
38981 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
38982 wxPyEndAllowThreads(__tstate);
38983 if (PyErr_Occurred()) SWIG_fail;
38984 }
38985 resultobj = SWIG_Py_Void();
38986 if (SWIG_IsTmpObj(res3)) {
38987 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38988 } else {
38989 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38990 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38991 }
38992 if (SWIG_IsTmpObj(res4)) {
38993 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38994 } else {
38995 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38996 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38997 }
38998 if (SWIG_IsTmpObj(res5)) {
38999 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
39000 } else {
39001 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39002 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
39003 }
39004 if (SWIG_IsTmpObj(res6)) {
39005 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
39006 } else {
39007 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39008 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
39009 }
39010 {
39011 if (temp2)
39012 delete arg2;
39013 }
39014 return resultobj;
39015 fail:
39016 {
39017 if (temp2)
39018 delete arg2;
39019 }
39020 return NULL;
39021 }
39022
39023
39024 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39025 PyObject *resultobj = 0;
39026 wxWindow *arg1 = (wxWindow *) 0 ;
39027 int *arg2 = (int *) 0 ;
39028 int *arg3 = (int *) 0 ;
39029 void *argp1 = 0 ;
39030 int res1 = 0 ;
39031 int temp2 ;
39032 int res2 = 0 ;
39033 int temp3 ;
39034 int res3 = 0 ;
39035 PyObject * obj0 = 0 ;
39036 PyObject * obj1 = 0 ;
39037 PyObject * obj2 = 0 ;
39038 char * kwnames[] = {
39039 (char *) "self",(char *) "x",(char *) "y", NULL
39040 };
39041
39042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39044 if (!SWIG_IsOK(res1)) {
39045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39046 }
39047 arg1 = reinterpret_cast< wxWindow * >(argp1);
39048 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39049 int val;
39050 int ecode = SWIG_AsVal_int(obj1, &val);
39051 if (!SWIG_IsOK(ecode)) {
39052 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39053 }
39054 temp2 = static_cast< int >(val);
39055 arg2 = &temp2;
39056 res2 = SWIG_AddTmpMask(ecode);
39057 }
39058 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39059 int val;
39060 int ecode = SWIG_AsVal_int(obj2, &val);
39061 if (!SWIG_IsOK(ecode)) {
39062 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39063 }
39064 temp3 = static_cast< int >(val);
39065 arg3 = &temp3;
39066 res3 = SWIG_AddTmpMask(ecode);
39067 }
39068 {
39069 PyThreadState* __tstate = wxPyBeginAllowThreads();
39070 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39071 wxPyEndAllowThreads(__tstate);
39072 if (PyErr_Occurred()) SWIG_fail;
39073 }
39074 resultobj = SWIG_Py_Void();
39075 if (SWIG_IsTmpObj(res2)) {
39076 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39077 } else {
39078 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39079 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39080 }
39081 if (SWIG_IsTmpObj(res3)) {
39082 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39083 } else {
39084 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39085 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39086 }
39087 return resultobj;
39088 fail:
39089 return NULL;
39090 }
39091
39092
39093 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39094 PyObject *resultobj = 0;
39095 wxWindow *arg1 = (wxWindow *) 0 ;
39096 int *arg2 = (int *) 0 ;
39097 int *arg3 = (int *) 0 ;
39098 void *argp1 = 0 ;
39099 int res1 = 0 ;
39100 int temp2 ;
39101 int res2 = 0 ;
39102 int temp3 ;
39103 int res3 = 0 ;
39104 PyObject * obj0 = 0 ;
39105 PyObject * obj1 = 0 ;
39106 PyObject * obj2 = 0 ;
39107 char * kwnames[] = {
39108 (char *) "self",(char *) "x",(char *) "y", NULL
39109 };
39110
39111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39113 if (!SWIG_IsOK(res1)) {
39114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39115 }
39116 arg1 = reinterpret_cast< wxWindow * >(argp1);
39117 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39118 int val;
39119 int ecode = SWIG_AsVal_int(obj1, &val);
39120 if (!SWIG_IsOK(ecode)) {
39121 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39122 }
39123 temp2 = static_cast< int >(val);
39124 arg2 = &temp2;
39125 res2 = SWIG_AddTmpMask(ecode);
39126 }
39127 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39128 int val;
39129 int ecode = SWIG_AsVal_int(obj2, &val);
39130 if (!SWIG_IsOK(ecode)) {
39131 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39132 }
39133 temp3 = static_cast< int >(val);
39134 arg3 = &temp3;
39135 res3 = SWIG_AddTmpMask(ecode);
39136 }
39137 {
39138 PyThreadState* __tstate = wxPyBeginAllowThreads();
39139 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39140 wxPyEndAllowThreads(__tstate);
39141 if (PyErr_Occurred()) SWIG_fail;
39142 }
39143 resultobj = SWIG_Py_Void();
39144 if (SWIG_IsTmpObj(res2)) {
39145 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39146 } else {
39147 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39148 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39149 }
39150 if (SWIG_IsTmpObj(res3)) {
39151 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39152 } else {
39153 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39154 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39155 }
39156 return resultobj;
39157 fail:
39158 return NULL;
39159 }
39160
39161
39162 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39163 PyObject *resultobj = 0;
39164 wxWindow *arg1 = (wxWindow *) 0 ;
39165 wxPoint *arg2 = 0 ;
39166 wxPoint result;
39167 void *argp1 = 0 ;
39168 int res1 = 0 ;
39169 wxPoint temp2 ;
39170 PyObject * obj0 = 0 ;
39171 PyObject * obj1 = 0 ;
39172 char * kwnames[] = {
39173 (char *) "self",(char *) "pt", NULL
39174 };
39175
39176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39178 if (!SWIG_IsOK(res1)) {
39179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39180 }
39181 arg1 = reinterpret_cast< wxWindow * >(argp1);
39182 {
39183 arg2 = &temp2;
39184 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39185 }
39186 {
39187 PyThreadState* __tstate = wxPyBeginAllowThreads();
39188 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39189 wxPyEndAllowThreads(__tstate);
39190 if (PyErr_Occurred()) SWIG_fail;
39191 }
39192 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39193 return resultobj;
39194 fail:
39195 return NULL;
39196 }
39197
39198
39199 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39200 PyObject *resultobj = 0;
39201 wxWindow *arg1 = (wxWindow *) 0 ;
39202 wxPoint *arg2 = 0 ;
39203 wxPoint result;
39204 void *argp1 = 0 ;
39205 int res1 = 0 ;
39206 wxPoint temp2 ;
39207 PyObject * obj0 = 0 ;
39208 PyObject * obj1 = 0 ;
39209 char * kwnames[] = {
39210 (char *) "self",(char *) "pt", NULL
39211 };
39212
39213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39215 if (!SWIG_IsOK(res1)) {
39216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39217 }
39218 arg1 = reinterpret_cast< wxWindow * >(argp1);
39219 {
39220 arg2 = &temp2;
39221 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39222 }
39223 {
39224 PyThreadState* __tstate = wxPyBeginAllowThreads();
39225 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39226 wxPyEndAllowThreads(__tstate);
39227 if (PyErr_Occurred()) SWIG_fail;
39228 }
39229 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39230 return resultobj;
39231 fail:
39232 return NULL;
39233 }
39234
39235
39236 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39237 PyObject *resultobj = 0;
39238 wxWindow *arg1 = (wxWindow *) 0 ;
39239 int arg2 ;
39240 int arg3 ;
39241 wxHitTest result;
39242 void *argp1 = 0 ;
39243 int res1 = 0 ;
39244 int val2 ;
39245 int ecode2 = 0 ;
39246 int val3 ;
39247 int ecode3 = 0 ;
39248 PyObject * obj0 = 0 ;
39249 PyObject * obj1 = 0 ;
39250 PyObject * obj2 = 0 ;
39251 char * kwnames[] = {
39252 (char *) "self",(char *) "x",(char *) "y", NULL
39253 };
39254
39255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39257 if (!SWIG_IsOK(res1)) {
39258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39259 }
39260 arg1 = reinterpret_cast< wxWindow * >(argp1);
39261 ecode2 = SWIG_AsVal_int(obj1, &val2);
39262 if (!SWIG_IsOK(ecode2)) {
39263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39264 }
39265 arg2 = static_cast< int >(val2);
39266 ecode3 = SWIG_AsVal_int(obj2, &val3);
39267 if (!SWIG_IsOK(ecode3)) {
39268 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39269 }
39270 arg3 = static_cast< int >(val3);
39271 {
39272 PyThreadState* __tstate = wxPyBeginAllowThreads();
39273 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39274 wxPyEndAllowThreads(__tstate);
39275 if (PyErr_Occurred()) SWIG_fail;
39276 }
39277 resultobj = SWIG_From_int(static_cast< int >(result));
39278 return resultobj;
39279 fail:
39280 return NULL;
39281 }
39282
39283
39284 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39285 PyObject *resultobj = 0;
39286 wxWindow *arg1 = (wxWindow *) 0 ;
39287 wxPoint *arg2 = 0 ;
39288 wxHitTest result;
39289 void *argp1 = 0 ;
39290 int res1 = 0 ;
39291 wxPoint temp2 ;
39292 PyObject * obj0 = 0 ;
39293 PyObject * obj1 = 0 ;
39294 char * kwnames[] = {
39295 (char *) "self",(char *) "pt", NULL
39296 };
39297
39298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39300 if (!SWIG_IsOK(res1)) {
39301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39302 }
39303 arg1 = reinterpret_cast< wxWindow * >(argp1);
39304 {
39305 arg2 = &temp2;
39306 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39307 }
39308 {
39309 PyThreadState* __tstate = wxPyBeginAllowThreads();
39310 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39311 wxPyEndAllowThreads(__tstate);
39312 if (PyErr_Occurred()) SWIG_fail;
39313 }
39314 resultobj = SWIG_From_int(static_cast< int >(result));
39315 return resultobj;
39316 fail:
39317 return NULL;
39318 }
39319
39320
39321 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39322 PyObject *resultobj = 0;
39323 wxWindow *arg1 = (wxWindow *) 0 ;
39324 long arg2 ;
39325 wxBorder result;
39326 void *argp1 = 0 ;
39327 int res1 = 0 ;
39328 long val2 ;
39329 int ecode2 = 0 ;
39330
39331 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39333 if (!SWIG_IsOK(res1)) {
39334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39335 }
39336 arg1 = reinterpret_cast< wxWindow * >(argp1);
39337 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39338 if (!SWIG_IsOK(ecode2)) {
39339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39340 }
39341 arg2 = static_cast< long >(val2);
39342 {
39343 PyThreadState* __tstate = wxPyBeginAllowThreads();
39344 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39345 wxPyEndAllowThreads(__tstate);
39346 if (PyErr_Occurred()) SWIG_fail;
39347 }
39348 resultobj = SWIG_From_int(static_cast< int >(result));
39349 return resultobj;
39350 fail:
39351 return NULL;
39352 }
39353
39354
39355 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39356 PyObject *resultobj = 0;
39357 wxWindow *arg1 = (wxWindow *) 0 ;
39358 wxBorder result;
39359 void *argp1 = 0 ;
39360 int res1 = 0 ;
39361
39362 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39364 if (!SWIG_IsOK(res1)) {
39365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39366 }
39367 arg1 = reinterpret_cast< wxWindow * >(argp1);
39368 {
39369 PyThreadState* __tstate = wxPyBeginAllowThreads();
39370 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39371 wxPyEndAllowThreads(__tstate);
39372 if (PyErr_Occurred()) SWIG_fail;
39373 }
39374 resultobj = SWIG_From_int(static_cast< int >(result));
39375 return resultobj;
39376 fail:
39377 return NULL;
39378 }
39379
39380
39381 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39382 int argc;
39383 PyObject *argv[3];
39384
39385 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39386 --argc;
39387 if (argc == 1) {
39388 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39389 }
39390 if (argc == 2) {
39391 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39392 }
39393
39394 fail:
39395 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39396 return NULL;
39397 }
39398
39399
39400 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39401 PyObject *resultobj = 0;
39402 wxWindow *arg1 = (wxWindow *) 0 ;
39403 long arg2 = (long) wxUPDATE_UI_NONE ;
39404 void *argp1 = 0 ;
39405 int res1 = 0 ;
39406 long val2 ;
39407 int ecode2 = 0 ;
39408 PyObject * obj0 = 0 ;
39409 PyObject * obj1 = 0 ;
39410 char * kwnames[] = {
39411 (char *) "self",(char *) "flags", NULL
39412 };
39413
39414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39416 if (!SWIG_IsOK(res1)) {
39417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39418 }
39419 arg1 = reinterpret_cast< wxWindow * >(argp1);
39420 if (obj1) {
39421 ecode2 = SWIG_AsVal_long(obj1, &val2);
39422 if (!SWIG_IsOK(ecode2)) {
39423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39424 }
39425 arg2 = static_cast< long >(val2);
39426 }
39427 {
39428 PyThreadState* __tstate = wxPyBeginAllowThreads();
39429 (arg1)->UpdateWindowUI(arg2);
39430 wxPyEndAllowThreads(__tstate);
39431 if (PyErr_Occurred()) SWIG_fail;
39432 }
39433 resultobj = SWIG_Py_Void();
39434 return resultobj;
39435 fail:
39436 return NULL;
39437 }
39438
39439
39440 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39441 PyObject *resultobj = 0;
39442 wxWindow *arg1 = (wxWindow *) 0 ;
39443 wxMenu *arg2 = (wxMenu *) 0 ;
39444 int arg3 = (int) -1 ;
39445 int arg4 = (int) -1 ;
39446 bool result;
39447 void *argp1 = 0 ;
39448 int res1 = 0 ;
39449 void *argp2 = 0 ;
39450 int res2 = 0 ;
39451 int val3 ;
39452 int ecode3 = 0 ;
39453 int val4 ;
39454 int ecode4 = 0 ;
39455 PyObject * obj0 = 0 ;
39456 PyObject * obj1 = 0 ;
39457 PyObject * obj2 = 0 ;
39458 PyObject * obj3 = 0 ;
39459 char * kwnames[] = {
39460 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39461 };
39462
39463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39465 if (!SWIG_IsOK(res1)) {
39466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39467 }
39468 arg1 = reinterpret_cast< wxWindow * >(argp1);
39469 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39470 if (!SWIG_IsOK(res2)) {
39471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39472 }
39473 arg2 = reinterpret_cast< wxMenu * >(argp2);
39474 if (obj2) {
39475 ecode3 = SWIG_AsVal_int(obj2, &val3);
39476 if (!SWIG_IsOK(ecode3)) {
39477 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39478 }
39479 arg3 = static_cast< int >(val3);
39480 }
39481 if (obj3) {
39482 ecode4 = SWIG_AsVal_int(obj3, &val4);
39483 if (!SWIG_IsOK(ecode4)) {
39484 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39485 }
39486 arg4 = static_cast< int >(val4);
39487 }
39488 {
39489 PyThreadState* __tstate = wxPyBeginAllowThreads();
39490 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39491 wxPyEndAllowThreads(__tstate);
39492 if (PyErr_Occurred()) SWIG_fail;
39493 }
39494 {
39495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39496 }
39497 return resultobj;
39498 fail:
39499 return NULL;
39500 }
39501
39502
39503 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39504 PyObject *resultobj = 0;
39505 wxWindow *arg1 = (wxWindow *) 0 ;
39506 wxMenu *arg2 = (wxMenu *) 0 ;
39507 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39508 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39509 bool result;
39510 void *argp1 = 0 ;
39511 int res1 = 0 ;
39512 void *argp2 = 0 ;
39513 int res2 = 0 ;
39514 wxPoint temp3 ;
39515 PyObject * obj0 = 0 ;
39516 PyObject * obj1 = 0 ;
39517 PyObject * obj2 = 0 ;
39518 char * kwnames[] = {
39519 (char *) "self",(char *) "menu",(char *) "pos", NULL
39520 };
39521
39522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39524 if (!SWIG_IsOK(res1)) {
39525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39526 }
39527 arg1 = reinterpret_cast< wxWindow * >(argp1);
39528 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39529 if (!SWIG_IsOK(res2)) {
39530 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39531 }
39532 arg2 = reinterpret_cast< wxMenu * >(argp2);
39533 if (obj2) {
39534 {
39535 arg3 = &temp3;
39536 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39537 }
39538 }
39539 {
39540 PyThreadState* __tstate = wxPyBeginAllowThreads();
39541 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39542 wxPyEndAllowThreads(__tstate);
39543 if (PyErr_Occurred()) SWIG_fail;
39544 }
39545 {
39546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39547 }
39548 return resultobj;
39549 fail:
39550 return NULL;
39551 }
39552
39553
39554 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39555 PyObject *resultobj = 0;
39556 wxWindow *arg1 = (wxWindow *) 0 ;
39557 bool result;
39558 void *argp1 = 0 ;
39559 int res1 = 0 ;
39560 PyObject *swig_obj[1] ;
39561
39562 if (!args) SWIG_fail;
39563 swig_obj[0] = args;
39564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39565 if (!SWIG_IsOK(res1)) {
39566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39567 }
39568 arg1 = reinterpret_cast< wxWindow * >(argp1);
39569 {
39570 PyThreadState* __tstate = wxPyBeginAllowThreads();
39571 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39572 wxPyEndAllowThreads(__tstate);
39573 if (PyErr_Occurred()) SWIG_fail;
39574 }
39575 {
39576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39577 }
39578 return resultobj;
39579 fail:
39580 return NULL;
39581 }
39582
39583
39584 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39585 PyObject *resultobj = 0;
39586 wxWindow *arg1 = (wxWindow *) 0 ;
39587 long result;
39588 void *argp1 = 0 ;
39589 int res1 = 0 ;
39590 PyObject *swig_obj[1] ;
39591
39592 if (!args) SWIG_fail;
39593 swig_obj[0] = args;
39594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39595 if (!SWIG_IsOK(res1)) {
39596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39597 }
39598 arg1 = reinterpret_cast< wxWindow * >(argp1);
39599 {
39600 PyThreadState* __tstate = wxPyBeginAllowThreads();
39601 result = (long)wxWindow_GetHandle(arg1);
39602 wxPyEndAllowThreads(__tstate);
39603 if (PyErr_Occurred()) SWIG_fail;
39604 }
39605 resultobj = SWIG_From_long(static_cast< long >(result));
39606 return resultobj;
39607 fail:
39608 return NULL;
39609 }
39610
39611
39612 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39613 PyObject *resultobj = 0;
39614 wxWindow *arg1 = (wxWindow *) 0 ;
39615 long arg2 ;
39616 void *argp1 = 0 ;
39617 int res1 = 0 ;
39618 long val2 ;
39619 int ecode2 = 0 ;
39620 PyObject * obj0 = 0 ;
39621 PyObject * obj1 = 0 ;
39622 char * kwnames[] = {
39623 (char *) "self",(char *) "handle", NULL
39624 };
39625
39626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39628 if (!SWIG_IsOK(res1)) {
39629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39630 }
39631 arg1 = reinterpret_cast< wxWindow * >(argp1);
39632 ecode2 = SWIG_AsVal_long(obj1, &val2);
39633 if (!SWIG_IsOK(ecode2)) {
39634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39635 }
39636 arg2 = static_cast< long >(val2);
39637 {
39638 PyThreadState* __tstate = wxPyBeginAllowThreads();
39639 wxWindow_AssociateHandle(arg1,arg2);
39640 wxPyEndAllowThreads(__tstate);
39641 if (PyErr_Occurred()) SWIG_fail;
39642 }
39643 resultobj = SWIG_Py_Void();
39644 return resultobj;
39645 fail:
39646 return NULL;
39647 }
39648
39649
39650 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39651 PyObject *resultobj = 0;
39652 wxWindow *arg1 = (wxWindow *) 0 ;
39653 void *argp1 = 0 ;
39654 int res1 = 0 ;
39655 PyObject *swig_obj[1] ;
39656
39657 if (!args) SWIG_fail;
39658 swig_obj[0] = args;
39659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39660 if (!SWIG_IsOK(res1)) {
39661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39662 }
39663 arg1 = reinterpret_cast< wxWindow * >(argp1);
39664 {
39665 PyThreadState* __tstate = wxPyBeginAllowThreads();
39666 (arg1)->DissociateHandle();
39667 wxPyEndAllowThreads(__tstate);
39668 if (PyErr_Occurred()) SWIG_fail;
39669 }
39670 resultobj = SWIG_Py_Void();
39671 return resultobj;
39672 fail:
39673 return NULL;
39674 }
39675
39676
39677 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39678 PyObject *resultobj = 0;
39679 wxWindow *arg1 = (wxWindow *) 0 ;
39680 int arg2 ;
39681 bool result;
39682 void *argp1 = 0 ;
39683 int res1 = 0 ;
39684 int val2 ;
39685 int ecode2 = 0 ;
39686 PyObject * obj0 = 0 ;
39687 PyObject * obj1 = 0 ;
39688 char * kwnames[] = {
39689 (char *) "self",(char *) "orient", NULL
39690 };
39691
39692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
39693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39694 if (!SWIG_IsOK(res1)) {
39695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
39696 }
39697 arg1 = reinterpret_cast< wxWindow * >(argp1);
39698 ecode2 = SWIG_AsVal_int(obj1, &val2);
39699 if (!SWIG_IsOK(ecode2)) {
39700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39701 }
39702 arg2 = static_cast< int >(val2);
39703 {
39704 PyThreadState* __tstate = wxPyBeginAllowThreads();
39705 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39706 wxPyEndAllowThreads(__tstate);
39707 if (PyErr_Occurred()) SWIG_fail;
39708 }
39709 {
39710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39711 }
39712 return resultobj;
39713 fail:
39714 return NULL;
39715 }
39716
39717
39718 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39719 PyObject *resultobj = 0;
39720 wxWindow *arg1 = (wxWindow *) 0 ;
39721 int arg2 ;
39722 int arg3 ;
39723 int arg4 ;
39724 int arg5 ;
39725 bool arg6 = (bool) true ;
39726 void *argp1 = 0 ;
39727 int res1 = 0 ;
39728 int val2 ;
39729 int ecode2 = 0 ;
39730 int val3 ;
39731 int ecode3 = 0 ;
39732 int val4 ;
39733 int ecode4 = 0 ;
39734 int val5 ;
39735 int ecode5 = 0 ;
39736 bool val6 ;
39737 int ecode6 = 0 ;
39738 PyObject * obj0 = 0 ;
39739 PyObject * obj1 = 0 ;
39740 PyObject * obj2 = 0 ;
39741 PyObject * obj3 = 0 ;
39742 PyObject * obj4 = 0 ;
39743 PyObject * obj5 = 0 ;
39744 char * kwnames[] = {
39745 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
39746 };
39747
39748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39750 if (!SWIG_IsOK(res1)) {
39751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
39752 }
39753 arg1 = reinterpret_cast< wxWindow * >(argp1);
39754 ecode2 = SWIG_AsVal_int(obj1, &val2);
39755 if (!SWIG_IsOK(ecode2)) {
39756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
39757 }
39758 arg2 = static_cast< int >(val2);
39759 ecode3 = SWIG_AsVal_int(obj2, &val3);
39760 if (!SWIG_IsOK(ecode3)) {
39761 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
39762 }
39763 arg3 = static_cast< int >(val3);
39764 ecode4 = SWIG_AsVal_int(obj3, &val4);
39765 if (!SWIG_IsOK(ecode4)) {
39766 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
39767 }
39768 arg4 = static_cast< int >(val4);
39769 ecode5 = SWIG_AsVal_int(obj4, &val5);
39770 if (!SWIG_IsOK(ecode5)) {
39771 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
39772 }
39773 arg5 = static_cast< int >(val5);
39774 if (obj5) {
39775 ecode6 = SWIG_AsVal_bool(obj5, &val6);
39776 if (!SWIG_IsOK(ecode6)) {
39777 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
39778 }
39779 arg6 = static_cast< bool >(val6);
39780 }
39781 {
39782 PyThreadState* __tstate = wxPyBeginAllowThreads();
39783 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
39784 wxPyEndAllowThreads(__tstate);
39785 if (PyErr_Occurred()) SWIG_fail;
39786 }
39787 resultobj = SWIG_Py_Void();
39788 return resultobj;
39789 fail:
39790 return NULL;
39791 }
39792
39793
39794 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39795 PyObject *resultobj = 0;
39796 wxWindow *arg1 = (wxWindow *) 0 ;
39797 int arg2 ;
39798 int arg3 ;
39799 bool arg4 = (bool) true ;
39800 void *argp1 = 0 ;
39801 int res1 = 0 ;
39802 int val2 ;
39803 int ecode2 = 0 ;
39804 int val3 ;
39805 int ecode3 = 0 ;
39806 bool val4 ;
39807 int ecode4 = 0 ;
39808 PyObject * obj0 = 0 ;
39809 PyObject * obj1 = 0 ;
39810 PyObject * obj2 = 0 ;
39811 PyObject * obj3 = 0 ;
39812 char * kwnames[] = {
39813 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
39814 };
39815
39816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39818 if (!SWIG_IsOK(res1)) {
39819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
39820 }
39821 arg1 = reinterpret_cast< wxWindow * >(argp1);
39822 ecode2 = SWIG_AsVal_int(obj1, &val2);
39823 if (!SWIG_IsOK(ecode2)) {
39824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
39825 }
39826 arg2 = static_cast< int >(val2);
39827 ecode3 = SWIG_AsVal_int(obj2, &val3);
39828 if (!SWIG_IsOK(ecode3)) {
39829 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
39830 }
39831 arg3 = static_cast< int >(val3);
39832 if (obj3) {
39833 ecode4 = SWIG_AsVal_bool(obj3, &val4);
39834 if (!SWIG_IsOK(ecode4)) {
39835 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
39836 }
39837 arg4 = static_cast< bool >(val4);
39838 }
39839 {
39840 PyThreadState* __tstate = wxPyBeginAllowThreads();
39841 (arg1)->SetScrollPos(arg2,arg3,arg4);
39842 wxPyEndAllowThreads(__tstate);
39843 if (PyErr_Occurred()) SWIG_fail;
39844 }
39845 resultobj = SWIG_Py_Void();
39846 return resultobj;
39847 fail:
39848 return NULL;
39849 }
39850
39851
39852 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39853 PyObject *resultobj = 0;
39854 wxWindow *arg1 = (wxWindow *) 0 ;
39855 int arg2 ;
39856 int result;
39857 void *argp1 = 0 ;
39858 int res1 = 0 ;
39859 int val2 ;
39860 int ecode2 = 0 ;
39861 PyObject * obj0 = 0 ;
39862 PyObject * obj1 = 0 ;
39863 char * kwnames[] = {
39864 (char *) "self",(char *) "orientation", NULL
39865 };
39866
39867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
39868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39869 if (!SWIG_IsOK(res1)) {
39870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
39871 }
39872 arg1 = reinterpret_cast< wxWindow * >(argp1);
39873 ecode2 = SWIG_AsVal_int(obj1, &val2);
39874 if (!SWIG_IsOK(ecode2)) {
39875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
39876 }
39877 arg2 = static_cast< int >(val2);
39878 {
39879 PyThreadState* __tstate = wxPyBeginAllowThreads();
39880 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
39881 wxPyEndAllowThreads(__tstate);
39882 if (PyErr_Occurred()) SWIG_fail;
39883 }
39884 resultobj = SWIG_From_int(static_cast< int >(result));
39885 return resultobj;
39886 fail:
39887 return NULL;
39888 }
39889
39890
39891 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39892 PyObject *resultobj = 0;
39893 wxWindow *arg1 = (wxWindow *) 0 ;
39894 int arg2 ;
39895 int result;
39896 void *argp1 = 0 ;
39897 int res1 = 0 ;
39898 int val2 ;
39899 int ecode2 = 0 ;
39900 PyObject * obj0 = 0 ;
39901 PyObject * obj1 = 0 ;
39902 char * kwnames[] = {
39903 (char *) "self",(char *) "orientation", NULL
39904 };
39905
39906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
39907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39908 if (!SWIG_IsOK(res1)) {
39909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
39910 }
39911 arg1 = reinterpret_cast< wxWindow * >(argp1);
39912 ecode2 = SWIG_AsVal_int(obj1, &val2);
39913 if (!SWIG_IsOK(ecode2)) {
39914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
39915 }
39916 arg2 = static_cast< int >(val2);
39917 {
39918 PyThreadState* __tstate = wxPyBeginAllowThreads();
39919 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
39920 wxPyEndAllowThreads(__tstate);
39921 if (PyErr_Occurred()) SWIG_fail;
39922 }
39923 resultobj = SWIG_From_int(static_cast< int >(result));
39924 return resultobj;
39925 fail:
39926 return NULL;
39927 }
39928
39929
39930 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39931 PyObject *resultobj = 0;
39932 wxWindow *arg1 = (wxWindow *) 0 ;
39933 int arg2 ;
39934 int result;
39935 void *argp1 = 0 ;
39936 int res1 = 0 ;
39937 int val2 ;
39938 int ecode2 = 0 ;
39939 PyObject * obj0 = 0 ;
39940 PyObject * obj1 = 0 ;
39941 char * kwnames[] = {
39942 (char *) "self",(char *) "orientation", NULL
39943 };
39944
39945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
39946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39947 if (!SWIG_IsOK(res1)) {
39948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
39949 }
39950 arg1 = reinterpret_cast< wxWindow * >(argp1);
39951 ecode2 = SWIG_AsVal_int(obj1, &val2);
39952 if (!SWIG_IsOK(ecode2)) {
39953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
39954 }
39955 arg2 = static_cast< int >(val2);
39956 {
39957 PyThreadState* __tstate = wxPyBeginAllowThreads();
39958 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
39959 wxPyEndAllowThreads(__tstate);
39960 if (PyErr_Occurred()) SWIG_fail;
39961 }
39962 resultobj = SWIG_From_int(static_cast< int >(result));
39963 return resultobj;
39964 fail:
39965 return NULL;
39966 }
39967
39968
39969 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39970 PyObject *resultobj = 0;
39971 wxWindow *arg1 = (wxWindow *) 0 ;
39972 int arg2 ;
39973 int arg3 ;
39974 wxRect *arg4 = (wxRect *) NULL ;
39975 void *argp1 = 0 ;
39976 int res1 = 0 ;
39977 int val2 ;
39978 int ecode2 = 0 ;
39979 int val3 ;
39980 int ecode3 = 0 ;
39981 void *argp4 = 0 ;
39982 int res4 = 0 ;
39983 PyObject * obj0 = 0 ;
39984 PyObject * obj1 = 0 ;
39985 PyObject * obj2 = 0 ;
39986 PyObject * obj3 = 0 ;
39987 char * kwnames[] = {
39988 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
39989 };
39990
39991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39993 if (!SWIG_IsOK(res1)) {
39994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
39995 }
39996 arg1 = reinterpret_cast< wxWindow * >(argp1);
39997 ecode2 = SWIG_AsVal_int(obj1, &val2);
39998 if (!SWIG_IsOK(ecode2)) {
39999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
40000 }
40001 arg2 = static_cast< int >(val2);
40002 ecode3 = SWIG_AsVal_int(obj2, &val3);
40003 if (!SWIG_IsOK(ecode3)) {
40004 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
40005 }
40006 arg3 = static_cast< int >(val3);
40007 if (obj3) {
40008 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
40009 if (!SWIG_IsOK(res4)) {
40010 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
40011 }
40012 arg4 = reinterpret_cast< wxRect * >(argp4);
40013 }
40014 {
40015 PyThreadState* __tstate = wxPyBeginAllowThreads();
40016 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
40017 wxPyEndAllowThreads(__tstate);
40018 if (PyErr_Occurred()) SWIG_fail;
40019 }
40020 resultobj = SWIG_Py_Void();
40021 return resultobj;
40022 fail:
40023 return NULL;
40024 }
40025
40026
40027 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40028 PyObject *resultobj = 0;
40029 wxWindow *arg1 = (wxWindow *) 0 ;
40030 int arg2 ;
40031 bool result;
40032 void *argp1 = 0 ;
40033 int res1 = 0 ;
40034 int val2 ;
40035 int ecode2 = 0 ;
40036 PyObject * obj0 = 0 ;
40037 PyObject * obj1 = 0 ;
40038 char * kwnames[] = {
40039 (char *) "self",(char *) "lines", NULL
40040 };
40041
40042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40044 if (!SWIG_IsOK(res1)) {
40045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40046 }
40047 arg1 = reinterpret_cast< wxWindow * >(argp1);
40048 ecode2 = SWIG_AsVal_int(obj1, &val2);
40049 if (!SWIG_IsOK(ecode2)) {
40050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40051 }
40052 arg2 = static_cast< int >(val2);
40053 {
40054 PyThreadState* __tstate = wxPyBeginAllowThreads();
40055 result = (bool)(arg1)->ScrollLines(arg2);
40056 wxPyEndAllowThreads(__tstate);
40057 if (PyErr_Occurred()) SWIG_fail;
40058 }
40059 {
40060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40061 }
40062 return resultobj;
40063 fail:
40064 return NULL;
40065 }
40066
40067
40068 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40069 PyObject *resultobj = 0;
40070 wxWindow *arg1 = (wxWindow *) 0 ;
40071 int arg2 ;
40072 bool result;
40073 void *argp1 = 0 ;
40074 int res1 = 0 ;
40075 int val2 ;
40076 int ecode2 = 0 ;
40077 PyObject * obj0 = 0 ;
40078 PyObject * obj1 = 0 ;
40079 char * kwnames[] = {
40080 (char *) "self",(char *) "pages", NULL
40081 };
40082
40083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40085 if (!SWIG_IsOK(res1)) {
40086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40087 }
40088 arg1 = reinterpret_cast< wxWindow * >(argp1);
40089 ecode2 = SWIG_AsVal_int(obj1, &val2);
40090 if (!SWIG_IsOK(ecode2)) {
40091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40092 }
40093 arg2 = static_cast< int >(val2);
40094 {
40095 PyThreadState* __tstate = wxPyBeginAllowThreads();
40096 result = (bool)(arg1)->ScrollPages(arg2);
40097 wxPyEndAllowThreads(__tstate);
40098 if (PyErr_Occurred()) SWIG_fail;
40099 }
40100 {
40101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40102 }
40103 return resultobj;
40104 fail:
40105 return NULL;
40106 }
40107
40108
40109 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40110 PyObject *resultobj = 0;
40111 wxWindow *arg1 = (wxWindow *) 0 ;
40112 bool result;
40113 void *argp1 = 0 ;
40114 int res1 = 0 ;
40115 PyObject *swig_obj[1] ;
40116
40117 if (!args) SWIG_fail;
40118 swig_obj[0] = args;
40119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40120 if (!SWIG_IsOK(res1)) {
40121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40122 }
40123 arg1 = reinterpret_cast< wxWindow * >(argp1);
40124 {
40125 PyThreadState* __tstate = wxPyBeginAllowThreads();
40126 result = (bool)(arg1)->LineUp();
40127 wxPyEndAllowThreads(__tstate);
40128 if (PyErr_Occurred()) SWIG_fail;
40129 }
40130 {
40131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40132 }
40133 return resultobj;
40134 fail:
40135 return NULL;
40136 }
40137
40138
40139 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40140 PyObject *resultobj = 0;
40141 wxWindow *arg1 = (wxWindow *) 0 ;
40142 bool result;
40143 void *argp1 = 0 ;
40144 int res1 = 0 ;
40145 PyObject *swig_obj[1] ;
40146
40147 if (!args) SWIG_fail;
40148 swig_obj[0] = args;
40149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40150 if (!SWIG_IsOK(res1)) {
40151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40152 }
40153 arg1 = reinterpret_cast< wxWindow * >(argp1);
40154 {
40155 PyThreadState* __tstate = wxPyBeginAllowThreads();
40156 result = (bool)(arg1)->LineDown();
40157 wxPyEndAllowThreads(__tstate);
40158 if (PyErr_Occurred()) SWIG_fail;
40159 }
40160 {
40161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40162 }
40163 return resultobj;
40164 fail:
40165 return NULL;
40166 }
40167
40168
40169 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40170 PyObject *resultobj = 0;
40171 wxWindow *arg1 = (wxWindow *) 0 ;
40172 bool result;
40173 void *argp1 = 0 ;
40174 int res1 = 0 ;
40175 PyObject *swig_obj[1] ;
40176
40177 if (!args) SWIG_fail;
40178 swig_obj[0] = args;
40179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40180 if (!SWIG_IsOK(res1)) {
40181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40182 }
40183 arg1 = reinterpret_cast< wxWindow * >(argp1);
40184 {
40185 PyThreadState* __tstate = wxPyBeginAllowThreads();
40186 result = (bool)(arg1)->PageUp();
40187 wxPyEndAllowThreads(__tstate);
40188 if (PyErr_Occurred()) SWIG_fail;
40189 }
40190 {
40191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40192 }
40193 return resultobj;
40194 fail:
40195 return NULL;
40196 }
40197
40198
40199 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40200 PyObject *resultobj = 0;
40201 wxWindow *arg1 = (wxWindow *) 0 ;
40202 bool result;
40203 void *argp1 = 0 ;
40204 int res1 = 0 ;
40205 PyObject *swig_obj[1] ;
40206
40207 if (!args) SWIG_fail;
40208 swig_obj[0] = args;
40209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40210 if (!SWIG_IsOK(res1)) {
40211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40212 }
40213 arg1 = reinterpret_cast< wxWindow * >(argp1);
40214 {
40215 PyThreadState* __tstate = wxPyBeginAllowThreads();
40216 result = (bool)(arg1)->PageDown();
40217 wxPyEndAllowThreads(__tstate);
40218 if (PyErr_Occurred()) SWIG_fail;
40219 }
40220 {
40221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40222 }
40223 return resultobj;
40224 fail:
40225 return NULL;
40226 }
40227
40228
40229 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40230 PyObject *resultobj = 0;
40231 wxWindow *arg1 = (wxWindow *) 0 ;
40232 wxString *arg2 = 0 ;
40233 void *argp1 = 0 ;
40234 int res1 = 0 ;
40235 bool temp2 = false ;
40236 PyObject * obj0 = 0 ;
40237 PyObject * obj1 = 0 ;
40238 char * kwnames[] = {
40239 (char *) "self",(char *) "text", NULL
40240 };
40241
40242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40244 if (!SWIG_IsOK(res1)) {
40245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40246 }
40247 arg1 = reinterpret_cast< wxWindow * >(argp1);
40248 {
40249 arg2 = wxString_in_helper(obj1);
40250 if (arg2 == NULL) SWIG_fail;
40251 temp2 = true;
40252 }
40253 {
40254 PyThreadState* __tstate = wxPyBeginAllowThreads();
40255 (arg1)->SetHelpText((wxString const &)*arg2);
40256 wxPyEndAllowThreads(__tstate);
40257 if (PyErr_Occurred()) SWIG_fail;
40258 }
40259 resultobj = SWIG_Py_Void();
40260 {
40261 if (temp2)
40262 delete arg2;
40263 }
40264 return resultobj;
40265 fail:
40266 {
40267 if (temp2)
40268 delete arg2;
40269 }
40270 return NULL;
40271 }
40272
40273
40274 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40275 PyObject *resultobj = 0;
40276 wxWindow *arg1 = (wxWindow *) 0 ;
40277 wxString *arg2 = 0 ;
40278 void *argp1 = 0 ;
40279 int res1 = 0 ;
40280 bool temp2 = false ;
40281 PyObject * obj0 = 0 ;
40282 PyObject * obj1 = 0 ;
40283 char * kwnames[] = {
40284 (char *) "self",(char *) "text", NULL
40285 };
40286
40287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40289 if (!SWIG_IsOK(res1)) {
40290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40291 }
40292 arg1 = reinterpret_cast< wxWindow * >(argp1);
40293 {
40294 arg2 = wxString_in_helper(obj1);
40295 if (arg2 == NULL) SWIG_fail;
40296 temp2 = true;
40297 }
40298 {
40299 PyThreadState* __tstate = wxPyBeginAllowThreads();
40300 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40301 wxPyEndAllowThreads(__tstate);
40302 if (PyErr_Occurred()) SWIG_fail;
40303 }
40304 resultobj = SWIG_Py_Void();
40305 {
40306 if (temp2)
40307 delete arg2;
40308 }
40309 return resultobj;
40310 fail:
40311 {
40312 if (temp2)
40313 delete arg2;
40314 }
40315 return NULL;
40316 }
40317
40318
40319 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40320 PyObject *resultobj = 0;
40321 wxWindow *arg1 = (wxWindow *) 0 ;
40322 wxPoint *arg2 = 0 ;
40323 wxHelpEvent::Origin arg3 ;
40324 wxString result;
40325 void *argp1 = 0 ;
40326 int res1 = 0 ;
40327 wxPoint temp2 ;
40328 void *argp3 ;
40329 int res3 = 0 ;
40330 PyObject * obj0 = 0 ;
40331 PyObject * obj1 = 0 ;
40332 PyObject * obj2 = 0 ;
40333 char * kwnames[] = {
40334 (char *) "self",(char *) "pt",(char *) "origin", NULL
40335 };
40336
40337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40339 if (!SWIG_IsOK(res1)) {
40340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40341 }
40342 arg1 = reinterpret_cast< wxWindow * >(argp1);
40343 {
40344 arg2 = &temp2;
40345 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40346 }
40347 {
40348 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40349 if (!SWIG_IsOK(res3)) {
40350 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40351 }
40352 if (!argp3) {
40353 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40354 } else {
40355 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40356 arg3 = *temp;
40357 if (SWIG_IsNewObj(res3)) delete temp;
40358 }
40359 }
40360 {
40361 PyThreadState* __tstate = wxPyBeginAllowThreads();
40362 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40363 wxPyEndAllowThreads(__tstate);
40364 if (PyErr_Occurred()) SWIG_fail;
40365 }
40366 {
40367 #if wxUSE_UNICODE
40368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40369 #else
40370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40371 #endif
40372 }
40373 return resultobj;
40374 fail:
40375 return NULL;
40376 }
40377
40378
40379 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40380 PyObject *resultobj = 0;
40381 wxWindow *arg1 = (wxWindow *) 0 ;
40382 wxString result;
40383 void *argp1 = 0 ;
40384 int res1 = 0 ;
40385 PyObject *swig_obj[1] ;
40386
40387 if (!args) SWIG_fail;
40388 swig_obj[0] = args;
40389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40390 if (!SWIG_IsOK(res1)) {
40391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40392 }
40393 arg1 = reinterpret_cast< wxWindow * >(argp1);
40394 {
40395 PyThreadState* __tstate = wxPyBeginAllowThreads();
40396 result = ((wxWindow const *)arg1)->GetHelpText();
40397 wxPyEndAllowThreads(__tstate);
40398 if (PyErr_Occurred()) SWIG_fail;
40399 }
40400 {
40401 #if wxUSE_UNICODE
40402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40403 #else
40404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40405 #endif
40406 }
40407 return resultobj;
40408 fail:
40409 return NULL;
40410 }
40411
40412
40413 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40414 PyObject *resultobj = 0;
40415 wxWindow *arg1 = (wxWindow *) 0 ;
40416 wxString *arg2 = 0 ;
40417 void *argp1 = 0 ;
40418 int res1 = 0 ;
40419 bool temp2 = false ;
40420 PyObject * obj0 = 0 ;
40421 PyObject * obj1 = 0 ;
40422 char * kwnames[] = {
40423 (char *) "self",(char *) "tip", NULL
40424 };
40425
40426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40428 if (!SWIG_IsOK(res1)) {
40429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40430 }
40431 arg1 = reinterpret_cast< wxWindow * >(argp1);
40432 {
40433 arg2 = wxString_in_helper(obj1);
40434 if (arg2 == NULL) SWIG_fail;
40435 temp2 = true;
40436 }
40437 {
40438 PyThreadState* __tstate = wxPyBeginAllowThreads();
40439 (arg1)->SetToolTip((wxString const &)*arg2);
40440 wxPyEndAllowThreads(__tstate);
40441 if (PyErr_Occurred()) SWIG_fail;
40442 }
40443 resultobj = SWIG_Py_Void();
40444 {
40445 if (temp2)
40446 delete arg2;
40447 }
40448 return resultobj;
40449 fail:
40450 {
40451 if (temp2)
40452 delete arg2;
40453 }
40454 return NULL;
40455 }
40456
40457
40458 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40459 PyObject *resultobj = 0;
40460 wxWindow *arg1 = (wxWindow *) 0 ;
40461 wxToolTip *arg2 = (wxToolTip *) 0 ;
40462 void *argp1 = 0 ;
40463 int res1 = 0 ;
40464 int res2 = 0 ;
40465 PyObject * obj0 = 0 ;
40466 PyObject * obj1 = 0 ;
40467 char * kwnames[] = {
40468 (char *) "self",(char *) "tip", NULL
40469 };
40470
40471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40473 if (!SWIG_IsOK(res1)) {
40474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40475 }
40476 arg1 = reinterpret_cast< wxWindow * >(argp1);
40477 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40478 if (!SWIG_IsOK(res2)) {
40479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40480 }
40481 {
40482 PyThreadState* __tstate = wxPyBeginAllowThreads();
40483 (arg1)->SetToolTip(arg2);
40484 wxPyEndAllowThreads(__tstate);
40485 if (PyErr_Occurred()) SWIG_fail;
40486 }
40487 resultobj = SWIG_Py_Void();
40488 return resultobj;
40489 fail:
40490 return NULL;
40491 }
40492
40493
40494 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40495 PyObject *resultobj = 0;
40496 wxWindow *arg1 = (wxWindow *) 0 ;
40497 wxToolTip *result = 0 ;
40498 void *argp1 = 0 ;
40499 int res1 = 0 ;
40500 PyObject *swig_obj[1] ;
40501
40502 if (!args) SWIG_fail;
40503 swig_obj[0] = args;
40504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40505 if (!SWIG_IsOK(res1)) {
40506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40507 }
40508 arg1 = reinterpret_cast< wxWindow * >(argp1);
40509 {
40510 PyThreadState* __tstate = wxPyBeginAllowThreads();
40511 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40512 wxPyEndAllowThreads(__tstate);
40513 if (PyErr_Occurred()) SWIG_fail;
40514 }
40515 {
40516 resultobj = wxPyMake_wxObject(result, (bool)0);
40517 }
40518 return resultobj;
40519 fail:
40520 return NULL;
40521 }
40522
40523
40524 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40525 PyObject *resultobj = 0;
40526 wxWindow *arg1 = (wxWindow *) 0 ;
40527 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40528 void *argp1 = 0 ;
40529 int res1 = 0 ;
40530 int res2 = 0 ;
40531 PyObject * obj0 = 0 ;
40532 PyObject * obj1 = 0 ;
40533 char * kwnames[] = {
40534 (char *) "self",(char *) "dropTarget", NULL
40535 };
40536
40537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40539 if (!SWIG_IsOK(res1)) {
40540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40541 }
40542 arg1 = reinterpret_cast< wxWindow * >(argp1);
40543 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40544 if (!SWIG_IsOK(res2)) {
40545 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40546 }
40547 {
40548 PyThreadState* __tstate = wxPyBeginAllowThreads();
40549 (arg1)->SetDropTarget(arg2);
40550 wxPyEndAllowThreads(__tstate);
40551 if (PyErr_Occurred()) SWIG_fail;
40552 }
40553 resultobj = SWIG_Py_Void();
40554 return resultobj;
40555 fail:
40556 return NULL;
40557 }
40558
40559
40560 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40561 PyObject *resultobj = 0;
40562 wxWindow *arg1 = (wxWindow *) 0 ;
40563 wxPyDropTarget *result = 0 ;
40564 void *argp1 = 0 ;
40565 int res1 = 0 ;
40566 PyObject *swig_obj[1] ;
40567
40568 if (!args) SWIG_fail;
40569 swig_obj[0] = args;
40570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40571 if (!SWIG_IsOK(res1)) {
40572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40573 }
40574 arg1 = reinterpret_cast< wxWindow * >(argp1);
40575 {
40576 PyThreadState* __tstate = wxPyBeginAllowThreads();
40577 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40578 wxPyEndAllowThreads(__tstate);
40579 if (PyErr_Occurred()) SWIG_fail;
40580 }
40581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40582 return resultobj;
40583 fail:
40584 return NULL;
40585 }
40586
40587
40588 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40589 PyObject *resultobj = 0;
40590 wxWindow *arg1 = (wxWindow *) 0 ;
40591 bool arg2 ;
40592 void *argp1 = 0 ;
40593 int res1 = 0 ;
40594 bool val2 ;
40595 int ecode2 = 0 ;
40596 PyObject * obj0 = 0 ;
40597 PyObject * obj1 = 0 ;
40598 char * kwnames[] = {
40599 (char *) "self",(char *) "accept", NULL
40600 };
40601
40602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40604 if (!SWIG_IsOK(res1)) {
40605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40606 }
40607 arg1 = reinterpret_cast< wxWindow * >(argp1);
40608 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40609 if (!SWIG_IsOK(ecode2)) {
40610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40611 }
40612 arg2 = static_cast< bool >(val2);
40613 {
40614 PyThreadState* __tstate = wxPyBeginAllowThreads();
40615 wxWindow_DragAcceptFiles(arg1,arg2);
40616 wxPyEndAllowThreads(__tstate);
40617 if (PyErr_Occurred()) SWIG_fail;
40618 }
40619 resultobj = SWIG_Py_Void();
40620 return resultobj;
40621 fail:
40622 return NULL;
40623 }
40624
40625
40626 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40627 PyObject *resultobj = 0;
40628 wxWindow *arg1 = (wxWindow *) 0 ;
40629 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40630 void *argp1 = 0 ;
40631 int res1 = 0 ;
40632 int res2 = 0 ;
40633 PyObject * obj0 = 0 ;
40634 PyObject * obj1 = 0 ;
40635 char * kwnames[] = {
40636 (char *) "self",(char *) "constraints", NULL
40637 };
40638
40639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40641 if (!SWIG_IsOK(res1)) {
40642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40643 }
40644 arg1 = reinterpret_cast< wxWindow * >(argp1);
40645 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40646 if (!SWIG_IsOK(res2)) {
40647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40648 }
40649 {
40650 PyThreadState* __tstate = wxPyBeginAllowThreads();
40651 (arg1)->SetConstraints(arg2);
40652 wxPyEndAllowThreads(__tstate);
40653 if (PyErr_Occurred()) SWIG_fail;
40654 }
40655 resultobj = SWIG_Py_Void();
40656 return resultobj;
40657 fail:
40658 return NULL;
40659 }
40660
40661
40662 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40663 PyObject *resultobj = 0;
40664 wxWindow *arg1 = (wxWindow *) 0 ;
40665 wxLayoutConstraints *result = 0 ;
40666 void *argp1 = 0 ;
40667 int res1 = 0 ;
40668 PyObject *swig_obj[1] ;
40669
40670 if (!args) SWIG_fail;
40671 swig_obj[0] = args;
40672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40673 if (!SWIG_IsOK(res1)) {
40674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40675 }
40676 arg1 = reinterpret_cast< wxWindow * >(argp1);
40677 {
40678 PyThreadState* __tstate = wxPyBeginAllowThreads();
40679 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40680 wxPyEndAllowThreads(__tstate);
40681 if (PyErr_Occurred()) SWIG_fail;
40682 }
40683 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40684 return resultobj;
40685 fail:
40686 return NULL;
40687 }
40688
40689
40690 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40691 PyObject *resultobj = 0;
40692 wxWindow *arg1 = (wxWindow *) 0 ;
40693 bool arg2 ;
40694 void *argp1 = 0 ;
40695 int res1 = 0 ;
40696 bool val2 ;
40697 int ecode2 = 0 ;
40698 PyObject * obj0 = 0 ;
40699 PyObject * obj1 = 0 ;
40700 char * kwnames[] = {
40701 (char *) "self",(char *) "autoLayout", NULL
40702 };
40703
40704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40706 if (!SWIG_IsOK(res1)) {
40707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40708 }
40709 arg1 = reinterpret_cast< wxWindow * >(argp1);
40710 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40711 if (!SWIG_IsOK(ecode2)) {
40712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40713 }
40714 arg2 = static_cast< bool >(val2);
40715 {
40716 PyThreadState* __tstate = wxPyBeginAllowThreads();
40717 (arg1)->SetAutoLayout(arg2);
40718 wxPyEndAllowThreads(__tstate);
40719 if (PyErr_Occurred()) SWIG_fail;
40720 }
40721 resultobj = SWIG_Py_Void();
40722 return resultobj;
40723 fail:
40724 return NULL;
40725 }
40726
40727
40728 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40729 PyObject *resultobj = 0;
40730 wxWindow *arg1 = (wxWindow *) 0 ;
40731 bool result;
40732 void *argp1 = 0 ;
40733 int res1 = 0 ;
40734 PyObject *swig_obj[1] ;
40735
40736 if (!args) SWIG_fail;
40737 swig_obj[0] = args;
40738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40739 if (!SWIG_IsOK(res1)) {
40740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
40741 }
40742 arg1 = reinterpret_cast< wxWindow * >(argp1);
40743 {
40744 PyThreadState* __tstate = wxPyBeginAllowThreads();
40745 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
40746 wxPyEndAllowThreads(__tstate);
40747 if (PyErr_Occurred()) SWIG_fail;
40748 }
40749 {
40750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40751 }
40752 return resultobj;
40753 fail:
40754 return NULL;
40755 }
40756
40757
40758 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40759 PyObject *resultobj = 0;
40760 wxWindow *arg1 = (wxWindow *) 0 ;
40761 bool result;
40762 void *argp1 = 0 ;
40763 int res1 = 0 ;
40764 PyObject *swig_obj[1] ;
40765
40766 if (!args) SWIG_fail;
40767 swig_obj[0] = args;
40768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40769 if (!SWIG_IsOK(res1)) {
40770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
40771 }
40772 arg1 = reinterpret_cast< wxWindow * >(argp1);
40773 {
40774 PyThreadState* __tstate = wxPyBeginAllowThreads();
40775 result = (bool)(arg1)->Layout();
40776 wxPyEndAllowThreads(__tstate);
40777 if (PyErr_Occurred()) SWIG_fail;
40778 }
40779 {
40780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40781 }
40782 return resultobj;
40783 fail:
40784 return NULL;
40785 }
40786
40787
40788 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40789 PyObject *resultobj = 0;
40790 wxWindow *arg1 = (wxWindow *) 0 ;
40791 wxSizer *arg2 = (wxSizer *) 0 ;
40792 bool arg3 = (bool) true ;
40793 void *argp1 = 0 ;
40794 int res1 = 0 ;
40795 int res2 = 0 ;
40796 bool val3 ;
40797 int ecode3 = 0 ;
40798 PyObject * obj0 = 0 ;
40799 PyObject * obj1 = 0 ;
40800 PyObject * obj2 = 0 ;
40801 char * kwnames[] = {
40802 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40803 };
40804
40805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40807 if (!SWIG_IsOK(res1)) {
40808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40809 }
40810 arg1 = reinterpret_cast< wxWindow * >(argp1);
40811 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40812 if (!SWIG_IsOK(res2)) {
40813 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40814 }
40815 if (obj2) {
40816 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40817 if (!SWIG_IsOK(ecode3)) {
40818 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
40819 }
40820 arg3 = static_cast< bool >(val3);
40821 }
40822 {
40823 PyThreadState* __tstate = wxPyBeginAllowThreads();
40824 (arg1)->SetSizer(arg2,arg3);
40825 wxPyEndAllowThreads(__tstate);
40826 if (PyErr_Occurred()) SWIG_fail;
40827 }
40828 resultobj = SWIG_Py_Void();
40829 return resultobj;
40830 fail:
40831 return NULL;
40832 }
40833
40834
40835 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40836 PyObject *resultobj = 0;
40837 wxWindow *arg1 = (wxWindow *) 0 ;
40838 wxSizer *arg2 = (wxSizer *) 0 ;
40839 bool arg3 = (bool) true ;
40840 void *argp1 = 0 ;
40841 int res1 = 0 ;
40842 int res2 = 0 ;
40843 bool val3 ;
40844 int ecode3 = 0 ;
40845 PyObject * obj0 = 0 ;
40846 PyObject * obj1 = 0 ;
40847 PyObject * obj2 = 0 ;
40848 char * kwnames[] = {
40849 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40850 };
40851
40852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40854 if (!SWIG_IsOK(res1)) {
40855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
40856 }
40857 arg1 = reinterpret_cast< wxWindow * >(argp1);
40858 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40859 if (!SWIG_IsOK(res2)) {
40860 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
40861 }
40862 if (obj2) {
40863 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40864 if (!SWIG_IsOK(ecode3)) {
40865 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
40866 }
40867 arg3 = static_cast< bool >(val3);
40868 }
40869 {
40870 PyThreadState* __tstate = wxPyBeginAllowThreads();
40871 (arg1)->SetSizerAndFit(arg2,arg3);
40872 wxPyEndAllowThreads(__tstate);
40873 if (PyErr_Occurred()) SWIG_fail;
40874 }
40875 resultobj = SWIG_Py_Void();
40876 return resultobj;
40877 fail:
40878 return NULL;
40879 }
40880
40881
40882 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40883 PyObject *resultobj = 0;
40884 wxWindow *arg1 = (wxWindow *) 0 ;
40885 wxSizer *result = 0 ;
40886 void *argp1 = 0 ;
40887 int res1 = 0 ;
40888 PyObject *swig_obj[1] ;
40889
40890 if (!args) SWIG_fail;
40891 swig_obj[0] = args;
40892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40893 if (!SWIG_IsOK(res1)) {
40894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40895 }
40896 arg1 = reinterpret_cast< wxWindow * >(argp1);
40897 {
40898 PyThreadState* __tstate = wxPyBeginAllowThreads();
40899 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
40900 wxPyEndAllowThreads(__tstate);
40901 if (PyErr_Occurred()) SWIG_fail;
40902 }
40903 {
40904 resultobj = wxPyMake_wxObject(result, (bool)0);
40905 }
40906 return resultobj;
40907 fail:
40908 return NULL;
40909 }
40910
40911
40912 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40913 PyObject *resultobj = 0;
40914 wxWindow *arg1 = (wxWindow *) 0 ;
40915 wxSizer *arg2 = (wxSizer *) 0 ;
40916 void *argp1 = 0 ;
40917 int res1 = 0 ;
40918 void *argp2 = 0 ;
40919 int res2 = 0 ;
40920 PyObject * obj0 = 0 ;
40921 PyObject * obj1 = 0 ;
40922 char * kwnames[] = {
40923 (char *) "self",(char *) "sizer", NULL
40924 };
40925
40926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
40927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40928 if (!SWIG_IsOK(res1)) {
40929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40930 }
40931 arg1 = reinterpret_cast< wxWindow * >(argp1);
40932 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
40933 if (!SWIG_IsOK(res2)) {
40934 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40935 }
40936 arg2 = reinterpret_cast< wxSizer * >(argp2);
40937 {
40938 PyThreadState* __tstate = wxPyBeginAllowThreads();
40939 (arg1)->SetContainingSizer(arg2);
40940 wxPyEndAllowThreads(__tstate);
40941 if (PyErr_Occurred()) SWIG_fail;
40942 }
40943 resultobj = SWIG_Py_Void();
40944 return resultobj;
40945 fail:
40946 return NULL;
40947 }
40948
40949
40950 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40951 PyObject *resultobj = 0;
40952 wxWindow *arg1 = (wxWindow *) 0 ;
40953 wxSizer *result = 0 ;
40954 void *argp1 = 0 ;
40955 int res1 = 0 ;
40956 PyObject *swig_obj[1] ;
40957
40958 if (!args) SWIG_fail;
40959 swig_obj[0] = args;
40960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40961 if (!SWIG_IsOK(res1)) {
40962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40963 }
40964 arg1 = reinterpret_cast< wxWindow * >(argp1);
40965 {
40966 PyThreadState* __tstate = wxPyBeginAllowThreads();
40967 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
40968 wxPyEndAllowThreads(__tstate);
40969 if (PyErr_Occurred()) SWIG_fail;
40970 }
40971 {
40972 resultobj = wxPyMake_wxObject(result, (bool)0);
40973 }
40974 return resultobj;
40975 fail:
40976 return NULL;
40977 }
40978
40979
40980 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40981 PyObject *resultobj = 0;
40982 wxWindow *arg1 = (wxWindow *) 0 ;
40983 void *argp1 = 0 ;
40984 int res1 = 0 ;
40985 PyObject *swig_obj[1] ;
40986
40987 if (!args) SWIG_fail;
40988 swig_obj[0] = args;
40989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40990 if (!SWIG_IsOK(res1)) {
40991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
40992 }
40993 arg1 = reinterpret_cast< wxWindow * >(argp1);
40994 {
40995 PyThreadState* __tstate = wxPyBeginAllowThreads();
40996 (arg1)->InheritAttributes();
40997 wxPyEndAllowThreads(__tstate);
40998 if (PyErr_Occurred()) SWIG_fail;
40999 }
41000 resultobj = SWIG_Py_Void();
41001 return resultobj;
41002 fail:
41003 return NULL;
41004 }
41005
41006
41007 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41008 PyObject *resultobj = 0;
41009 wxWindow *arg1 = (wxWindow *) 0 ;
41010 bool result;
41011 void *argp1 = 0 ;
41012 int res1 = 0 ;
41013 PyObject *swig_obj[1] ;
41014
41015 if (!args) SWIG_fail;
41016 swig_obj[0] = args;
41017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41018 if (!SWIG_IsOK(res1)) {
41019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41020 }
41021 arg1 = reinterpret_cast< wxWindow * >(argp1);
41022 {
41023 PyThreadState* __tstate = wxPyBeginAllowThreads();
41024 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41025 wxPyEndAllowThreads(__tstate);
41026 if (PyErr_Occurred()) SWIG_fail;
41027 }
41028 {
41029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41030 }
41031 return resultobj;
41032 fail:
41033 return NULL;
41034 }
41035
41036
41037 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41038 PyObject *resultobj = 0;
41039 wxWindow *arg1 = (wxWindow *) 0 ;
41040 bool result;
41041 void *argp1 = 0 ;
41042 int res1 = 0 ;
41043 PyObject *swig_obj[1] ;
41044
41045 if (!args) SWIG_fail;
41046 swig_obj[0] = args;
41047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41048 if (!SWIG_IsOK(res1)) {
41049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41050 }
41051 arg1 = reinterpret_cast< wxWindow * >(argp1);
41052 {
41053 PyThreadState* __tstate = wxPyBeginAllowThreads();
41054 result = (bool)(arg1)->CanSetTransparent();
41055 wxPyEndAllowThreads(__tstate);
41056 if (PyErr_Occurred()) SWIG_fail;
41057 }
41058 {
41059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41060 }
41061 return resultobj;
41062 fail:
41063 return NULL;
41064 }
41065
41066
41067 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41068 PyObject *resultobj = 0;
41069 wxWindow *arg1 = (wxWindow *) 0 ;
41070 byte arg2 ;
41071 bool result;
41072 void *argp1 = 0 ;
41073 int res1 = 0 ;
41074 unsigned char val2 ;
41075 int ecode2 = 0 ;
41076 PyObject * obj0 = 0 ;
41077 PyObject * obj1 = 0 ;
41078 char * kwnames[] = {
41079 (char *) "self",(char *) "alpha", NULL
41080 };
41081
41082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41084 if (!SWIG_IsOK(res1)) {
41085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41086 }
41087 arg1 = reinterpret_cast< wxWindow * >(argp1);
41088 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41089 if (!SWIG_IsOK(ecode2)) {
41090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41091 }
41092 arg2 = static_cast< byte >(val2);
41093 {
41094 PyThreadState* __tstate = wxPyBeginAllowThreads();
41095 result = (bool)(arg1)->SetTransparent(arg2);
41096 wxPyEndAllowThreads(__tstate);
41097 if (PyErr_Occurred()) SWIG_fail;
41098 }
41099 {
41100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41101 }
41102 return resultobj;
41103 fail:
41104 return NULL;
41105 }
41106
41107
41108 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41109 PyObject *obj;
41110 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41111 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41112 return SWIG_Py_Void();
41113 }
41114
41115 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41116 return SWIG_Python_InitShadowInstance(args);
41117 }
41118
41119 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41120 PyObject *resultobj = 0;
41121 long arg1 ;
41122 wxWindow *arg2 = (wxWindow *) NULL ;
41123 wxWindow *result = 0 ;
41124 long val1 ;
41125 int ecode1 = 0 ;
41126 void *argp2 = 0 ;
41127 int res2 = 0 ;
41128 PyObject * obj0 = 0 ;
41129 PyObject * obj1 = 0 ;
41130 char * kwnames[] = {
41131 (char *) "id",(char *) "parent", NULL
41132 };
41133
41134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41135 ecode1 = SWIG_AsVal_long(obj0, &val1);
41136 if (!SWIG_IsOK(ecode1)) {
41137 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41138 }
41139 arg1 = static_cast< long >(val1);
41140 if (obj1) {
41141 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41142 if (!SWIG_IsOK(res2)) {
41143 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41144 }
41145 arg2 = reinterpret_cast< wxWindow * >(argp2);
41146 }
41147 {
41148 if (!wxPyCheckForApp()) SWIG_fail;
41149 PyThreadState* __tstate = wxPyBeginAllowThreads();
41150 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41151 wxPyEndAllowThreads(__tstate);
41152 if (PyErr_Occurred()) SWIG_fail;
41153 }
41154 {
41155 resultobj = wxPyMake_wxObject(result, 0);
41156 }
41157 return resultobj;
41158 fail:
41159 return NULL;
41160 }
41161
41162
41163 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41164 PyObject *resultobj = 0;
41165 wxString *arg1 = 0 ;
41166 wxWindow *arg2 = (wxWindow *) NULL ;
41167 wxWindow *result = 0 ;
41168 bool temp1 = false ;
41169 void *argp2 = 0 ;
41170 int res2 = 0 ;
41171 PyObject * obj0 = 0 ;
41172 PyObject * obj1 = 0 ;
41173 char * kwnames[] = {
41174 (char *) "name",(char *) "parent", NULL
41175 };
41176
41177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41178 {
41179 arg1 = wxString_in_helper(obj0);
41180 if (arg1 == NULL) SWIG_fail;
41181 temp1 = true;
41182 }
41183 if (obj1) {
41184 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41185 if (!SWIG_IsOK(res2)) {
41186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41187 }
41188 arg2 = reinterpret_cast< wxWindow * >(argp2);
41189 }
41190 {
41191 if (!wxPyCheckForApp()) SWIG_fail;
41192 PyThreadState* __tstate = wxPyBeginAllowThreads();
41193 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41194 wxPyEndAllowThreads(__tstate);
41195 if (PyErr_Occurred()) SWIG_fail;
41196 }
41197 {
41198 resultobj = wxPyMake_wxObject(result, 0);
41199 }
41200 {
41201 if (temp1)
41202 delete arg1;
41203 }
41204 return resultobj;
41205 fail:
41206 {
41207 if (temp1)
41208 delete arg1;
41209 }
41210 return NULL;
41211 }
41212
41213
41214 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41215 PyObject *resultobj = 0;
41216 wxString *arg1 = 0 ;
41217 wxWindow *arg2 = (wxWindow *) NULL ;
41218 wxWindow *result = 0 ;
41219 bool temp1 = false ;
41220 void *argp2 = 0 ;
41221 int res2 = 0 ;
41222 PyObject * obj0 = 0 ;
41223 PyObject * obj1 = 0 ;
41224 char * kwnames[] = {
41225 (char *) "label",(char *) "parent", NULL
41226 };
41227
41228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41229 {
41230 arg1 = wxString_in_helper(obj0);
41231 if (arg1 == NULL) SWIG_fail;
41232 temp1 = true;
41233 }
41234 if (obj1) {
41235 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41236 if (!SWIG_IsOK(res2)) {
41237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41238 }
41239 arg2 = reinterpret_cast< wxWindow * >(argp2);
41240 }
41241 {
41242 if (!wxPyCheckForApp()) SWIG_fail;
41243 PyThreadState* __tstate = wxPyBeginAllowThreads();
41244 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41245 wxPyEndAllowThreads(__tstate);
41246 if (PyErr_Occurred()) SWIG_fail;
41247 }
41248 {
41249 resultobj = wxPyMake_wxObject(result, 0);
41250 }
41251 {
41252 if (temp1)
41253 delete arg1;
41254 }
41255 return resultobj;
41256 fail:
41257 {
41258 if (temp1)
41259 delete arg1;
41260 }
41261 return NULL;
41262 }
41263
41264
41265 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41266 PyObject *resultobj = 0;
41267 wxWindow *arg1 = (wxWindow *) 0 ;
41268 unsigned long arg2 ;
41269 wxWindow *result = 0 ;
41270 void *argp1 = 0 ;
41271 int res1 = 0 ;
41272 unsigned long val2 ;
41273 int ecode2 = 0 ;
41274 PyObject * obj0 = 0 ;
41275 PyObject * obj1 = 0 ;
41276 char * kwnames[] = {
41277 (char *) "parent",(char *) "_hWnd", NULL
41278 };
41279
41280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41282 if (!SWIG_IsOK(res1)) {
41283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41284 }
41285 arg1 = reinterpret_cast< wxWindow * >(argp1);
41286 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41287 if (!SWIG_IsOK(ecode2)) {
41288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41289 }
41290 arg2 = static_cast< unsigned long >(val2);
41291 {
41292 PyThreadState* __tstate = wxPyBeginAllowThreads();
41293 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41294 wxPyEndAllowThreads(__tstate);
41295 if (PyErr_Occurred()) SWIG_fail;
41296 }
41297 {
41298 resultobj = wxPyMake_wxObject(result, 0);
41299 }
41300 return resultobj;
41301 fail:
41302 return NULL;
41303 }
41304
41305
41306 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41307 PyObject *resultobj = 0;
41308 PyObject *result = 0 ;
41309
41310 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41311 {
41312 PyThreadState* __tstate = wxPyBeginAllowThreads();
41313 result = (PyObject *)GetTopLevelWindows();
41314 wxPyEndAllowThreads(__tstate);
41315 if (PyErr_Occurred()) SWIG_fail;
41316 }
41317 resultobj = result;
41318 return resultobj;
41319 fail:
41320 return NULL;
41321 }
41322
41323
41324 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41325 PyObject *resultobj = 0;
41326 wxValidator *result = 0 ;
41327
41328 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41329 {
41330 PyThreadState* __tstate = wxPyBeginAllowThreads();
41331 result = (wxValidator *)new wxValidator();
41332 wxPyEndAllowThreads(__tstate);
41333 if (PyErr_Occurred()) SWIG_fail;
41334 }
41335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41336 return resultobj;
41337 fail:
41338 return NULL;
41339 }
41340
41341
41342 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41343 PyObject *resultobj = 0;
41344 wxValidator *arg1 = (wxValidator *) 0 ;
41345 wxValidator *result = 0 ;
41346 void *argp1 = 0 ;
41347 int res1 = 0 ;
41348 PyObject *swig_obj[1] ;
41349
41350 if (!args) SWIG_fail;
41351 swig_obj[0] = args;
41352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41353 if (!SWIG_IsOK(res1)) {
41354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41355 }
41356 arg1 = reinterpret_cast< wxValidator * >(argp1);
41357 {
41358 PyThreadState* __tstate = wxPyBeginAllowThreads();
41359 result = (wxValidator *)(arg1)->Clone();
41360 wxPyEndAllowThreads(__tstate);
41361 if (PyErr_Occurred()) SWIG_fail;
41362 }
41363 {
41364 resultobj = wxPyMake_wxObject(result, 0);
41365 }
41366 return resultobj;
41367 fail:
41368 return NULL;
41369 }
41370
41371
41372 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41373 PyObject *resultobj = 0;
41374 wxValidator *arg1 = (wxValidator *) 0 ;
41375 wxWindow *arg2 = (wxWindow *) 0 ;
41376 bool result;
41377 void *argp1 = 0 ;
41378 int res1 = 0 ;
41379 void *argp2 = 0 ;
41380 int res2 = 0 ;
41381 PyObject * obj0 = 0 ;
41382 PyObject * obj1 = 0 ;
41383 char * kwnames[] = {
41384 (char *) "self",(char *) "parent", NULL
41385 };
41386
41387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41389 if (!SWIG_IsOK(res1)) {
41390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41391 }
41392 arg1 = reinterpret_cast< wxValidator * >(argp1);
41393 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41394 if (!SWIG_IsOK(res2)) {
41395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41396 }
41397 arg2 = reinterpret_cast< wxWindow * >(argp2);
41398 {
41399 PyThreadState* __tstate = wxPyBeginAllowThreads();
41400 result = (bool)(arg1)->Validate(arg2);
41401 wxPyEndAllowThreads(__tstate);
41402 if (PyErr_Occurred()) SWIG_fail;
41403 }
41404 {
41405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41406 }
41407 return resultobj;
41408 fail:
41409 return NULL;
41410 }
41411
41412
41413 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41414 PyObject *resultobj = 0;
41415 wxValidator *arg1 = (wxValidator *) 0 ;
41416 bool result;
41417 void *argp1 = 0 ;
41418 int res1 = 0 ;
41419 PyObject *swig_obj[1] ;
41420
41421 if (!args) SWIG_fail;
41422 swig_obj[0] = args;
41423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41424 if (!SWIG_IsOK(res1)) {
41425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41426 }
41427 arg1 = reinterpret_cast< wxValidator * >(argp1);
41428 {
41429 PyThreadState* __tstate = wxPyBeginAllowThreads();
41430 result = (bool)(arg1)->TransferToWindow();
41431 wxPyEndAllowThreads(__tstate);
41432 if (PyErr_Occurred()) SWIG_fail;
41433 }
41434 {
41435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41436 }
41437 return resultobj;
41438 fail:
41439 return NULL;
41440 }
41441
41442
41443 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41444 PyObject *resultobj = 0;
41445 wxValidator *arg1 = (wxValidator *) 0 ;
41446 bool result;
41447 void *argp1 = 0 ;
41448 int res1 = 0 ;
41449 PyObject *swig_obj[1] ;
41450
41451 if (!args) SWIG_fail;
41452 swig_obj[0] = args;
41453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41454 if (!SWIG_IsOK(res1)) {
41455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41456 }
41457 arg1 = reinterpret_cast< wxValidator * >(argp1);
41458 {
41459 PyThreadState* __tstate = wxPyBeginAllowThreads();
41460 result = (bool)(arg1)->TransferFromWindow();
41461 wxPyEndAllowThreads(__tstate);
41462 if (PyErr_Occurred()) SWIG_fail;
41463 }
41464 {
41465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41466 }
41467 return resultobj;
41468 fail:
41469 return NULL;
41470 }
41471
41472
41473 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41474 PyObject *resultobj = 0;
41475 wxValidator *arg1 = (wxValidator *) 0 ;
41476 wxWindow *result = 0 ;
41477 void *argp1 = 0 ;
41478 int res1 = 0 ;
41479 PyObject *swig_obj[1] ;
41480
41481 if (!args) SWIG_fail;
41482 swig_obj[0] = args;
41483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41484 if (!SWIG_IsOK(res1)) {
41485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41486 }
41487 arg1 = reinterpret_cast< wxValidator * >(argp1);
41488 {
41489 PyThreadState* __tstate = wxPyBeginAllowThreads();
41490 result = (wxWindow *)(arg1)->GetWindow();
41491 wxPyEndAllowThreads(__tstate);
41492 if (PyErr_Occurred()) SWIG_fail;
41493 }
41494 {
41495 resultobj = wxPyMake_wxObject(result, 0);
41496 }
41497 return resultobj;
41498 fail:
41499 return NULL;
41500 }
41501
41502
41503 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41504 PyObject *resultobj = 0;
41505 wxValidator *arg1 = (wxValidator *) 0 ;
41506 wxWindow *arg2 = (wxWindow *) 0 ;
41507 void *argp1 = 0 ;
41508 int res1 = 0 ;
41509 void *argp2 = 0 ;
41510 int res2 = 0 ;
41511 PyObject * obj0 = 0 ;
41512 PyObject * obj1 = 0 ;
41513 char * kwnames[] = {
41514 (char *) "self",(char *) "window", NULL
41515 };
41516
41517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41519 if (!SWIG_IsOK(res1)) {
41520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41521 }
41522 arg1 = reinterpret_cast< wxValidator * >(argp1);
41523 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41524 if (!SWIG_IsOK(res2)) {
41525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41526 }
41527 arg2 = reinterpret_cast< wxWindow * >(argp2);
41528 {
41529 PyThreadState* __tstate = wxPyBeginAllowThreads();
41530 (arg1)->SetWindow(arg2);
41531 wxPyEndAllowThreads(__tstate);
41532 if (PyErr_Occurred()) SWIG_fail;
41533 }
41534 resultobj = SWIG_Py_Void();
41535 return resultobj;
41536 fail:
41537 return NULL;
41538 }
41539
41540
41541 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41542 PyObject *resultobj = 0;
41543 bool result;
41544
41545 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41546 {
41547 PyThreadState* __tstate = wxPyBeginAllowThreads();
41548 result = (bool)wxValidator::IsSilent();
41549 wxPyEndAllowThreads(__tstate);
41550 if (PyErr_Occurred()) SWIG_fail;
41551 }
41552 {
41553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41554 }
41555 return resultobj;
41556 fail:
41557 return NULL;
41558 }
41559
41560
41561 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41562 PyObject *resultobj = 0;
41563 int arg1 = (int) true ;
41564 int val1 ;
41565 int ecode1 = 0 ;
41566 PyObject * obj0 = 0 ;
41567 char * kwnames[] = {
41568 (char *) "doIt", NULL
41569 };
41570
41571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41572 if (obj0) {
41573 ecode1 = SWIG_AsVal_int(obj0, &val1);
41574 if (!SWIG_IsOK(ecode1)) {
41575 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41576 }
41577 arg1 = static_cast< int >(val1);
41578 }
41579 {
41580 PyThreadState* __tstate = wxPyBeginAllowThreads();
41581 wxValidator::SetBellOnError(arg1);
41582 wxPyEndAllowThreads(__tstate);
41583 if (PyErr_Occurred()) SWIG_fail;
41584 }
41585 resultobj = SWIG_Py_Void();
41586 return resultobj;
41587 fail:
41588 return NULL;
41589 }
41590
41591
41592 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41593 PyObject *obj;
41594 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41595 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41596 return SWIG_Py_Void();
41597 }
41598
41599 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41600 return SWIG_Python_InitShadowInstance(args);
41601 }
41602
41603 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41604 PyObject *resultobj = 0;
41605 wxPyValidator *result = 0 ;
41606
41607 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41608 {
41609 PyThreadState* __tstate = wxPyBeginAllowThreads();
41610 result = (wxPyValidator *)new wxPyValidator();
41611 wxPyEndAllowThreads(__tstate);
41612 if (PyErr_Occurred()) SWIG_fail;
41613 }
41614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41615 return resultobj;
41616 fail:
41617 return NULL;
41618 }
41619
41620
41621 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41622 PyObject *resultobj = 0;
41623 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41624 PyObject *arg2 = (PyObject *) 0 ;
41625 PyObject *arg3 = (PyObject *) 0 ;
41626 int arg4 = (int) true ;
41627 void *argp1 = 0 ;
41628 int res1 = 0 ;
41629 int val4 ;
41630 int ecode4 = 0 ;
41631 PyObject * obj0 = 0 ;
41632 PyObject * obj1 = 0 ;
41633 PyObject * obj2 = 0 ;
41634 PyObject * obj3 = 0 ;
41635 char * kwnames[] = {
41636 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41637 };
41638
41639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41641 if (!SWIG_IsOK(res1)) {
41642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41643 }
41644 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41645 arg2 = obj1;
41646 arg3 = obj2;
41647 if (obj3) {
41648 ecode4 = SWIG_AsVal_int(obj3, &val4);
41649 if (!SWIG_IsOK(ecode4)) {
41650 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41651 }
41652 arg4 = static_cast< int >(val4);
41653 }
41654 {
41655 PyThreadState* __tstate = wxPyBeginAllowThreads();
41656 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41657 wxPyEndAllowThreads(__tstate);
41658 if (PyErr_Occurred()) SWIG_fail;
41659 }
41660 resultobj = SWIG_Py_Void();
41661 return resultobj;
41662 fail:
41663 return NULL;
41664 }
41665
41666
41667 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41668 PyObject *obj;
41669 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41670 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41671 return SWIG_Py_Void();
41672 }
41673
41674 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41675 return SWIG_Python_InitShadowInstance(args);
41676 }
41677
41678 SWIGINTERN int DefaultValidator_set(PyObject *) {
41679 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41680 return 1;
41681 }
41682
41683
41684 SWIGINTERN PyObject *DefaultValidator_get(void) {
41685 PyObject *pyobj = 0;
41686
41687 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41688 return pyobj;
41689 }
41690
41691
41692 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41693 PyObject *resultobj = 0;
41694 wxString const &arg1_defvalue = wxPyEmptyString ;
41695 wxString *arg1 = (wxString *) &arg1_defvalue ;
41696 long arg2 = (long) 0 ;
41697 wxMenu *result = 0 ;
41698 bool temp1 = false ;
41699 long val2 ;
41700 int ecode2 = 0 ;
41701 PyObject * obj0 = 0 ;
41702 PyObject * obj1 = 0 ;
41703 char * kwnames[] = {
41704 (char *) "title",(char *) "style", NULL
41705 };
41706
41707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41708 if (obj0) {
41709 {
41710 arg1 = wxString_in_helper(obj0);
41711 if (arg1 == NULL) SWIG_fail;
41712 temp1 = true;
41713 }
41714 }
41715 if (obj1) {
41716 ecode2 = SWIG_AsVal_long(obj1, &val2);
41717 if (!SWIG_IsOK(ecode2)) {
41718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
41719 }
41720 arg2 = static_cast< long >(val2);
41721 }
41722 {
41723 if (!wxPyCheckForApp()) SWIG_fail;
41724 PyThreadState* __tstate = wxPyBeginAllowThreads();
41725 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
41726 wxPyEndAllowThreads(__tstate);
41727 if (PyErr_Occurred()) SWIG_fail;
41728 }
41729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
41730 {
41731 if (temp1)
41732 delete arg1;
41733 }
41734 return resultobj;
41735 fail:
41736 {
41737 if (temp1)
41738 delete arg1;
41739 }
41740 return NULL;
41741 }
41742
41743
41744 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41745 PyObject *resultobj = 0;
41746 wxMenu *arg1 = (wxMenu *) 0 ;
41747 int arg2 ;
41748 wxString const &arg3_defvalue = wxPyEmptyString ;
41749 wxString *arg3 = (wxString *) &arg3_defvalue ;
41750 wxString const &arg4_defvalue = wxPyEmptyString ;
41751 wxString *arg4 = (wxString *) &arg4_defvalue ;
41752 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41753 wxMenuItem *result = 0 ;
41754 void *argp1 = 0 ;
41755 int res1 = 0 ;
41756 int val2 ;
41757 int ecode2 = 0 ;
41758 bool temp3 = false ;
41759 bool temp4 = false ;
41760 int val5 ;
41761 int ecode5 = 0 ;
41762 PyObject * obj0 = 0 ;
41763 PyObject * obj1 = 0 ;
41764 PyObject * obj2 = 0 ;
41765 PyObject * obj3 = 0 ;
41766 PyObject * obj4 = 0 ;
41767 char * kwnames[] = {
41768 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
41769 };
41770
41771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41773 if (!SWIG_IsOK(res1)) {
41774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
41775 }
41776 arg1 = reinterpret_cast< wxMenu * >(argp1);
41777 ecode2 = SWIG_AsVal_int(obj1, &val2);
41778 if (!SWIG_IsOK(ecode2)) {
41779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
41780 }
41781 arg2 = static_cast< int >(val2);
41782 if (obj2) {
41783 {
41784 arg3 = wxString_in_helper(obj2);
41785 if (arg3 == NULL) SWIG_fail;
41786 temp3 = true;
41787 }
41788 }
41789 if (obj3) {
41790 {
41791 arg4 = wxString_in_helper(obj3);
41792 if (arg4 == NULL) SWIG_fail;
41793 temp4 = true;
41794 }
41795 }
41796 if (obj4) {
41797 ecode5 = SWIG_AsVal_int(obj4, &val5);
41798 if (!SWIG_IsOK(ecode5)) {
41799 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
41800 }
41801 arg5 = static_cast< wxItemKind >(val5);
41802 }
41803 {
41804 PyThreadState* __tstate = wxPyBeginAllowThreads();
41805 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
41806 wxPyEndAllowThreads(__tstate);
41807 if (PyErr_Occurred()) SWIG_fail;
41808 }
41809 {
41810 resultobj = wxPyMake_wxObject(result, (bool)0);
41811 }
41812 {
41813 if (temp3)
41814 delete arg3;
41815 }
41816 {
41817 if (temp4)
41818 delete arg4;
41819 }
41820 return resultobj;
41821 fail:
41822 {
41823 if (temp3)
41824 delete arg3;
41825 }
41826 {
41827 if (temp4)
41828 delete arg4;
41829 }
41830 return NULL;
41831 }
41832
41833
41834 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41835 PyObject *resultobj = 0;
41836 wxMenu *arg1 = (wxMenu *) 0 ;
41837 wxMenuItem *result = 0 ;
41838 void *argp1 = 0 ;
41839 int res1 = 0 ;
41840 PyObject *swig_obj[1] ;
41841
41842 if (!args) SWIG_fail;
41843 swig_obj[0] = args;
41844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41845 if (!SWIG_IsOK(res1)) {
41846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
41847 }
41848 arg1 = reinterpret_cast< wxMenu * >(argp1);
41849 {
41850 PyThreadState* __tstate = wxPyBeginAllowThreads();
41851 result = (wxMenuItem *)(arg1)->AppendSeparator();
41852 wxPyEndAllowThreads(__tstate);
41853 if (PyErr_Occurred()) SWIG_fail;
41854 }
41855 {
41856 resultobj = wxPyMake_wxObject(result, (bool)0);
41857 }
41858 return resultobj;
41859 fail:
41860 return NULL;
41861 }
41862
41863
41864 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41865 PyObject *resultobj = 0;
41866 wxMenu *arg1 = (wxMenu *) 0 ;
41867 int arg2 ;
41868 wxString *arg3 = 0 ;
41869 wxString const &arg4_defvalue = wxPyEmptyString ;
41870 wxString *arg4 = (wxString *) &arg4_defvalue ;
41871 wxMenuItem *result = 0 ;
41872 void *argp1 = 0 ;
41873 int res1 = 0 ;
41874 int val2 ;
41875 int ecode2 = 0 ;
41876 bool temp3 = false ;
41877 bool temp4 = false ;
41878 PyObject * obj0 = 0 ;
41879 PyObject * obj1 = 0 ;
41880 PyObject * obj2 = 0 ;
41881 PyObject * obj3 = 0 ;
41882 char * kwnames[] = {
41883 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41884 };
41885
41886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41888 if (!SWIG_IsOK(res1)) {
41889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41890 }
41891 arg1 = reinterpret_cast< wxMenu * >(argp1);
41892 ecode2 = SWIG_AsVal_int(obj1, &val2);
41893 if (!SWIG_IsOK(ecode2)) {
41894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
41895 }
41896 arg2 = static_cast< int >(val2);
41897 {
41898 arg3 = wxString_in_helper(obj2);
41899 if (arg3 == NULL) SWIG_fail;
41900 temp3 = true;
41901 }
41902 if (obj3) {
41903 {
41904 arg4 = wxString_in_helper(obj3);
41905 if (arg4 == NULL) SWIG_fail;
41906 temp4 = true;
41907 }
41908 }
41909 {
41910 PyThreadState* __tstate = wxPyBeginAllowThreads();
41911 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41912 wxPyEndAllowThreads(__tstate);
41913 if (PyErr_Occurred()) SWIG_fail;
41914 }
41915 {
41916 resultobj = wxPyMake_wxObject(result, (bool)0);
41917 }
41918 {
41919 if (temp3)
41920 delete arg3;
41921 }
41922 {
41923 if (temp4)
41924 delete arg4;
41925 }
41926 return resultobj;
41927 fail:
41928 {
41929 if (temp3)
41930 delete arg3;
41931 }
41932 {
41933 if (temp4)
41934 delete arg4;
41935 }
41936 return NULL;
41937 }
41938
41939
41940 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41941 PyObject *resultobj = 0;
41942 wxMenu *arg1 = (wxMenu *) 0 ;
41943 int arg2 ;
41944 wxString *arg3 = 0 ;
41945 wxString const &arg4_defvalue = wxPyEmptyString ;
41946 wxString *arg4 = (wxString *) &arg4_defvalue ;
41947 wxMenuItem *result = 0 ;
41948 void *argp1 = 0 ;
41949 int res1 = 0 ;
41950 int val2 ;
41951 int ecode2 = 0 ;
41952 bool temp3 = false ;
41953 bool temp4 = false ;
41954 PyObject * obj0 = 0 ;
41955 PyObject * obj1 = 0 ;
41956 PyObject * obj2 = 0 ;
41957 PyObject * obj3 = 0 ;
41958 char * kwnames[] = {
41959 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41960 };
41961
41962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41964 if (!SWIG_IsOK(res1)) {
41965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41966 }
41967 arg1 = reinterpret_cast< wxMenu * >(argp1);
41968 ecode2 = SWIG_AsVal_int(obj1, &val2);
41969 if (!SWIG_IsOK(ecode2)) {
41970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
41971 }
41972 arg2 = static_cast< int >(val2);
41973 {
41974 arg3 = wxString_in_helper(obj2);
41975 if (arg3 == NULL) SWIG_fail;
41976 temp3 = true;
41977 }
41978 if (obj3) {
41979 {
41980 arg4 = wxString_in_helper(obj3);
41981 if (arg4 == NULL) SWIG_fail;
41982 temp4 = true;
41983 }
41984 }
41985 {
41986 PyThreadState* __tstate = wxPyBeginAllowThreads();
41987 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41988 wxPyEndAllowThreads(__tstate);
41989 if (PyErr_Occurred()) SWIG_fail;
41990 }
41991 {
41992 resultobj = wxPyMake_wxObject(result, (bool)0);
41993 }
41994 {
41995 if (temp3)
41996 delete arg3;
41997 }
41998 {
41999 if (temp4)
42000 delete arg4;
42001 }
42002 return resultobj;
42003 fail:
42004 {
42005 if (temp3)
42006 delete arg3;
42007 }
42008 {
42009 if (temp4)
42010 delete arg4;
42011 }
42012 return NULL;
42013 }
42014
42015
42016 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42017 PyObject *resultobj = 0;
42018 wxMenu *arg1 = (wxMenu *) 0 ;
42019 int arg2 ;
42020 wxString *arg3 = 0 ;
42021 wxMenu *arg4 = (wxMenu *) 0 ;
42022 wxString const &arg5_defvalue = wxPyEmptyString ;
42023 wxString *arg5 = (wxString *) &arg5_defvalue ;
42024 wxMenuItem *result = 0 ;
42025 void *argp1 = 0 ;
42026 int res1 = 0 ;
42027 int val2 ;
42028 int ecode2 = 0 ;
42029 bool temp3 = false ;
42030 void *argp4 = 0 ;
42031 int res4 = 0 ;
42032 bool temp5 = false ;
42033 PyObject * obj0 = 0 ;
42034 PyObject * obj1 = 0 ;
42035 PyObject * obj2 = 0 ;
42036 PyObject * obj3 = 0 ;
42037 PyObject * obj4 = 0 ;
42038 char * kwnames[] = {
42039 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42040 };
42041
42042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42044 if (!SWIG_IsOK(res1)) {
42045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42046 }
42047 arg1 = reinterpret_cast< wxMenu * >(argp1);
42048 ecode2 = SWIG_AsVal_int(obj1, &val2);
42049 if (!SWIG_IsOK(ecode2)) {
42050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42051 }
42052 arg2 = static_cast< int >(val2);
42053 {
42054 arg3 = wxString_in_helper(obj2);
42055 if (arg3 == NULL) SWIG_fail;
42056 temp3 = true;
42057 }
42058 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42059 if (!SWIG_IsOK(res4)) {
42060 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42061 }
42062 arg4 = reinterpret_cast< wxMenu * >(argp4);
42063 if (obj4) {
42064 {
42065 arg5 = wxString_in_helper(obj4);
42066 if (arg5 == NULL) SWIG_fail;
42067 temp5 = true;
42068 }
42069 }
42070 {
42071 PyThreadState* __tstate = wxPyBeginAllowThreads();
42072 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42073 wxPyEndAllowThreads(__tstate);
42074 if (PyErr_Occurred()) SWIG_fail;
42075 }
42076 {
42077 resultobj = wxPyMake_wxObject(result, (bool)0);
42078 }
42079 {
42080 if (temp3)
42081 delete arg3;
42082 }
42083 {
42084 if (temp5)
42085 delete arg5;
42086 }
42087 return resultobj;
42088 fail:
42089 {
42090 if (temp3)
42091 delete arg3;
42092 }
42093 {
42094 if (temp5)
42095 delete arg5;
42096 }
42097 return NULL;
42098 }
42099
42100
42101 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42102 PyObject *resultobj = 0;
42103 wxMenu *arg1 = (wxMenu *) 0 ;
42104 wxMenu *arg2 = (wxMenu *) 0 ;
42105 wxString *arg3 = 0 ;
42106 wxString const &arg4_defvalue = wxPyEmptyString ;
42107 wxString *arg4 = (wxString *) &arg4_defvalue ;
42108 wxMenuItem *result = 0 ;
42109 void *argp1 = 0 ;
42110 int res1 = 0 ;
42111 void *argp2 = 0 ;
42112 int res2 = 0 ;
42113 bool temp3 = false ;
42114 bool temp4 = false ;
42115 PyObject * obj0 = 0 ;
42116 PyObject * obj1 = 0 ;
42117 PyObject * obj2 = 0 ;
42118 PyObject * obj3 = 0 ;
42119 char * kwnames[] = {
42120 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42121 };
42122
42123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42125 if (!SWIG_IsOK(res1)) {
42126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42127 }
42128 arg1 = reinterpret_cast< wxMenu * >(argp1);
42129 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42130 if (!SWIG_IsOK(res2)) {
42131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42132 }
42133 arg2 = reinterpret_cast< wxMenu * >(argp2);
42134 {
42135 arg3 = wxString_in_helper(obj2);
42136 if (arg3 == NULL) SWIG_fail;
42137 temp3 = true;
42138 }
42139 if (obj3) {
42140 {
42141 arg4 = wxString_in_helper(obj3);
42142 if (arg4 == NULL) SWIG_fail;
42143 temp4 = true;
42144 }
42145 }
42146 {
42147 PyThreadState* __tstate = wxPyBeginAllowThreads();
42148 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42149 wxPyEndAllowThreads(__tstate);
42150 if (PyErr_Occurred()) SWIG_fail;
42151 }
42152 {
42153 resultobj = wxPyMake_wxObject(result, (bool)0);
42154 }
42155 {
42156 if (temp3)
42157 delete arg3;
42158 }
42159 {
42160 if (temp4)
42161 delete arg4;
42162 }
42163 return resultobj;
42164 fail:
42165 {
42166 if (temp3)
42167 delete arg3;
42168 }
42169 {
42170 if (temp4)
42171 delete arg4;
42172 }
42173 return NULL;
42174 }
42175
42176
42177 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42178 PyObject *resultobj = 0;
42179 wxMenu *arg1 = (wxMenu *) 0 ;
42180 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42181 wxMenuItem *result = 0 ;
42182 void *argp1 = 0 ;
42183 int res1 = 0 ;
42184 int res2 = 0 ;
42185 PyObject * obj0 = 0 ;
42186 PyObject * obj1 = 0 ;
42187 char * kwnames[] = {
42188 (char *) "self",(char *) "item", NULL
42189 };
42190
42191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42193 if (!SWIG_IsOK(res1)) {
42194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42195 }
42196 arg1 = reinterpret_cast< wxMenu * >(argp1);
42197 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42198 if (!SWIG_IsOK(res2)) {
42199 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42200 }
42201 {
42202 PyThreadState* __tstate = wxPyBeginAllowThreads();
42203 result = (wxMenuItem *)(arg1)->Append(arg2);
42204 wxPyEndAllowThreads(__tstate);
42205 if (PyErr_Occurred()) SWIG_fail;
42206 }
42207 {
42208 resultobj = wxPyMake_wxObject(result, (bool)0);
42209 }
42210 return resultobj;
42211 fail:
42212 return NULL;
42213 }
42214
42215
42216 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42217 PyObject *resultobj = 0;
42218 wxMenu *arg1 = (wxMenu *) 0 ;
42219 size_t arg2 ;
42220 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42221 wxMenuItem *result = 0 ;
42222 void *argp1 = 0 ;
42223 int res1 = 0 ;
42224 size_t val2 ;
42225 int ecode2 = 0 ;
42226 int res3 = 0 ;
42227 PyObject * obj0 = 0 ;
42228 PyObject * obj1 = 0 ;
42229 PyObject * obj2 = 0 ;
42230 char * kwnames[] = {
42231 (char *) "self",(char *) "pos",(char *) "item", NULL
42232 };
42233
42234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42236 if (!SWIG_IsOK(res1)) {
42237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42238 }
42239 arg1 = reinterpret_cast< wxMenu * >(argp1);
42240 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42241 if (!SWIG_IsOK(ecode2)) {
42242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42243 }
42244 arg2 = static_cast< size_t >(val2);
42245 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42246 if (!SWIG_IsOK(res3)) {
42247 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42248 }
42249 {
42250 PyThreadState* __tstate = wxPyBeginAllowThreads();
42251 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42252 wxPyEndAllowThreads(__tstate);
42253 if (PyErr_Occurred()) SWIG_fail;
42254 }
42255 {
42256 resultobj = wxPyMake_wxObject(result, (bool)0);
42257 }
42258 return resultobj;
42259 fail:
42260 return NULL;
42261 }
42262
42263
42264 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42265 PyObject *resultobj = 0;
42266 wxMenu *arg1 = (wxMenu *) 0 ;
42267 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42268 wxMenuItem *result = 0 ;
42269 void *argp1 = 0 ;
42270 int res1 = 0 ;
42271 int res2 = 0 ;
42272 PyObject * obj0 = 0 ;
42273 PyObject * obj1 = 0 ;
42274 char * kwnames[] = {
42275 (char *) "self",(char *) "item", NULL
42276 };
42277
42278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42280 if (!SWIG_IsOK(res1)) {
42281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42282 }
42283 arg1 = reinterpret_cast< wxMenu * >(argp1);
42284 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42285 if (!SWIG_IsOK(res2)) {
42286 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42287 }
42288 {
42289 PyThreadState* __tstate = wxPyBeginAllowThreads();
42290 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42291 wxPyEndAllowThreads(__tstate);
42292 if (PyErr_Occurred()) SWIG_fail;
42293 }
42294 {
42295 resultobj = wxPyMake_wxObject(result, (bool)0);
42296 }
42297 return resultobj;
42298 fail:
42299 return NULL;
42300 }
42301
42302
42303 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42304 PyObject *resultobj = 0;
42305 wxMenu *arg1 = (wxMenu *) 0 ;
42306 void *argp1 = 0 ;
42307 int res1 = 0 ;
42308 PyObject *swig_obj[1] ;
42309
42310 if (!args) SWIG_fail;
42311 swig_obj[0] = args;
42312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42313 if (!SWIG_IsOK(res1)) {
42314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42315 }
42316 arg1 = reinterpret_cast< wxMenu * >(argp1);
42317 {
42318 PyThreadState* __tstate = wxPyBeginAllowThreads();
42319 (arg1)->Break();
42320 wxPyEndAllowThreads(__tstate);
42321 if (PyErr_Occurred()) SWIG_fail;
42322 }
42323 resultobj = SWIG_Py_Void();
42324 return resultobj;
42325 fail:
42326 return NULL;
42327 }
42328
42329
42330 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42331 PyObject *resultobj = 0;
42332 wxMenu *arg1 = (wxMenu *) 0 ;
42333 size_t arg2 ;
42334 int arg3 ;
42335 wxString const &arg4_defvalue = wxPyEmptyString ;
42336 wxString *arg4 = (wxString *) &arg4_defvalue ;
42337 wxString const &arg5_defvalue = wxPyEmptyString ;
42338 wxString *arg5 = (wxString *) &arg5_defvalue ;
42339 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42340 wxMenuItem *result = 0 ;
42341 void *argp1 = 0 ;
42342 int res1 = 0 ;
42343 size_t val2 ;
42344 int ecode2 = 0 ;
42345 int val3 ;
42346 int ecode3 = 0 ;
42347 bool temp4 = false ;
42348 bool temp5 = false ;
42349 int val6 ;
42350 int ecode6 = 0 ;
42351 PyObject * obj0 = 0 ;
42352 PyObject * obj1 = 0 ;
42353 PyObject * obj2 = 0 ;
42354 PyObject * obj3 = 0 ;
42355 PyObject * obj4 = 0 ;
42356 PyObject * obj5 = 0 ;
42357 char * kwnames[] = {
42358 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42359 };
42360
42361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42363 if (!SWIG_IsOK(res1)) {
42364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42365 }
42366 arg1 = reinterpret_cast< wxMenu * >(argp1);
42367 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42368 if (!SWIG_IsOK(ecode2)) {
42369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42370 }
42371 arg2 = static_cast< size_t >(val2);
42372 ecode3 = SWIG_AsVal_int(obj2, &val3);
42373 if (!SWIG_IsOK(ecode3)) {
42374 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42375 }
42376 arg3 = static_cast< int >(val3);
42377 if (obj3) {
42378 {
42379 arg4 = wxString_in_helper(obj3);
42380 if (arg4 == NULL) SWIG_fail;
42381 temp4 = true;
42382 }
42383 }
42384 if (obj4) {
42385 {
42386 arg5 = wxString_in_helper(obj4);
42387 if (arg5 == NULL) SWIG_fail;
42388 temp5 = true;
42389 }
42390 }
42391 if (obj5) {
42392 ecode6 = SWIG_AsVal_int(obj5, &val6);
42393 if (!SWIG_IsOK(ecode6)) {
42394 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42395 }
42396 arg6 = static_cast< wxItemKind >(val6);
42397 }
42398 {
42399 PyThreadState* __tstate = wxPyBeginAllowThreads();
42400 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42401 wxPyEndAllowThreads(__tstate);
42402 if (PyErr_Occurred()) SWIG_fail;
42403 }
42404 {
42405 resultobj = wxPyMake_wxObject(result, (bool)0);
42406 }
42407 {
42408 if (temp4)
42409 delete arg4;
42410 }
42411 {
42412 if (temp5)
42413 delete arg5;
42414 }
42415 return resultobj;
42416 fail:
42417 {
42418 if (temp4)
42419 delete arg4;
42420 }
42421 {
42422 if (temp5)
42423 delete arg5;
42424 }
42425 return NULL;
42426 }
42427
42428
42429 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42430 PyObject *resultobj = 0;
42431 wxMenu *arg1 = (wxMenu *) 0 ;
42432 size_t arg2 ;
42433 wxMenuItem *result = 0 ;
42434 void *argp1 = 0 ;
42435 int res1 = 0 ;
42436 size_t val2 ;
42437 int ecode2 = 0 ;
42438 PyObject * obj0 = 0 ;
42439 PyObject * obj1 = 0 ;
42440 char * kwnames[] = {
42441 (char *) "self",(char *) "pos", NULL
42442 };
42443
42444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42446 if (!SWIG_IsOK(res1)) {
42447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42448 }
42449 arg1 = reinterpret_cast< wxMenu * >(argp1);
42450 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42451 if (!SWIG_IsOK(ecode2)) {
42452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42453 }
42454 arg2 = static_cast< size_t >(val2);
42455 {
42456 PyThreadState* __tstate = wxPyBeginAllowThreads();
42457 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42458 wxPyEndAllowThreads(__tstate);
42459 if (PyErr_Occurred()) SWIG_fail;
42460 }
42461 {
42462 resultobj = wxPyMake_wxObject(result, (bool)0);
42463 }
42464 return resultobj;
42465 fail:
42466 return NULL;
42467 }
42468
42469
42470 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42471 PyObject *resultobj = 0;
42472 wxMenu *arg1 = (wxMenu *) 0 ;
42473 size_t arg2 ;
42474 int arg3 ;
42475 wxString *arg4 = 0 ;
42476 wxString const &arg5_defvalue = wxPyEmptyString ;
42477 wxString *arg5 = (wxString *) &arg5_defvalue ;
42478 wxMenuItem *result = 0 ;
42479 void *argp1 = 0 ;
42480 int res1 = 0 ;
42481 size_t val2 ;
42482 int ecode2 = 0 ;
42483 int val3 ;
42484 int ecode3 = 0 ;
42485 bool temp4 = false ;
42486 bool temp5 = false ;
42487 PyObject * obj0 = 0 ;
42488 PyObject * obj1 = 0 ;
42489 PyObject * obj2 = 0 ;
42490 PyObject * obj3 = 0 ;
42491 PyObject * obj4 = 0 ;
42492 char * kwnames[] = {
42493 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42494 };
42495
42496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42498 if (!SWIG_IsOK(res1)) {
42499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42500 }
42501 arg1 = reinterpret_cast< wxMenu * >(argp1);
42502 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42503 if (!SWIG_IsOK(ecode2)) {
42504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42505 }
42506 arg2 = static_cast< size_t >(val2);
42507 ecode3 = SWIG_AsVal_int(obj2, &val3);
42508 if (!SWIG_IsOK(ecode3)) {
42509 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42510 }
42511 arg3 = static_cast< int >(val3);
42512 {
42513 arg4 = wxString_in_helper(obj3);
42514 if (arg4 == NULL) SWIG_fail;
42515 temp4 = true;
42516 }
42517 if (obj4) {
42518 {
42519 arg5 = wxString_in_helper(obj4);
42520 if (arg5 == NULL) SWIG_fail;
42521 temp5 = true;
42522 }
42523 }
42524 {
42525 PyThreadState* __tstate = wxPyBeginAllowThreads();
42526 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42527 wxPyEndAllowThreads(__tstate);
42528 if (PyErr_Occurred()) SWIG_fail;
42529 }
42530 {
42531 resultobj = wxPyMake_wxObject(result, (bool)0);
42532 }
42533 {
42534 if (temp4)
42535 delete arg4;
42536 }
42537 {
42538 if (temp5)
42539 delete arg5;
42540 }
42541 return resultobj;
42542 fail:
42543 {
42544 if (temp4)
42545 delete arg4;
42546 }
42547 {
42548 if (temp5)
42549 delete arg5;
42550 }
42551 return NULL;
42552 }
42553
42554
42555 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42556 PyObject *resultobj = 0;
42557 wxMenu *arg1 = (wxMenu *) 0 ;
42558 size_t arg2 ;
42559 int arg3 ;
42560 wxString *arg4 = 0 ;
42561 wxString const &arg5_defvalue = wxPyEmptyString ;
42562 wxString *arg5 = (wxString *) &arg5_defvalue ;
42563 wxMenuItem *result = 0 ;
42564 void *argp1 = 0 ;
42565 int res1 = 0 ;
42566 size_t val2 ;
42567 int ecode2 = 0 ;
42568 int val3 ;
42569 int ecode3 = 0 ;
42570 bool temp4 = false ;
42571 bool temp5 = false ;
42572 PyObject * obj0 = 0 ;
42573 PyObject * obj1 = 0 ;
42574 PyObject * obj2 = 0 ;
42575 PyObject * obj3 = 0 ;
42576 PyObject * obj4 = 0 ;
42577 char * kwnames[] = {
42578 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42579 };
42580
42581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42583 if (!SWIG_IsOK(res1)) {
42584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42585 }
42586 arg1 = reinterpret_cast< wxMenu * >(argp1);
42587 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42588 if (!SWIG_IsOK(ecode2)) {
42589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42590 }
42591 arg2 = static_cast< size_t >(val2);
42592 ecode3 = SWIG_AsVal_int(obj2, &val3);
42593 if (!SWIG_IsOK(ecode3)) {
42594 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42595 }
42596 arg3 = static_cast< int >(val3);
42597 {
42598 arg4 = wxString_in_helper(obj3);
42599 if (arg4 == NULL) SWIG_fail;
42600 temp4 = true;
42601 }
42602 if (obj4) {
42603 {
42604 arg5 = wxString_in_helper(obj4);
42605 if (arg5 == NULL) SWIG_fail;
42606 temp5 = true;
42607 }
42608 }
42609 {
42610 PyThreadState* __tstate = wxPyBeginAllowThreads();
42611 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42612 wxPyEndAllowThreads(__tstate);
42613 if (PyErr_Occurred()) SWIG_fail;
42614 }
42615 {
42616 resultobj = wxPyMake_wxObject(result, (bool)0);
42617 }
42618 {
42619 if (temp4)
42620 delete arg4;
42621 }
42622 {
42623 if (temp5)
42624 delete arg5;
42625 }
42626 return resultobj;
42627 fail:
42628 {
42629 if (temp4)
42630 delete arg4;
42631 }
42632 {
42633 if (temp5)
42634 delete arg5;
42635 }
42636 return NULL;
42637 }
42638
42639
42640 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42641 PyObject *resultobj = 0;
42642 wxMenu *arg1 = (wxMenu *) 0 ;
42643 size_t arg2 ;
42644 int arg3 ;
42645 wxString *arg4 = 0 ;
42646 wxMenu *arg5 = (wxMenu *) 0 ;
42647 wxString const &arg6_defvalue = wxPyEmptyString ;
42648 wxString *arg6 = (wxString *) &arg6_defvalue ;
42649 wxMenuItem *result = 0 ;
42650 void *argp1 = 0 ;
42651 int res1 = 0 ;
42652 size_t val2 ;
42653 int ecode2 = 0 ;
42654 int val3 ;
42655 int ecode3 = 0 ;
42656 bool temp4 = false ;
42657 void *argp5 = 0 ;
42658 int res5 = 0 ;
42659 bool temp6 = false ;
42660 PyObject * obj0 = 0 ;
42661 PyObject * obj1 = 0 ;
42662 PyObject * obj2 = 0 ;
42663 PyObject * obj3 = 0 ;
42664 PyObject * obj4 = 0 ;
42665 PyObject * obj5 = 0 ;
42666 char * kwnames[] = {
42667 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42668 };
42669
42670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42672 if (!SWIG_IsOK(res1)) {
42673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42674 }
42675 arg1 = reinterpret_cast< wxMenu * >(argp1);
42676 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42677 if (!SWIG_IsOK(ecode2)) {
42678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42679 }
42680 arg2 = static_cast< size_t >(val2);
42681 ecode3 = SWIG_AsVal_int(obj2, &val3);
42682 if (!SWIG_IsOK(ecode3)) {
42683 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42684 }
42685 arg3 = static_cast< int >(val3);
42686 {
42687 arg4 = wxString_in_helper(obj3);
42688 if (arg4 == NULL) SWIG_fail;
42689 temp4 = true;
42690 }
42691 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42692 if (!SWIG_IsOK(res5)) {
42693 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42694 }
42695 arg5 = reinterpret_cast< wxMenu * >(argp5);
42696 if (obj5) {
42697 {
42698 arg6 = wxString_in_helper(obj5);
42699 if (arg6 == NULL) SWIG_fail;
42700 temp6 = true;
42701 }
42702 }
42703 {
42704 PyThreadState* __tstate = wxPyBeginAllowThreads();
42705 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42706 wxPyEndAllowThreads(__tstate);
42707 if (PyErr_Occurred()) SWIG_fail;
42708 }
42709 {
42710 resultobj = wxPyMake_wxObject(result, (bool)0);
42711 }
42712 {
42713 if (temp4)
42714 delete arg4;
42715 }
42716 {
42717 if (temp6)
42718 delete arg6;
42719 }
42720 return resultobj;
42721 fail:
42722 {
42723 if (temp4)
42724 delete arg4;
42725 }
42726 {
42727 if (temp6)
42728 delete arg6;
42729 }
42730 return NULL;
42731 }
42732
42733
42734 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42735 PyObject *resultobj = 0;
42736 wxMenu *arg1 = (wxMenu *) 0 ;
42737 int arg2 ;
42738 wxString const &arg3_defvalue = wxPyEmptyString ;
42739 wxString *arg3 = (wxString *) &arg3_defvalue ;
42740 wxString const &arg4_defvalue = wxPyEmptyString ;
42741 wxString *arg4 = (wxString *) &arg4_defvalue ;
42742 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42743 wxMenuItem *result = 0 ;
42744 void *argp1 = 0 ;
42745 int res1 = 0 ;
42746 int val2 ;
42747 int ecode2 = 0 ;
42748 bool temp3 = false ;
42749 bool temp4 = false ;
42750 int val5 ;
42751 int ecode5 = 0 ;
42752 PyObject * obj0 = 0 ;
42753 PyObject * obj1 = 0 ;
42754 PyObject * obj2 = 0 ;
42755 PyObject * obj3 = 0 ;
42756 PyObject * obj4 = 0 ;
42757 char * kwnames[] = {
42758 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42759 };
42760
42761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42763 if (!SWIG_IsOK(res1)) {
42764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
42765 }
42766 arg1 = reinterpret_cast< wxMenu * >(argp1);
42767 ecode2 = SWIG_AsVal_int(obj1, &val2);
42768 if (!SWIG_IsOK(ecode2)) {
42769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
42770 }
42771 arg2 = static_cast< int >(val2);
42772 if (obj2) {
42773 {
42774 arg3 = wxString_in_helper(obj2);
42775 if (arg3 == NULL) SWIG_fail;
42776 temp3 = true;
42777 }
42778 }
42779 if (obj3) {
42780 {
42781 arg4 = wxString_in_helper(obj3);
42782 if (arg4 == NULL) SWIG_fail;
42783 temp4 = true;
42784 }
42785 }
42786 if (obj4) {
42787 ecode5 = SWIG_AsVal_int(obj4, &val5);
42788 if (!SWIG_IsOK(ecode5)) {
42789 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
42790 }
42791 arg5 = static_cast< wxItemKind >(val5);
42792 }
42793 {
42794 PyThreadState* __tstate = wxPyBeginAllowThreads();
42795 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42796 wxPyEndAllowThreads(__tstate);
42797 if (PyErr_Occurred()) SWIG_fail;
42798 }
42799 {
42800 resultobj = wxPyMake_wxObject(result, (bool)0);
42801 }
42802 {
42803 if (temp3)
42804 delete arg3;
42805 }
42806 {
42807 if (temp4)
42808 delete arg4;
42809 }
42810 return resultobj;
42811 fail:
42812 {
42813 if (temp3)
42814 delete arg3;
42815 }
42816 {
42817 if (temp4)
42818 delete arg4;
42819 }
42820 return NULL;
42821 }
42822
42823
42824 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42825 PyObject *resultobj = 0;
42826 wxMenu *arg1 = (wxMenu *) 0 ;
42827 wxMenuItem *result = 0 ;
42828 void *argp1 = 0 ;
42829 int res1 = 0 ;
42830 PyObject *swig_obj[1] ;
42831
42832 if (!args) SWIG_fail;
42833 swig_obj[0] = args;
42834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42835 if (!SWIG_IsOK(res1)) {
42836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42837 }
42838 arg1 = reinterpret_cast< wxMenu * >(argp1);
42839 {
42840 PyThreadState* __tstate = wxPyBeginAllowThreads();
42841 result = (wxMenuItem *)(arg1)->PrependSeparator();
42842 wxPyEndAllowThreads(__tstate);
42843 if (PyErr_Occurred()) SWIG_fail;
42844 }
42845 {
42846 resultobj = wxPyMake_wxObject(result, (bool)0);
42847 }
42848 return resultobj;
42849 fail:
42850 return NULL;
42851 }
42852
42853
42854 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42855 PyObject *resultobj = 0;
42856 wxMenu *arg1 = (wxMenu *) 0 ;
42857 int arg2 ;
42858 wxString *arg3 = 0 ;
42859 wxString const &arg4_defvalue = wxPyEmptyString ;
42860 wxString *arg4 = (wxString *) &arg4_defvalue ;
42861 wxMenuItem *result = 0 ;
42862 void *argp1 = 0 ;
42863 int res1 = 0 ;
42864 int val2 ;
42865 int ecode2 = 0 ;
42866 bool temp3 = false ;
42867 bool temp4 = false ;
42868 PyObject * obj0 = 0 ;
42869 PyObject * obj1 = 0 ;
42870 PyObject * obj2 = 0 ;
42871 PyObject * obj3 = 0 ;
42872 char * kwnames[] = {
42873 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42874 };
42875
42876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42878 if (!SWIG_IsOK(res1)) {
42879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42880 }
42881 arg1 = reinterpret_cast< wxMenu * >(argp1);
42882 ecode2 = SWIG_AsVal_int(obj1, &val2);
42883 if (!SWIG_IsOK(ecode2)) {
42884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
42885 }
42886 arg2 = static_cast< int >(val2);
42887 {
42888 arg3 = wxString_in_helper(obj2);
42889 if (arg3 == NULL) SWIG_fail;
42890 temp3 = true;
42891 }
42892 if (obj3) {
42893 {
42894 arg4 = wxString_in_helper(obj3);
42895 if (arg4 == NULL) SWIG_fail;
42896 temp4 = true;
42897 }
42898 }
42899 {
42900 PyThreadState* __tstate = wxPyBeginAllowThreads();
42901 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42902 wxPyEndAllowThreads(__tstate);
42903 if (PyErr_Occurred()) SWIG_fail;
42904 }
42905 {
42906 resultobj = wxPyMake_wxObject(result, (bool)0);
42907 }
42908 {
42909 if (temp3)
42910 delete arg3;
42911 }
42912 {
42913 if (temp4)
42914 delete arg4;
42915 }
42916 return resultobj;
42917 fail:
42918 {
42919 if (temp3)
42920 delete arg3;
42921 }
42922 {
42923 if (temp4)
42924 delete arg4;
42925 }
42926 return NULL;
42927 }
42928
42929
42930 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42931 PyObject *resultobj = 0;
42932 wxMenu *arg1 = (wxMenu *) 0 ;
42933 int arg2 ;
42934 wxString *arg3 = 0 ;
42935 wxString const &arg4_defvalue = wxPyEmptyString ;
42936 wxString *arg4 = (wxString *) &arg4_defvalue ;
42937 wxMenuItem *result = 0 ;
42938 void *argp1 = 0 ;
42939 int res1 = 0 ;
42940 int val2 ;
42941 int ecode2 = 0 ;
42942 bool temp3 = false ;
42943 bool temp4 = false ;
42944 PyObject * obj0 = 0 ;
42945 PyObject * obj1 = 0 ;
42946 PyObject * obj2 = 0 ;
42947 PyObject * obj3 = 0 ;
42948 char * kwnames[] = {
42949 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42950 };
42951
42952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42954 if (!SWIG_IsOK(res1)) {
42955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42956 }
42957 arg1 = reinterpret_cast< wxMenu * >(argp1);
42958 ecode2 = SWIG_AsVal_int(obj1, &val2);
42959 if (!SWIG_IsOK(ecode2)) {
42960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
42961 }
42962 arg2 = static_cast< int >(val2);
42963 {
42964 arg3 = wxString_in_helper(obj2);
42965 if (arg3 == NULL) SWIG_fail;
42966 temp3 = true;
42967 }
42968 if (obj3) {
42969 {
42970 arg4 = wxString_in_helper(obj3);
42971 if (arg4 == NULL) SWIG_fail;
42972 temp4 = true;
42973 }
42974 }
42975 {
42976 PyThreadState* __tstate = wxPyBeginAllowThreads();
42977 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42978 wxPyEndAllowThreads(__tstate);
42979 if (PyErr_Occurred()) SWIG_fail;
42980 }
42981 {
42982 resultobj = wxPyMake_wxObject(result, (bool)0);
42983 }
42984 {
42985 if (temp3)
42986 delete arg3;
42987 }
42988 {
42989 if (temp4)
42990 delete arg4;
42991 }
42992 return resultobj;
42993 fail:
42994 {
42995 if (temp3)
42996 delete arg3;
42997 }
42998 {
42999 if (temp4)
43000 delete arg4;
43001 }
43002 return NULL;
43003 }
43004
43005
43006 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43007 PyObject *resultobj = 0;
43008 wxMenu *arg1 = (wxMenu *) 0 ;
43009 int arg2 ;
43010 wxString *arg3 = 0 ;
43011 wxMenu *arg4 = (wxMenu *) 0 ;
43012 wxString const &arg5_defvalue = wxPyEmptyString ;
43013 wxString *arg5 = (wxString *) &arg5_defvalue ;
43014 wxMenuItem *result = 0 ;
43015 void *argp1 = 0 ;
43016 int res1 = 0 ;
43017 int val2 ;
43018 int ecode2 = 0 ;
43019 bool temp3 = false ;
43020 void *argp4 = 0 ;
43021 int res4 = 0 ;
43022 bool temp5 = false ;
43023 PyObject * obj0 = 0 ;
43024 PyObject * obj1 = 0 ;
43025 PyObject * obj2 = 0 ;
43026 PyObject * obj3 = 0 ;
43027 PyObject * obj4 = 0 ;
43028 char * kwnames[] = {
43029 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43030 };
43031
43032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43034 if (!SWIG_IsOK(res1)) {
43035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43036 }
43037 arg1 = reinterpret_cast< wxMenu * >(argp1);
43038 ecode2 = SWIG_AsVal_int(obj1, &val2);
43039 if (!SWIG_IsOK(ecode2)) {
43040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43041 }
43042 arg2 = static_cast< int >(val2);
43043 {
43044 arg3 = wxString_in_helper(obj2);
43045 if (arg3 == NULL) SWIG_fail;
43046 temp3 = true;
43047 }
43048 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43049 if (!SWIG_IsOK(res4)) {
43050 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43051 }
43052 arg4 = reinterpret_cast< wxMenu * >(argp4);
43053 if (obj4) {
43054 {
43055 arg5 = wxString_in_helper(obj4);
43056 if (arg5 == NULL) SWIG_fail;
43057 temp5 = true;
43058 }
43059 }
43060 {
43061 PyThreadState* __tstate = wxPyBeginAllowThreads();
43062 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43063 wxPyEndAllowThreads(__tstate);
43064 if (PyErr_Occurred()) SWIG_fail;
43065 }
43066 {
43067 resultobj = wxPyMake_wxObject(result, (bool)0);
43068 }
43069 {
43070 if (temp3)
43071 delete arg3;
43072 }
43073 {
43074 if (temp5)
43075 delete arg5;
43076 }
43077 return resultobj;
43078 fail:
43079 {
43080 if (temp3)
43081 delete arg3;
43082 }
43083 {
43084 if (temp5)
43085 delete arg5;
43086 }
43087 return NULL;
43088 }
43089
43090
43091 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43092 PyObject *resultobj = 0;
43093 wxMenu *arg1 = (wxMenu *) 0 ;
43094 int arg2 ;
43095 wxMenuItem *result = 0 ;
43096 void *argp1 = 0 ;
43097 int res1 = 0 ;
43098 int val2 ;
43099 int ecode2 = 0 ;
43100 PyObject * obj0 = 0 ;
43101 PyObject * obj1 = 0 ;
43102 char * kwnames[] = {
43103 (char *) "self",(char *) "id", NULL
43104 };
43105
43106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43108 if (!SWIG_IsOK(res1)) {
43109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43110 }
43111 arg1 = reinterpret_cast< wxMenu * >(argp1);
43112 ecode2 = SWIG_AsVal_int(obj1, &val2);
43113 if (!SWIG_IsOK(ecode2)) {
43114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43115 }
43116 arg2 = static_cast< int >(val2);
43117 {
43118 PyThreadState* __tstate = wxPyBeginAllowThreads();
43119 result = (wxMenuItem *)(arg1)->Remove(arg2);
43120 wxPyEndAllowThreads(__tstate);
43121 if (PyErr_Occurred()) SWIG_fail;
43122 }
43123 {
43124 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43125 }
43126 return resultobj;
43127 fail:
43128 return NULL;
43129 }
43130
43131
43132 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43133 PyObject *resultobj = 0;
43134 wxMenu *arg1 = (wxMenu *) 0 ;
43135 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43136 wxMenuItem *result = 0 ;
43137 void *argp1 = 0 ;
43138 int res1 = 0 ;
43139 void *argp2 = 0 ;
43140 int res2 = 0 ;
43141 PyObject * obj0 = 0 ;
43142 PyObject * obj1 = 0 ;
43143 char * kwnames[] = {
43144 (char *) "self",(char *) "item", NULL
43145 };
43146
43147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43149 if (!SWIG_IsOK(res1)) {
43150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43151 }
43152 arg1 = reinterpret_cast< wxMenu * >(argp1);
43153 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43154 if (!SWIG_IsOK(res2)) {
43155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43156 }
43157 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43158 {
43159 PyThreadState* __tstate = wxPyBeginAllowThreads();
43160 result = (wxMenuItem *)(arg1)->Remove(arg2);
43161 wxPyEndAllowThreads(__tstate);
43162 if (PyErr_Occurred()) SWIG_fail;
43163 }
43164 {
43165 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43166 }
43167 return resultobj;
43168 fail:
43169 return NULL;
43170 }
43171
43172
43173 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43174 PyObject *resultobj = 0;
43175 wxMenu *arg1 = (wxMenu *) 0 ;
43176 int arg2 ;
43177 bool result;
43178 void *argp1 = 0 ;
43179 int res1 = 0 ;
43180 int val2 ;
43181 int ecode2 = 0 ;
43182 PyObject * obj0 = 0 ;
43183 PyObject * obj1 = 0 ;
43184 char * kwnames[] = {
43185 (char *) "self",(char *) "id", NULL
43186 };
43187
43188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43190 if (!SWIG_IsOK(res1)) {
43191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43192 }
43193 arg1 = reinterpret_cast< wxMenu * >(argp1);
43194 ecode2 = SWIG_AsVal_int(obj1, &val2);
43195 if (!SWIG_IsOK(ecode2)) {
43196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43197 }
43198 arg2 = static_cast< int >(val2);
43199 {
43200 PyThreadState* __tstate = wxPyBeginAllowThreads();
43201 result = (bool)(arg1)->Delete(arg2);
43202 wxPyEndAllowThreads(__tstate);
43203 if (PyErr_Occurred()) SWIG_fail;
43204 }
43205 {
43206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43207 }
43208 return resultobj;
43209 fail:
43210 return NULL;
43211 }
43212
43213
43214 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43215 PyObject *resultobj = 0;
43216 wxMenu *arg1 = (wxMenu *) 0 ;
43217 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43218 bool result;
43219 void *argp1 = 0 ;
43220 int res1 = 0 ;
43221 void *argp2 = 0 ;
43222 int res2 = 0 ;
43223 PyObject * obj0 = 0 ;
43224 PyObject * obj1 = 0 ;
43225 char * kwnames[] = {
43226 (char *) "self",(char *) "item", NULL
43227 };
43228
43229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43231 if (!SWIG_IsOK(res1)) {
43232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43233 }
43234 arg1 = reinterpret_cast< wxMenu * >(argp1);
43235 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43236 if (!SWIG_IsOK(res2)) {
43237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43238 }
43239 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43240 {
43241 PyThreadState* __tstate = wxPyBeginAllowThreads();
43242 result = (bool)(arg1)->Delete(arg2);
43243 wxPyEndAllowThreads(__tstate);
43244 if (PyErr_Occurred()) SWIG_fail;
43245 }
43246 {
43247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43248 }
43249 return resultobj;
43250 fail:
43251 return NULL;
43252 }
43253
43254
43255 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43256 PyObject *resultobj = 0;
43257 wxMenu *arg1 = (wxMenu *) 0 ;
43258 void *argp1 = 0 ;
43259 int res1 = 0 ;
43260 PyObject *swig_obj[1] ;
43261
43262 if (!args) SWIG_fail;
43263 swig_obj[0] = args;
43264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43265 if (!SWIG_IsOK(res1)) {
43266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43267 }
43268 arg1 = reinterpret_cast< wxMenu * >(argp1);
43269 {
43270 PyThreadState* __tstate = wxPyBeginAllowThreads();
43271 wxMenu_Destroy(arg1);
43272 wxPyEndAllowThreads(__tstate);
43273 if (PyErr_Occurred()) SWIG_fail;
43274 }
43275 resultobj = SWIG_Py_Void();
43276 return resultobj;
43277 fail:
43278 return NULL;
43279 }
43280
43281
43282 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43283 PyObject *resultobj = 0;
43284 wxMenu *arg1 = (wxMenu *) 0 ;
43285 int arg2 ;
43286 bool result;
43287 void *argp1 = 0 ;
43288 int res1 = 0 ;
43289 int val2 ;
43290 int ecode2 = 0 ;
43291 PyObject * obj0 = 0 ;
43292 PyObject * obj1 = 0 ;
43293 char * kwnames[] = {
43294 (char *) "self",(char *) "id", NULL
43295 };
43296
43297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43299 if (!SWIG_IsOK(res1)) {
43300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43301 }
43302 arg1 = reinterpret_cast< wxMenu * >(argp1);
43303 ecode2 = SWIG_AsVal_int(obj1, &val2);
43304 if (!SWIG_IsOK(ecode2)) {
43305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43306 }
43307 arg2 = static_cast< int >(val2);
43308 {
43309 PyThreadState* __tstate = wxPyBeginAllowThreads();
43310 result = (bool)(arg1)->Destroy(arg2);
43311 wxPyEndAllowThreads(__tstate);
43312 if (PyErr_Occurred()) SWIG_fail;
43313 }
43314 {
43315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43316 }
43317 return resultobj;
43318 fail:
43319 return NULL;
43320 }
43321
43322
43323 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43324 PyObject *resultobj = 0;
43325 wxMenu *arg1 = (wxMenu *) 0 ;
43326 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43327 bool result;
43328 void *argp1 = 0 ;
43329 int res1 = 0 ;
43330 void *argp2 = 0 ;
43331 int res2 = 0 ;
43332 PyObject * obj0 = 0 ;
43333 PyObject * obj1 = 0 ;
43334 char * kwnames[] = {
43335 (char *) "self",(char *) "item", NULL
43336 };
43337
43338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43340 if (!SWIG_IsOK(res1)) {
43341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43342 }
43343 arg1 = reinterpret_cast< wxMenu * >(argp1);
43344 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43345 if (!SWIG_IsOK(res2)) {
43346 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43347 }
43348 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43349 {
43350 PyThreadState* __tstate = wxPyBeginAllowThreads();
43351 result = (bool)(arg1)->Destroy(arg2);
43352 wxPyEndAllowThreads(__tstate);
43353 if (PyErr_Occurred()) SWIG_fail;
43354 }
43355 {
43356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43357 }
43358 return resultobj;
43359 fail:
43360 return NULL;
43361 }
43362
43363
43364 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43365 PyObject *resultobj = 0;
43366 wxMenu *arg1 = (wxMenu *) 0 ;
43367 size_t result;
43368 void *argp1 = 0 ;
43369 int res1 = 0 ;
43370 PyObject *swig_obj[1] ;
43371
43372 if (!args) SWIG_fail;
43373 swig_obj[0] = args;
43374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43375 if (!SWIG_IsOK(res1)) {
43376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43377 }
43378 arg1 = reinterpret_cast< wxMenu * >(argp1);
43379 {
43380 PyThreadState* __tstate = wxPyBeginAllowThreads();
43381 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43382 wxPyEndAllowThreads(__tstate);
43383 if (PyErr_Occurred()) SWIG_fail;
43384 }
43385 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43386 return resultobj;
43387 fail:
43388 return NULL;
43389 }
43390
43391
43392 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43393 PyObject *resultobj = 0;
43394 wxMenu *arg1 = (wxMenu *) 0 ;
43395 PyObject *result = 0 ;
43396 void *argp1 = 0 ;
43397 int res1 = 0 ;
43398 PyObject *swig_obj[1] ;
43399
43400 if (!args) SWIG_fail;
43401 swig_obj[0] = args;
43402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43403 if (!SWIG_IsOK(res1)) {
43404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43405 }
43406 arg1 = reinterpret_cast< wxMenu * >(argp1);
43407 {
43408 PyThreadState* __tstate = wxPyBeginAllowThreads();
43409 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43410 wxPyEndAllowThreads(__tstate);
43411 if (PyErr_Occurred()) SWIG_fail;
43412 }
43413 resultobj = result;
43414 return resultobj;
43415 fail:
43416 return NULL;
43417 }
43418
43419
43420 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43421 PyObject *resultobj = 0;
43422 wxMenu *arg1 = (wxMenu *) 0 ;
43423 wxString *arg2 = 0 ;
43424 int result;
43425 void *argp1 = 0 ;
43426 int res1 = 0 ;
43427 bool temp2 = false ;
43428 PyObject * obj0 = 0 ;
43429 PyObject * obj1 = 0 ;
43430 char * kwnames[] = {
43431 (char *) "self",(char *) "item", NULL
43432 };
43433
43434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43436 if (!SWIG_IsOK(res1)) {
43437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43438 }
43439 arg1 = reinterpret_cast< wxMenu * >(argp1);
43440 {
43441 arg2 = wxString_in_helper(obj1);
43442 if (arg2 == NULL) SWIG_fail;
43443 temp2 = true;
43444 }
43445 {
43446 PyThreadState* __tstate = wxPyBeginAllowThreads();
43447 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43448 wxPyEndAllowThreads(__tstate);
43449 if (PyErr_Occurred()) SWIG_fail;
43450 }
43451 resultobj = SWIG_From_int(static_cast< int >(result));
43452 {
43453 if (temp2)
43454 delete arg2;
43455 }
43456 return resultobj;
43457 fail:
43458 {
43459 if (temp2)
43460 delete arg2;
43461 }
43462 return NULL;
43463 }
43464
43465
43466 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43467 PyObject *resultobj = 0;
43468 wxMenu *arg1 = (wxMenu *) 0 ;
43469 int arg2 ;
43470 wxMenuItem *result = 0 ;
43471 void *argp1 = 0 ;
43472 int res1 = 0 ;
43473 int val2 ;
43474 int ecode2 = 0 ;
43475 PyObject * obj0 = 0 ;
43476 PyObject * obj1 = 0 ;
43477 char * kwnames[] = {
43478 (char *) "self",(char *) "id", NULL
43479 };
43480
43481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43483 if (!SWIG_IsOK(res1)) {
43484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43485 }
43486 arg1 = reinterpret_cast< wxMenu * >(argp1);
43487 ecode2 = SWIG_AsVal_int(obj1, &val2);
43488 if (!SWIG_IsOK(ecode2)) {
43489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43490 }
43491 arg2 = static_cast< int >(val2);
43492 {
43493 PyThreadState* __tstate = wxPyBeginAllowThreads();
43494 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43495 wxPyEndAllowThreads(__tstate);
43496 if (PyErr_Occurred()) SWIG_fail;
43497 }
43498 {
43499 resultobj = wxPyMake_wxObject(result, (bool)0);
43500 }
43501 return resultobj;
43502 fail:
43503 return NULL;
43504 }
43505
43506
43507 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43508 PyObject *resultobj = 0;
43509 wxMenu *arg1 = (wxMenu *) 0 ;
43510 size_t arg2 ;
43511 wxMenuItem *result = 0 ;
43512 void *argp1 = 0 ;
43513 int res1 = 0 ;
43514 size_t val2 ;
43515 int ecode2 = 0 ;
43516 PyObject * obj0 = 0 ;
43517 PyObject * obj1 = 0 ;
43518 char * kwnames[] = {
43519 (char *) "self",(char *) "position", NULL
43520 };
43521
43522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43524 if (!SWIG_IsOK(res1)) {
43525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43526 }
43527 arg1 = reinterpret_cast< wxMenu * >(argp1);
43528 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43529 if (!SWIG_IsOK(ecode2)) {
43530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43531 }
43532 arg2 = static_cast< size_t >(val2);
43533 {
43534 PyThreadState* __tstate = wxPyBeginAllowThreads();
43535 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43536 wxPyEndAllowThreads(__tstate);
43537 if (PyErr_Occurred()) SWIG_fail;
43538 }
43539 {
43540 resultobj = wxPyMake_wxObject(result, (bool)0);
43541 }
43542 return resultobj;
43543 fail:
43544 return NULL;
43545 }
43546
43547
43548 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43549 PyObject *resultobj = 0;
43550 wxMenu *arg1 = (wxMenu *) 0 ;
43551 int arg2 ;
43552 bool arg3 ;
43553 void *argp1 = 0 ;
43554 int res1 = 0 ;
43555 int val2 ;
43556 int ecode2 = 0 ;
43557 bool val3 ;
43558 int ecode3 = 0 ;
43559 PyObject * obj0 = 0 ;
43560 PyObject * obj1 = 0 ;
43561 PyObject * obj2 = 0 ;
43562 char * kwnames[] = {
43563 (char *) "self",(char *) "id",(char *) "enable", NULL
43564 };
43565
43566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43568 if (!SWIG_IsOK(res1)) {
43569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43570 }
43571 arg1 = reinterpret_cast< wxMenu * >(argp1);
43572 ecode2 = SWIG_AsVal_int(obj1, &val2);
43573 if (!SWIG_IsOK(ecode2)) {
43574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43575 }
43576 arg2 = static_cast< int >(val2);
43577 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43578 if (!SWIG_IsOK(ecode3)) {
43579 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43580 }
43581 arg3 = static_cast< bool >(val3);
43582 {
43583 PyThreadState* __tstate = wxPyBeginAllowThreads();
43584 (arg1)->Enable(arg2,arg3);
43585 wxPyEndAllowThreads(__tstate);
43586 if (PyErr_Occurred()) SWIG_fail;
43587 }
43588 resultobj = SWIG_Py_Void();
43589 return resultobj;
43590 fail:
43591 return NULL;
43592 }
43593
43594
43595 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43596 PyObject *resultobj = 0;
43597 wxMenu *arg1 = (wxMenu *) 0 ;
43598 int arg2 ;
43599 bool result;
43600 void *argp1 = 0 ;
43601 int res1 = 0 ;
43602 int val2 ;
43603 int ecode2 = 0 ;
43604 PyObject * obj0 = 0 ;
43605 PyObject * obj1 = 0 ;
43606 char * kwnames[] = {
43607 (char *) "self",(char *) "id", NULL
43608 };
43609
43610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43612 if (!SWIG_IsOK(res1)) {
43613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43614 }
43615 arg1 = reinterpret_cast< wxMenu * >(argp1);
43616 ecode2 = SWIG_AsVal_int(obj1, &val2);
43617 if (!SWIG_IsOK(ecode2)) {
43618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43619 }
43620 arg2 = static_cast< int >(val2);
43621 {
43622 PyThreadState* __tstate = wxPyBeginAllowThreads();
43623 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43624 wxPyEndAllowThreads(__tstate);
43625 if (PyErr_Occurred()) SWIG_fail;
43626 }
43627 {
43628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43629 }
43630 return resultobj;
43631 fail:
43632 return NULL;
43633 }
43634
43635
43636 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43637 PyObject *resultobj = 0;
43638 wxMenu *arg1 = (wxMenu *) 0 ;
43639 int arg2 ;
43640 bool arg3 ;
43641 void *argp1 = 0 ;
43642 int res1 = 0 ;
43643 int val2 ;
43644 int ecode2 = 0 ;
43645 bool val3 ;
43646 int ecode3 = 0 ;
43647 PyObject * obj0 = 0 ;
43648 PyObject * obj1 = 0 ;
43649 PyObject * obj2 = 0 ;
43650 char * kwnames[] = {
43651 (char *) "self",(char *) "id",(char *) "check", NULL
43652 };
43653
43654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43656 if (!SWIG_IsOK(res1)) {
43657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43658 }
43659 arg1 = reinterpret_cast< wxMenu * >(argp1);
43660 ecode2 = SWIG_AsVal_int(obj1, &val2);
43661 if (!SWIG_IsOK(ecode2)) {
43662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43663 }
43664 arg2 = static_cast< int >(val2);
43665 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43666 if (!SWIG_IsOK(ecode3)) {
43667 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43668 }
43669 arg3 = static_cast< bool >(val3);
43670 {
43671 PyThreadState* __tstate = wxPyBeginAllowThreads();
43672 (arg1)->Check(arg2,arg3);
43673 wxPyEndAllowThreads(__tstate);
43674 if (PyErr_Occurred()) SWIG_fail;
43675 }
43676 resultobj = SWIG_Py_Void();
43677 return resultobj;
43678 fail:
43679 return NULL;
43680 }
43681
43682
43683 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43684 PyObject *resultobj = 0;
43685 wxMenu *arg1 = (wxMenu *) 0 ;
43686 int arg2 ;
43687 bool result;
43688 void *argp1 = 0 ;
43689 int res1 = 0 ;
43690 int val2 ;
43691 int ecode2 = 0 ;
43692 PyObject * obj0 = 0 ;
43693 PyObject * obj1 = 0 ;
43694 char * kwnames[] = {
43695 (char *) "self",(char *) "id", NULL
43696 };
43697
43698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43700 if (!SWIG_IsOK(res1)) {
43701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43702 }
43703 arg1 = reinterpret_cast< wxMenu * >(argp1);
43704 ecode2 = SWIG_AsVal_int(obj1, &val2);
43705 if (!SWIG_IsOK(ecode2)) {
43706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43707 }
43708 arg2 = static_cast< int >(val2);
43709 {
43710 PyThreadState* __tstate = wxPyBeginAllowThreads();
43711 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43712 wxPyEndAllowThreads(__tstate);
43713 if (PyErr_Occurred()) SWIG_fail;
43714 }
43715 {
43716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43717 }
43718 return resultobj;
43719 fail:
43720 return NULL;
43721 }
43722
43723
43724 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43725 PyObject *resultobj = 0;
43726 wxMenu *arg1 = (wxMenu *) 0 ;
43727 int arg2 ;
43728 wxString *arg3 = 0 ;
43729 void *argp1 = 0 ;
43730 int res1 = 0 ;
43731 int val2 ;
43732 int ecode2 = 0 ;
43733 bool temp3 = false ;
43734 PyObject * obj0 = 0 ;
43735 PyObject * obj1 = 0 ;
43736 PyObject * obj2 = 0 ;
43737 char * kwnames[] = {
43738 (char *) "self",(char *) "id",(char *) "label", NULL
43739 };
43740
43741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43743 if (!SWIG_IsOK(res1)) {
43744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
43745 }
43746 arg1 = reinterpret_cast< wxMenu * >(argp1);
43747 ecode2 = SWIG_AsVal_int(obj1, &val2);
43748 if (!SWIG_IsOK(ecode2)) {
43749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
43750 }
43751 arg2 = static_cast< int >(val2);
43752 {
43753 arg3 = wxString_in_helper(obj2);
43754 if (arg3 == NULL) SWIG_fail;
43755 temp3 = true;
43756 }
43757 {
43758 PyThreadState* __tstate = wxPyBeginAllowThreads();
43759 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43760 wxPyEndAllowThreads(__tstate);
43761 if (PyErr_Occurred()) SWIG_fail;
43762 }
43763 resultobj = SWIG_Py_Void();
43764 {
43765 if (temp3)
43766 delete arg3;
43767 }
43768 return resultobj;
43769 fail:
43770 {
43771 if (temp3)
43772 delete arg3;
43773 }
43774 return NULL;
43775 }
43776
43777
43778 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43779 PyObject *resultobj = 0;
43780 wxMenu *arg1 = (wxMenu *) 0 ;
43781 int arg2 ;
43782 wxString result;
43783 void *argp1 = 0 ;
43784 int res1 = 0 ;
43785 int val2 ;
43786 int ecode2 = 0 ;
43787 PyObject * obj0 = 0 ;
43788 PyObject * obj1 = 0 ;
43789 char * kwnames[] = {
43790 (char *) "self",(char *) "id", NULL
43791 };
43792
43793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43795 if (!SWIG_IsOK(res1)) {
43796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
43797 }
43798 arg1 = reinterpret_cast< wxMenu * >(argp1);
43799 ecode2 = SWIG_AsVal_int(obj1, &val2);
43800 if (!SWIG_IsOK(ecode2)) {
43801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
43802 }
43803 arg2 = static_cast< int >(val2);
43804 {
43805 PyThreadState* __tstate = wxPyBeginAllowThreads();
43806 result = ((wxMenu const *)arg1)->GetLabel(arg2);
43807 wxPyEndAllowThreads(__tstate);
43808 if (PyErr_Occurred()) SWIG_fail;
43809 }
43810 {
43811 #if wxUSE_UNICODE
43812 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43813 #else
43814 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43815 #endif
43816 }
43817 return resultobj;
43818 fail:
43819 return NULL;
43820 }
43821
43822
43823 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43824 PyObject *resultobj = 0;
43825 wxMenu *arg1 = (wxMenu *) 0 ;
43826 int arg2 ;
43827 wxString *arg3 = 0 ;
43828 void *argp1 = 0 ;
43829 int res1 = 0 ;
43830 int val2 ;
43831 int ecode2 = 0 ;
43832 bool temp3 = false ;
43833 PyObject * obj0 = 0 ;
43834 PyObject * obj1 = 0 ;
43835 PyObject * obj2 = 0 ;
43836 char * kwnames[] = {
43837 (char *) "self",(char *) "id",(char *) "helpString", NULL
43838 };
43839
43840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43842 if (!SWIG_IsOK(res1)) {
43843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
43844 }
43845 arg1 = reinterpret_cast< wxMenu * >(argp1);
43846 ecode2 = SWIG_AsVal_int(obj1, &val2);
43847 if (!SWIG_IsOK(ecode2)) {
43848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43849 }
43850 arg2 = static_cast< int >(val2);
43851 {
43852 arg3 = wxString_in_helper(obj2);
43853 if (arg3 == NULL) SWIG_fail;
43854 temp3 = true;
43855 }
43856 {
43857 PyThreadState* __tstate = wxPyBeginAllowThreads();
43858 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43859 wxPyEndAllowThreads(__tstate);
43860 if (PyErr_Occurred()) SWIG_fail;
43861 }
43862 resultobj = SWIG_Py_Void();
43863 {
43864 if (temp3)
43865 delete arg3;
43866 }
43867 return resultobj;
43868 fail:
43869 {
43870 if (temp3)
43871 delete arg3;
43872 }
43873 return NULL;
43874 }
43875
43876
43877 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43878 PyObject *resultobj = 0;
43879 wxMenu *arg1 = (wxMenu *) 0 ;
43880 int arg2 ;
43881 wxString result;
43882 void *argp1 = 0 ;
43883 int res1 = 0 ;
43884 int val2 ;
43885 int ecode2 = 0 ;
43886 PyObject * obj0 = 0 ;
43887 PyObject * obj1 = 0 ;
43888 char * kwnames[] = {
43889 (char *) "self",(char *) "id", NULL
43890 };
43891
43892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43894 if (!SWIG_IsOK(res1)) {
43895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
43896 }
43897 arg1 = reinterpret_cast< wxMenu * >(argp1);
43898 ecode2 = SWIG_AsVal_int(obj1, &val2);
43899 if (!SWIG_IsOK(ecode2)) {
43900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43901 }
43902 arg2 = static_cast< int >(val2);
43903 {
43904 PyThreadState* __tstate = wxPyBeginAllowThreads();
43905 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
43906 wxPyEndAllowThreads(__tstate);
43907 if (PyErr_Occurred()) SWIG_fail;
43908 }
43909 {
43910 #if wxUSE_UNICODE
43911 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43912 #else
43913 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43914 #endif
43915 }
43916 return resultobj;
43917 fail:
43918 return NULL;
43919 }
43920
43921
43922 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43923 PyObject *resultobj = 0;
43924 wxMenu *arg1 = (wxMenu *) 0 ;
43925 wxString *arg2 = 0 ;
43926 void *argp1 = 0 ;
43927 int res1 = 0 ;
43928 bool temp2 = false ;
43929 PyObject * obj0 = 0 ;
43930 PyObject * obj1 = 0 ;
43931 char * kwnames[] = {
43932 (char *) "self",(char *) "title", NULL
43933 };
43934
43935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
43936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43937 if (!SWIG_IsOK(res1)) {
43938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
43939 }
43940 arg1 = reinterpret_cast< wxMenu * >(argp1);
43941 {
43942 arg2 = wxString_in_helper(obj1);
43943 if (arg2 == NULL) SWIG_fail;
43944 temp2 = true;
43945 }
43946 {
43947 PyThreadState* __tstate = wxPyBeginAllowThreads();
43948 (arg1)->SetTitle((wxString const &)*arg2);
43949 wxPyEndAllowThreads(__tstate);
43950 if (PyErr_Occurred()) SWIG_fail;
43951 }
43952 resultobj = SWIG_Py_Void();
43953 {
43954 if (temp2)
43955 delete arg2;
43956 }
43957 return resultobj;
43958 fail:
43959 {
43960 if (temp2)
43961 delete arg2;
43962 }
43963 return NULL;
43964 }
43965
43966
43967 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43968 PyObject *resultobj = 0;
43969 wxMenu *arg1 = (wxMenu *) 0 ;
43970 wxString result;
43971 void *argp1 = 0 ;
43972 int res1 = 0 ;
43973 PyObject *swig_obj[1] ;
43974
43975 if (!args) SWIG_fail;
43976 swig_obj[0] = args;
43977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43978 if (!SWIG_IsOK(res1)) {
43979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
43980 }
43981 arg1 = reinterpret_cast< wxMenu * >(argp1);
43982 {
43983 PyThreadState* __tstate = wxPyBeginAllowThreads();
43984 result = ((wxMenu const *)arg1)->GetTitle();
43985 wxPyEndAllowThreads(__tstate);
43986 if (PyErr_Occurred()) SWIG_fail;
43987 }
43988 {
43989 #if wxUSE_UNICODE
43990 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43991 #else
43992 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43993 #endif
43994 }
43995 return resultobj;
43996 fail:
43997 return NULL;
43998 }
43999
44000
44001 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44002 PyObject *resultobj = 0;
44003 wxMenu *arg1 = (wxMenu *) 0 ;
44004 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
44005 void *argp1 = 0 ;
44006 int res1 = 0 ;
44007 void *argp2 = 0 ;
44008 int res2 = 0 ;
44009 PyObject * obj0 = 0 ;
44010 PyObject * obj1 = 0 ;
44011 char * kwnames[] = {
44012 (char *) "self",(char *) "handler", NULL
44013 };
44014
44015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
44016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44017 if (!SWIG_IsOK(res1)) {
44018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44019 }
44020 arg1 = reinterpret_cast< wxMenu * >(argp1);
44021 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44022 if (!SWIG_IsOK(res2)) {
44023 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44024 }
44025 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44026 {
44027 PyThreadState* __tstate = wxPyBeginAllowThreads();
44028 (arg1)->SetEventHandler(arg2);
44029 wxPyEndAllowThreads(__tstate);
44030 if (PyErr_Occurred()) SWIG_fail;
44031 }
44032 resultobj = SWIG_Py_Void();
44033 return resultobj;
44034 fail:
44035 return NULL;
44036 }
44037
44038
44039 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44040 PyObject *resultobj = 0;
44041 wxMenu *arg1 = (wxMenu *) 0 ;
44042 wxEvtHandler *result = 0 ;
44043 void *argp1 = 0 ;
44044 int res1 = 0 ;
44045 PyObject *swig_obj[1] ;
44046
44047 if (!args) SWIG_fail;
44048 swig_obj[0] = args;
44049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44050 if (!SWIG_IsOK(res1)) {
44051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44052 }
44053 arg1 = reinterpret_cast< wxMenu * >(argp1);
44054 {
44055 PyThreadState* __tstate = wxPyBeginAllowThreads();
44056 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44057 wxPyEndAllowThreads(__tstate);
44058 if (PyErr_Occurred()) SWIG_fail;
44059 }
44060 {
44061 resultobj = wxPyMake_wxObject(result, 0);
44062 }
44063 return resultobj;
44064 fail:
44065 return NULL;
44066 }
44067
44068
44069 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44070 PyObject *resultobj = 0;
44071 wxMenu *arg1 = (wxMenu *) 0 ;
44072 wxWindow *arg2 = (wxWindow *) 0 ;
44073 void *argp1 = 0 ;
44074 int res1 = 0 ;
44075 void *argp2 = 0 ;
44076 int res2 = 0 ;
44077 PyObject * obj0 = 0 ;
44078 PyObject * obj1 = 0 ;
44079 char * kwnames[] = {
44080 (char *) "self",(char *) "win", NULL
44081 };
44082
44083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44085 if (!SWIG_IsOK(res1)) {
44086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44087 }
44088 arg1 = reinterpret_cast< wxMenu * >(argp1);
44089 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44090 if (!SWIG_IsOK(res2)) {
44091 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44092 }
44093 arg2 = reinterpret_cast< wxWindow * >(argp2);
44094 {
44095 PyThreadState* __tstate = wxPyBeginAllowThreads();
44096 (arg1)->SetInvokingWindow(arg2);
44097 wxPyEndAllowThreads(__tstate);
44098 if (PyErr_Occurred()) SWIG_fail;
44099 }
44100 resultobj = SWIG_Py_Void();
44101 return resultobj;
44102 fail:
44103 return NULL;
44104 }
44105
44106
44107 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44108 PyObject *resultobj = 0;
44109 wxMenu *arg1 = (wxMenu *) 0 ;
44110 wxWindow *result = 0 ;
44111 void *argp1 = 0 ;
44112 int res1 = 0 ;
44113 PyObject *swig_obj[1] ;
44114
44115 if (!args) SWIG_fail;
44116 swig_obj[0] = args;
44117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44118 if (!SWIG_IsOK(res1)) {
44119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44120 }
44121 arg1 = reinterpret_cast< wxMenu * >(argp1);
44122 {
44123 PyThreadState* __tstate = wxPyBeginAllowThreads();
44124 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44125 wxPyEndAllowThreads(__tstate);
44126 if (PyErr_Occurred()) SWIG_fail;
44127 }
44128 {
44129 resultobj = wxPyMake_wxObject(result, 0);
44130 }
44131 return resultobj;
44132 fail:
44133 return NULL;
44134 }
44135
44136
44137 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44138 PyObject *resultobj = 0;
44139 wxMenu *arg1 = (wxMenu *) 0 ;
44140 long result;
44141 void *argp1 = 0 ;
44142 int res1 = 0 ;
44143 PyObject *swig_obj[1] ;
44144
44145 if (!args) SWIG_fail;
44146 swig_obj[0] = args;
44147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44148 if (!SWIG_IsOK(res1)) {
44149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44150 }
44151 arg1 = reinterpret_cast< wxMenu * >(argp1);
44152 {
44153 PyThreadState* __tstate = wxPyBeginAllowThreads();
44154 result = (long)((wxMenu const *)arg1)->GetStyle();
44155 wxPyEndAllowThreads(__tstate);
44156 if (PyErr_Occurred()) SWIG_fail;
44157 }
44158 resultobj = SWIG_From_long(static_cast< long >(result));
44159 return resultobj;
44160 fail:
44161 return NULL;
44162 }
44163
44164
44165 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44166 PyObject *resultobj = 0;
44167 wxMenu *arg1 = (wxMenu *) 0 ;
44168 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44169 void *argp1 = 0 ;
44170 int res1 = 0 ;
44171 void *argp2 = 0 ;
44172 int res2 = 0 ;
44173 PyObject * obj0 = 0 ;
44174 PyObject * obj1 = 0 ;
44175 char * kwnames[] = {
44176 (char *) "self",(char *) "source", NULL
44177 };
44178
44179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44181 if (!SWIG_IsOK(res1)) {
44182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44183 }
44184 arg1 = reinterpret_cast< wxMenu * >(argp1);
44185 if (obj1) {
44186 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44187 if (!SWIG_IsOK(res2)) {
44188 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44189 }
44190 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44191 }
44192 {
44193 PyThreadState* __tstate = wxPyBeginAllowThreads();
44194 (arg1)->UpdateUI(arg2);
44195 wxPyEndAllowThreads(__tstate);
44196 if (PyErr_Occurred()) SWIG_fail;
44197 }
44198 resultobj = SWIG_Py_Void();
44199 return resultobj;
44200 fail:
44201 return NULL;
44202 }
44203
44204
44205 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44206 PyObject *resultobj = 0;
44207 wxMenu *arg1 = (wxMenu *) 0 ;
44208 wxMenuBar *result = 0 ;
44209 void *argp1 = 0 ;
44210 int res1 = 0 ;
44211 PyObject *swig_obj[1] ;
44212
44213 if (!args) SWIG_fail;
44214 swig_obj[0] = args;
44215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44216 if (!SWIG_IsOK(res1)) {
44217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44218 }
44219 arg1 = reinterpret_cast< wxMenu * >(argp1);
44220 {
44221 PyThreadState* __tstate = wxPyBeginAllowThreads();
44222 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44223 wxPyEndAllowThreads(__tstate);
44224 if (PyErr_Occurred()) SWIG_fail;
44225 }
44226 {
44227 resultobj = wxPyMake_wxObject(result, (bool)0);
44228 }
44229 return resultobj;
44230 fail:
44231 return NULL;
44232 }
44233
44234
44235 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44236 PyObject *resultobj = 0;
44237 wxMenu *arg1 = (wxMenu *) 0 ;
44238 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44239 void *argp1 = 0 ;
44240 int res1 = 0 ;
44241 void *argp2 = 0 ;
44242 int res2 = 0 ;
44243 PyObject * obj0 = 0 ;
44244 PyObject * obj1 = 0 ;
44245 char * kwnames[] = {
44246 (char *) "self",(char *) "menubar", NULL
44247 };
44248
44249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44251 if (!SWIG_IsOK(res1)) {
44252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44253 }
44254 arg1 = reinterpret_cast< wxMenu * >(argp1);
44255 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44256 if (!SWIG_IsOK(res2)) {
44257 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44258 }
44259 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44260 {
44261 PyThreadState* __tstate = wxPyBeginAllowThreads();
44262 (arg1)->Attach(arg2);
44263 wxPyEndAllowThreads(__tstate);
44264 if (PyErr_Occurred()) SWIG_fail;
44265 }
44266 resultobj = SWIG_Py_Void();
44267 return resultobj;
44268 fail:
44269 return NULL;
44270 }
44271
44272
44273 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44274 PyObject *resultobj = 0;
44275 wxMenu *arg1 = (wxMenu *) 0 ;
44276 void *argp1 = 0 ;
44277 int res1 = 0 ;
44278 PyObject *swig_obj[1] ;
44279
44280 if (!args) SWIG_fail;
44281 swig_obj[0] = args;
44282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44283 if (!SWIG_IsOK(res1)) {
44284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44285 }
44286 arg1 = reinterpret_cast< wxMenu * >(argp1);
44287 {
44288 PyThreadState* __tstate = wxPyBeginAllowThreads();
44289 (arg1)->Detach();
44290 wxPyEndAllowThreads(__tstate);
44291 if (PyErr_Occurred()) SWIG_fail;
44292 }
44293 resultobj = SWIG_Py_Void();
44294 return resultobj;
44295 fail:
44296 return NULL;
44297 }
44298
44299
44300 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44301 PyObject *resultobj = 0;
44302 wxMenu *arg1 = (wxMenu *) 0 ;
44303 bool result;
44304 void *argp1 = 0 ;
44305 int res1 = 0 ;
44306 PyObject *swig_obj[1] ;
44307
44308 if (!args) SWIG_fail;
44309 swig_obj[0] = args;
44310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44311 if (!SWIG_IsOK(res1)) {
44312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44313 }
44314 arg1 = reinterpret_cast< wxMenu * >(argp1);
44315 {
44316 PyThreadState* __tstate = wxPyBeginAllowThreads();
44317 result = (bool)((wxMenu const *)arg1)->IsAttached();
44318 wxPyEndAllowThreads(__tstate);
44319 if (PyErr_Occurred()) SWIG_fail;
44320 }
44321 {
44322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44323 }
44324 return resultobj;
44325 fail:
44326 return NULL;
44327 }
44328
44329
44330 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44331 PyObject *resultobj = 0;
44332 wxMenu *arg1 = (wxMenu *) 0 ;
44333 wxMenu *arg2 = (wxMenu *) 0 ;
44334 void *argp1 = 0 ;
44335 int res1 = 0 ;
44336 void *argp2 = 0 ;
44337 int res2 = 0 ;
44338 PyObject * obj0 = 0 ;
44339 PyObject * obj1 = 0 ;
44340 char * kwnames[] = {
44341 (char *) "self",(char *) "parent", NULL
44342 };
44343
44344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44346 if (!SWIG_IsOK(res1)) {
44347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44348 }
44349 arg1 = reinterpret_cast< wxMenu * >(argp1);
44350 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44351 if (!SWIG_IsOK(res2)) {
44352 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44353 }
44354 arg2 = reinterpret_cast< wxMenu * >(argp2);
44355 {
44356 PyThreadState* __tstate = wxPyBeginAllowThreads();
44357 (arg1)->SetParent(arg2);
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_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44369 PyObject *resultobj = 0;
44370 wxMenu *arg1 = (wxMenu *) 0 ;
44371 wxMenu *result = 0 ;
44372 void *argp1 = 0 ;
44373 int res1 = 0 ;
44374 PyObject *swig_obj[1] ;
44375
44376 if (!args) SWIG_fail;
44377 swig_obj[0] = args;
44378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44379 if (!SWIG_IsOK(res1)) {
44380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44381 }
44382 arg1 = reinterpret_cast< wxMenu * >(argp1);
44383 {
44384 PyThreadState* __tstate = wxPyBeginAllowThreads();
44385 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44386 wxPyEndAllowThreads(__tstate);
44387 if (PyErr_Occurred()) SWIG_fail;
44388 }
44389 {
44390 resultobj = wxPyMake_wxObject(result, 0);
44391 }
44392 return resultobj;
44393 fail:
44394 return NULL;
44395 }
44396
44397
44398 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44399 PyObject *obj;
44400 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44401 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44402 return SWIG_Py_Void();
44403 }
44404
44405 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44406 return SWIG_Python_InitShadowInstance(args);
44407 }
44408
44409 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44410 PyObject *resultobj = 0;
44411 long arg1 = (long) 0 ;
44412 wxMenuBar *result = 0 ;
44413 long val1 ;
44414 int ecode1 = 0 ;
44415 PyObject * obj0 = 0 ;
44416 char * kwnames[] = {
44417 (char *) "style", NULL
44418 };
44419
44420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44421 if (obj0) {
44422 ecode1 = SWIG_AsVal_long(obj0, &val1);
44423 if (!SWIG_IsOK(ecode1)) {
44424 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44425 }
44426 arg1 = static_cast< long >(val1);
44427 }
44428 {
44429 if (!wxPyCheckForApp()) SWIG_fail;
44430 PyThreadState* __tstate = wxPyBeginAllowThreads();
44431 result = (wxMenuBar *)new wxMenuBar(arg1);
44432 wxPyEndAllowThreads(__tstate);
44433 if (PyErr_Occurred()) SWIG_fail;
44434 }
44435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44436 return resultobj;
44437 fail:
44438 return NULL;
44439 }
44440
44441
44442 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44443 PyObject *resultobj = 0;
44444 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44445 wxMenu *arg2 = (wxMenu *) 0 ;
44446 wxString *arg3 = 0 ;
44447 bool result;
44448 void *argp1 = 0 ;
44449 int res1 = 0 ;
44450 void *argp2 = 0 ;
44451 int res2 = 0 ;
44452 bool temp3 = false ;
44453 PyObject * obj0 = 0 ;
44454 PyObject * obj1 = 0 ;
44455 PyObject * obj2 = 0 ;
44456 char * kwnames[] = {
44457 (char *) "self",(char *) "menu",(char *) "title", NULL
44458 };
44459
44460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44462 if (!SWIG_IsOK(res1)) {
44463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44464 }
44465 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44466 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44467 if (!SWIG_IsOK(res2)) {
44468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44469 }
44470 arg2 = reinterpret_cast< wxMenu * >(argp2);
44471 {
44472 arg3 = wxString_in_helper(obj2);
44473 if (arg3 == NULL) SWIG_fail;
44474 temp3 = true;
44475 }
44476 {
44477 PyThreadState* __tstate = wxPyBeginAllowThreads();
44478 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44479 wxPyEndAllowThreads(__tstate);
44480 if (PyErr_Occurred()) SWIG_fail;
44481 }
44482 {
44483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44484 }
44485 {
44486 if (temp3)
44487 delete arg3;
44488 }
44489 return resultobj;
44490 fail:
44491 {
44492 if (temp3)
44493 delete arg3;
44494 }
44495 return NULL;
44496 }
44497
44498
44499 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44500 PyObject *resultobj = 0;
44501 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44502 size_t arg2 ;
44503 wxMenu *arg3 = (wxMenu *) 0 ;
44504 wxString *arg4 = 0 ;
44505 bool result;
44506 void *argp1 = 0 ;
44507 int res1 = 0 ;
44508 size_t val2 ;
44509 int ecode2 = 0 ;
44510 void *argp3 = 0 ;
44511 int res3 = 0 ;
44512 bool temp4 = false ;
44513 PyObject * obj0 = 0 ;
44514 PyObject * obj1 = 0 ;
44515 PyObject * obj2 = 0 ;
44516 PyObject * obj3 = 0 ;
44517 char * kwnames[] = {
44518 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44519 };
44520
44521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44523 if (!SWIG_IsOK(res1)) {
44524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44525 }
44526 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44527 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44528 if (!SWIG_IsOK(ecode2)) {
44529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44530 }
44531 arg2 = static_cast< size_t >(val2);
44532 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44533 if (!SWIG_IsOK(res3)) {
44534 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44535 }
44536 arg3 = reinterpret_cast< wxMenu * >(argp3);
44537 {
44538 arg4 = wxString_in_helper(obj3);
44539 if (arg4 == NULL) SWIG_fail;
44540 temp4 = true;
44541 }
44542 {
44543 PyThreadState* __tstate = wxPyBeginAllowThreads();
44544 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44545 wxPyEndAllowThreads(__tstate);
44546 if (PyErr_Occurred()) SWIG_fail;
44547 }
44548 {
44549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44550 }
44551 {
44552 if (temp4)
44553 delete arg4;
44554 }
44555 return resultobj;
44556 fail:
44557 {
44558 if (temp4)
44559 delete arg4;
44560 }
44561 return NULL;
44562 }
44563
44564
44565 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44566 PyObject *resultobj = 0;
44567 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44568 size_t result;
44569 void *argp1 = 0 ;
44570 int res1 = 0 ;
44571 PyObject *swig_obj[1] ;
44572
44573 if (!args) SWIG_fail;
44574 swig_obj[0] = args;
44575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44576 if (!SWIG_IsOK(res1)) {
44577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44578 }
44579 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44580 {
44581 PyThreadState* __tstate = wxPyBeginAllowThreads();
44582 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44583 wxPyEndAllowThreads(__tstate);
44584 if (PyErr_Occurred()) SWIG_fail;
44585 }
44586 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44587 return resultobj;
44588 fail:
44589 return NULL;
44590 }
44591
44592
44593 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44594 PyObject *resultobj = 0;
44595 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44596 size_t arg2 ;
44597 wxMenu *result = 0 ;
44598 void *argp1 = 0 ;
44599 int res1 = 0 ;
44600 size_t val2 ;
44601 int ecode2 = 0 ;
44602 PyObject * obj0 = 0 ;
44603 PyObject * obj1 = 0 ;
44604 char * kwnames[] = {
44605 (char *) "self",(char *) "pos", NULL
44606 };
44607
44608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44610 if (!SWIG_IsOK(res1)) {
44611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44612 }
44613 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44614 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44615 if (!SWIG_IsOK(ecode2)) {
44616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44617 }
44618 arg2 = static_cast< size_t >(val2);
44619 {
44620 PyThreadState* __tstate = wxPyBeginAllowThreads();
44621 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44622 wxPyEndAllowThreads(__tstate);
44623 if (PyErr_Occurred()) SWIG_fail;
44624 }
44625 {
44626 resultobj = wxPyMake_wxObject(result, 0);
44627 }
44628 return resultobj;
44629 fail:
44630 return NULL;
44631 }
44632
44633
44634 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44635 PyObject *resultobj = 0;
44636 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44637 size_t arg2 ;
44638 wxMenu *arg3 = (wxMenu *) 0 ;
44639 wxString *arg4 = 0 ;
44640 wxMenu *result = 0 ;
44641 void *argp1 = 0 ;
44642 int res1 = 0 ;
44643 size_t val2 ;
44644 int ecode2 = 0 ;
44645 void *argp3 = 0 ;
44646 int res3 = 0 ;
44647 bool temp4 = false ;
44648 PyObject * obj0 = 0 ;
44649 PyObject * obj1 = 0 ;
44650 PyObject * obj2 = 0 ;
44651 PyObject * obj3 = 0 ;
44652 char * kwnames[] = {
44653 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44654 };
44655
44656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44658 if (!SWIG_IsOK(res1)) {
44659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44660 }
44661 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44662 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44663 if (!SWIG_IsOK(ecode2)) {
44664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44665 }
44666 arg2 = static_cast< size_t >(val2);
44667 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44668 if (!SWIG_IsOK(res3)) {
44669 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44670 }
44671 arg3 = reinterpret_cast< wxMenu * >(argp3);
44672 {
44673 arg4 = wxString_in_helper(obj3);
44674 if (arg4 == NULL) SWIG_fail;
44675 temp4 = true;
44676 }
44677 {
44678 PyThreadState* __tstate = wxPyBeginAllowThreads();
44679 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44680 wxPyEndAllowThreads(__tstate);
44681 if (PyErr_Occurred()) SWIG_fail;
44682 }
44683 {
44684 resultobj = wxPyMake_wxObject(result, 0);
44685 }
44686 {
44687 if (temp4)
44688 delete arg4;
44689 }
44690 return resultobj;
44691 fail:
44692 {
44693 if (temp4)
44694 delete arg4;
44695 }
44696 return NULL;
44697 }
44698
44699
44700 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44701 PyObject *resultobj = 0;
44702 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44703 size_t arg2 ;
44704 wxMenu *result = 0 ;
44705 void *argp1 = 0 ;
44706 int res1 = 0 ;
44707 size_t val2 ;
44708 int ecode2 = 0 ;
44709 PyObject * obj0 = 0 ;
44710 PyObject * obj1 = 0 ;
44711 char * kwnames[] = {
44712 (char *) "self",(char *) "pos", NULL
44713 };
44714
44715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44717 if (!SWIG_IsOK(res1)) {
44718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44719 }
44720 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44721 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44722 if (!SWIG_IsOK(ecode2)) {
44723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
44724 }
44725 arg2 = static_cast< size_t >(val2);
44726 {
44727 PyThreadState* __tstate = wxPyBeginAllowThreads();
44728 result = (wxMenu *)(arg1)->Remove(arg2);
44729 wxPyEndAllowThreads(__tstate);
44730 if (PyErr_Occurred()) SWIG_fail;
44731 }
44732 {
44733 resultobj = wxPyMake_wxObject(result, 0);
44734 }
44735 return resultobj;
44736 fail:
44737 return NULL;
44738 }
44739
44740
44741 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44742 PyObject *resultobj = 0;
44743 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44744 size_t arg2 ;
44745 bool arg3 ;
44746 void *argp1 = 0 ;
44747 int res1 = 0 ;
44748 size_t val2 ;
44749 int ecode2 = 0 ;
44750 bool val3 ;
44751 int ecode3 = 0 ;
44752 PyObject * obj0 = 0 ;
44753 PyObject * obj1 = 0 ;
44754 PyObject * obj2 = 0 ;
44755 char * kwnames[] = {
44756 (char *) "self",(char *) "pos",(char *) "enable", NULL
44757 };
44758
44759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44761 if (!SWIG_IsOK(res1)) {
44762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44763 }
44764 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44765 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44766 if (!SWIG_IsOK(ecode2)) {
44767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
44768 }
44769 arg2 = static_cast< size_t >(val2);
44770 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44771 if (!SWIG_IsOK(ecode3)) {
44772 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
44773 }
44774 arg3 = static_cast< bool >(val3);
44775 {
44776 PyThreadState* __tstate = wxPyBeginAllowThreads();
44777 (arg1)->EnableTop(arg2,arg3);
44778 wxPyEndAllowThreads(__tstate);
44779 if (PyErr_Occurred()) SWIG_fail;
44780 }
44781 resultobj = SWIG_Py_Void();
44782 return resultobj;
44783 fail:
44784 return NULL;
44785 }
44786
44787
44788 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44789 PyObject *resultobj = 0;
44790 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44791 size_t arg2 ;
44792 bool result;
44793 void *argp1 = 0 ;
44794 int res1 = 0 ;
44795 size_t val2 ;
44796 int ecode2 = 0 ;
44797 PyObject * obj0 = 0 ;
44798 PyObject * obj1 = 0 ;
44799 char * kwnames[] = {
44800 (char *) "self",(char *) "pos", NULL
44801 };
44802
44803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
44804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44805 if (!SWIG_IsOK(res1)) {
44806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44807 }
44808 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44809 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44810 if (!SWIG_IsOK(ecode2)) {
44811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
44812 }
44813 arg2 = static_cast< size_t >(val2);
44814 {
44815 PyThreadState* __tstate = wxPyBeginAllowThreads();
44816 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
44817 wxPyEndAllowThreads(__tstate);
44818 if (PyErr_Occurred()) SWIG_fail;
44819 }
44820 {
44821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44822 }
44823 return resultobj;
44824 fail:
44825 return NULL;
44826 }
44827
44828
44829 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44830 PyObject *resultobj = 0;
44831 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44832 size_t arg2 ;
44833 wxString *arg3 = 0 ;
44834 void *argp1 = 0 ;
44835 int res1 = 0 ;
44836 size_t val2 ;
44837 int ecode2 = 0 ;
44838 bool temp3 = false ;
44839 PyObject * obj0 = 0 ;
44840 PyObject * obj1 = 0 ;
44841 PyObject * obj2 = 0 ;
44842 char * kwnames[] = {
44843 (char *) "self",(char *) "pos",(char *) "label", NULL
44844 };
44845
44846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44848 if (!SWIG_IsOK(res1)) {
44849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44850 }
44851 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44852 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44853 if (!SWIG_IsOK(ecode2)) {
44854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44855 }
44856 arg2 = static_cast< size_t >(val2);
44857 {
44858 arg3 = wxString_in_helper(obj2);
44859 if (arg3 == NULL) SWIG_fail;
44860 temp3 = true;
44861 }
44862 {
44863 PyThreadState* __tstate = wxPyBeginAllowThreads();
44864 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
44865 wxPyEndAllowThreads(__tstate);
44866 if (PyErr_Occurred()) SWIG_fail;
44867 }
44868 resultobj = SWIG_Py_Void();
44869 {
44870 if (temp3)
44871 delete arg3;
44872 }
44873 return resultobj;
44874 fail:
44875 {
44876 if (temp3)
44877 delete arg3;
44878 }
44879 return NULL;
44880 }
44881
44882
44883 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44884 PyObject *resultobj = 0;
44885 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44886 size_t arg2 ;
44887 wxString result;
44888 void *argp1 = 0 ;
44889 int res1 = 0 ;
44890 size_t val2 ;
44891 int ecode2 = 0 ;
44892 PyObject * obj0 = 0 ;
44893 PyObject * obj1 = 0 ;
44894 char * kwnames[] = {
44895 (char *) "self",(char *) "pos", NULL
44896 };
44897
44898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
44899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44900 if (!SWIG_IsOK(res1)) {
44901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44902 }
44903 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44904 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44905 if (!SWIG_IsOK(ecode2)) {
44906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44907 }
44908 arg2 = static_cast< size_t >(val2);
44909 {
44910 PyThreadState* __tstate = wxPyBeginAllowThreads();
44911 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
44912 wxPyEndAllowThreads(__tstate);
44913 if (PyErr_Occurred()) SWIG_fail;
44914 }
44915 {
44916 #if wxUSE_UNICODE
44917 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44918 #else
44919 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44920 #endif
44921 }
44922 return resultobj;
44923 fail:
44924 return NULL;
44925 }
44926
44927
44928 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44929 PyObject *resultobj = 0;
44930 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44931 wxString *arg2 = 0 ;
44932 wxString *arg3 = 0 ;
44933 int result;
44934 void *argp1 = 0 ;
44935 int res1 = 0 ;
44936 bool temp2 = false ;
44937 bool temp3 = false ;
44938 PyObject * obj0 = 0 ;
44939 PyObject * obj1 = 0 ;
44940 PyObject * obj2 = 0 ;
44941 char * kwnames[] = {
44942 (char *) "self",(char *) "menu",(char *) "item", NULL
44943 };
44944
44945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44947 if (!SWIG_IsOK(res1)) {
44948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44949 }
44950 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44951 {
44952 arg2 = wxString_in_helper(obj1);
44953 if (arg2 == NULL) SWIG_fail;
44954 temp2 = true;
44955 }
44956 {
44957 arg3 = wxString_in_helper(obj2);
44958 if (arg3 == NULL) SWIG_fail;
44959 temp3 = true;
44960 }
44961 {
44962 PyThreadState* __tstate = wxPyBeginAllowThreads();
44963 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
44964 wxPyEndAllowThreads(__tstate);
44965 if (PyErr_Occurred()) SWIG_fail;
44966 }
44967 resultobj = SWIG_From_int(static_cast< int >(result));
44968 {
44969 if (temp2)
44970 delete arg2;
44971 }
44972 {
44973 if (temp3)
44974 delete arg3;
44975 }
44976 return resultobj;
44977 fail:
44978 {
44979 if (temp2)
44980 delete arg2;
44981 }
44982 {
44983 if (temp3)
44984 delete arg3;
44985 }
44986 return NULL;
44987 }
44988
44989
44990 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44991 PyObject *resultobj = 0;
44992 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44993 int arg2 ;
44994 wxMenuItem *result = 0 ;
44995 void *argp1 = 0 ;
44996 int res1 = 0 ;
44997 int val2 ;
44998 int ecode2 = 0 ;
44999 PyObject * obj0 = 0 ;
45000 PyObject * obj1 = 0 ;
45001 char * kwnames[] = {
45002 (char *) "self",(char *) "id", NULL
45003 };
45004
45005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
45006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45007 if (!SWIG_IsOK(res1)) {
45008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45009 }
45010 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45011 ecode2 = SWIG_AsVal_int(obj1, &val2);
45012 if (!SWIG_IsOK(ecode2)) {
45013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
45014 }
45015 arg2 = static_cast< int >(val2);
45016 {
45017 PyThreadState* __tstate = wxPyBeginAllowThreads();
45018 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45019 wxPyEndAllowThreads(__tstate);
45020 if (PyErr_Occurred()) SWIG_fail;
45021 }
45022 {
45023 resultobj = wxPyMake_wxObject(result, (bool)0);
45024 }
45025 return resultobj;
45026 fail:
45027 return NULL;
45028 }
45029
45030
45031 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45032 PyObject *resultobj = 0;
45033 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45034 wxString *arg2 = 0 ;
45035 int result;
45036 void *argp1 = 0 ;
45037 int res1 = 0 ;
45038 bool temp2 = false ;
45039 PyObject * obj0 = 0 ;
45040 PyObject * obj1 = 0 ;
45041 char * kwnames[] = {
45042 (char *) "self",(char *) "title", NULL
45043 };
45044
45045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45047 if (!SWIG_IsOK(res1)) {
45048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45049 }
45050 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45051 {
45052 arg2 = wxString_in_helper(obj1);
45053 if (arg2 == NULL) SWIG_fail;
45054 temp2 = true;
45055 }
45056 {
45057 PyThreadState* __tstate = wxPyBeginAllowThreads();
45058 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45059 wxPyEndAllowThreads(__tstate);
45060 if (PyErr_Occurred()) SWIG_fail;
45061 }
45062 resultobj = SWIG_From_int(static_cast< int >(result));
45063 {
45064 if (temp2)
45065 delete arg2;
45066 }
45067 return resultobj;
45068 fail:
45069 {
45070 if (temp2)
45071 delete arg2;
45072 }
45073 return NULL;
45074 }
45075
45076
45077 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45078 PyObject *resultobj = 0;
45079 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45080 int arg2 ;
45081 bool arg3 ;
45082 void *argp1 = 0 ;
45083 int res1 = 0 ;
45084 int val2 ;
45085 int ecode2 = 0 ;
45086 bool val3 ;
45087 int ecode3 = 0 ;
45088 PyObject * obj0 = 0 ;
45089 PyObject * obj1 = 0 ;
45090 PyObject * obj2 = 0 ;
45091 char * kwnames[] = {
45092 (char *) "self",(char *) "id",(char *) "enable", NULL
45093 };
45094
45095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45097 if (!SWIG_IsOK(res1)) {
45098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45099 }
45100 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45101 ecode2 = SWIG_AsVal_int(obj1, &val2);
45102 if (!SWIG_IsOK(ecode2)) {
45103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45104 }
45105 arg2 = static_cast< int >(val2);
45106 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45107 if (!SWIG_IsOK(ecode3)) {
45108 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45109 }
45110 arg3 = static_cast< bool >(val3);
45111 {
45112 PyThreadState* __tstate = wxPyBeginAllowThreads();
45113 (arg1)->Enable(arg2,arg3);
45114 wxPyEndAllowThreads(__tstate);
45115 if (PyErr_Occurred()) SWIG_fail;
45116 }
45117 resultobj = SWIG_Py_Void();
45118 return resultobj;
45119 fail:
45120 return NULL;
45121 }
45122
45123
45124 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45125 PyObject *resultobj = 0;
45126 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45127 int arg2 ;
45128 bool arg3 ;
45129 void *argp1 = 0 ;
45130 int res1 = 0 ;
45131 int val2 ;
45132 int ecode2 = 0 ;
45133 bool val3 ;
45134 int ecode3 = 0 ;
45135 PyObject * obj0 = 0 ;
45136 PyObject * obj1 = 0 ;
45137 PyObject * obj2 = 0 ;
45138 char * kwnames[] = {
45139 (char *) "self",(char *) "id",(char *) "check", NULL
45140 };
45141
45142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45144 if (!SWIG_IsOK(res1)) {
45145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45146 }
45147 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45148 ecode2 = SWIG_AsVal_int(obj1, &val2);
45149 if (!SWIG_IsOK(ecode2)) {
45150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45151 }
45152 arg2 = static_cast< int >(val2);
45153 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45154 if (!SWIG_IsOK(ecode3)) {
45155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45156 }
45157 arg3 = static_cast< bool >(val3);
45158 {
45159 PyThreadState* __tstate = wxPyBeginAllowThreads();
45160 (arg1)->Check(arg2,arg3);
45161 wxPyEndAllowThreads(__tstate);
45162 if (PyErr_Occurred()) SWIG_fail;
45163 }
45164 resultobj = SWIG_Py_Void();
45165 return resultobj;
45166 fail:
45167 return NULL;
45168 }
45169
45170
45171 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45172 PyObject *resultobj = 0;
45173 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45174 int arg2 ;
45175 bool result;
45176 void *argp1 = 0 ;
45177 int res1 = 0 ;
45178 int val2 ;
45179 int ecode2 = 0 ;
45180 PyObject * obj0 = 0 ;
45181 PyObject * obj1 = 0 ;
45182 char * kwnames[] = {
45183 (char *) "self",(char *) "id", NULL
45184 };
45185
45186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45188 if (!SWIG_IsOK(res1)) {
45189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45190 }
45191 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45192 ecode2 = SWIG_AsVal_int(obj1, &val2);
45193 if (!SWIG_IsOK(ecode2)) {
45194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45195 }
45196 arg2 = static_cast< int >(val2);
45197 {
45198 PyThreadState* __tstate = wxPyBeginAllowThreads();
45199 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45200 wxPyEndAllowThreads(__tstate);
45201 if (PyErr_Occurred()) SWIG_fail;
45202 }
45203 {
45204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45205 }
45206 return resultobj;
45207 fail:
45208 return NULL;
45209 }
45210
45211
45212 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45213 PyObject *resultobj = 0;
45214 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45215 int arg2 ;
45216 bool result;
45217 void *argp1 = 0 ;
45218 int res1 = 0 ;
45219 int val2 ;
45220 int ecode2 = 0 ;
45221 PyObject * obj0 = 0 ;
45222 PyObject * obj1 = 0 ;
45223 char * kwnames[] = {
45224 (char *) "self",(char *) "id", NULL
45225 };
45226
45227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45229 if (!SWIG_IsOK(res1)) {
45230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45231 }
45232 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45233 ecode2 = SWIG_AsVal_int(obj1, &val2);
45234 if (!SWIG_IsOK(ecode2)) {
45235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45236 }
45237 arg2 = static_cast< int >(val2);
45238 {
45239 PyThreadState* __tstate = wxPyBeginAllowThreads();
45240 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45241 wxPyEndAllowThreads(__tstate);
45242 if (PyErr_Occurred()) SWIG_fail;
45243 }
45244 {
45245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45246 }
45247 return resultobj;
45248 fail:
45249 return NULL;
45250 }
45251
45252
45253 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45254 PyObject *resultobj = 0;
45255 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45256 int arg2 ;
45257 wxString *arg3 = 0 ;
45258 void *argp1 = 0 ;
45259 int res1 = 0 ;
45260 int val2 ;
45261 int ecode2 = 0 ;
45262 bool temp3 = false ;
45263 PyObject * obj0 = 0 ;
45264 PyObject * obj1 = 0 ;
45265 PyObject * obj2 = 0 ;
45266 char * kwnames[] = {
45267 (char *) "self",(char *) "id",(char *) "label", NULL
45268 };
45269
45270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45272 if (!SWIG_IsOK(res1)) {
45273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45274 }
45275 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45276 ecode2 = SWIG_AsVal_int(obj1, &val2);
45277 if (!SWIG_IsOK(ecode2)) {
45278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45279 }
45280 arg2 = static_cast< int >(val2);
45281 {
45282 arg3 = wxString_in_helper(obj2);
45283 if (arg3 == NULL) SWIG_fail;
45284 temp3 = true;
45285 }
45286 {
45287 PyThreadState* __tstate = wxPyBeginAllowThreads();
45288 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45289 wxPyEndAllowThreads(__tstate);
45290 if (PyErr_Occurred()) SWIG_fail;
45291 }
45292 resultobj = SWIG_Py_Void();
45293 {
45294 if (temp3)
45295 delete arg3;
45296 }
45297 return resultobj;
45298 fail:
45299 {
45300 if (temp3)
45301 delete arg3;
45302 }
45303 return NULL;
45304 }
45305
45306
45307 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45308 PyObject *resultobj = 0;
45309 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45310 int arg2 ;
45311 wxString result;
45312 void *argp1 = 0 ;
45313 int res1 = 0 ;
45314 int val2 ;
45315 int ecode2 = 0 ;
45316 PyObject * obj0 = 0 ;
45317 PyObject * obj1 = 0 ;
45318 char * kwnames[] = {
45319 (char *) "self",(char *) "id", NULL
45320 };
45321
45322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45324 if (!SWIG_IsOK(res1)) {
45325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45326 }
45327 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45328 ecode2 = SWIG_AsVal_int(obj1, &val2);
45329 if (!SWIG_IsOK(ecode2)) {
45330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45331 }
45332 arg2 = static_cast< int >(val2);
45333 {
45334 PyThreadState* __tstate = wxPyBeginAllowThreads();
45335 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45336 wxPyEndAllowThreads(__tstate);
45337 if (PyErr_Occurred()) SWIG_fail;
45338 }
45339 {
45340 #if wxUSE_UNICODE
45341 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45342 #else
45343 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45344 #endif
45345 }
45346 return resultobj;
45347 fail:
45348 return NULL;
45349 }
45350
45351
45352 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45353 PyObject *resultobj = 0;
45354 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45355 int arg2 ;
45356 wxString *arg3 = 0 ;
45357 void *argp1 = 0 ;
45358 int res1 = 0 ;
45359 int val2 ;
45360 int ecode2 = 0 ;
45361 bool temp3 = false ;
45362 PyObject * obj0 = 0 ;
45363 PyObject * obj1 = 0 ;
45364 PyObject * obj2 = 0 ;
45365 char * kwnames[] = {
45366 (char *) "self",(char *) "id",(char *) "helpString", NULL
45367 };
45368
45369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45371 if (!SWIG_IsOK(res1)) {
45372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45373 }
45374 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45375 ecode2 = SWIG_AsVal_int(obj1, &val2);
45376 if (!SWIG_IsOK(ecode2)) {
45377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45378 }
45379 arg2 = static_cast< int >(val2);
45380 {
45381 arg3 = wxString_in_helper(obj2);
45382 if (arg3 == NULL) SWIG_fail;
45383 temp3 = true;
45384 }
45385 {
45386 PyThreadState* __tstate = wxPyBeginAllowThreads();
45387 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45388 wxPyEndAllowThreads(__tstate);
45389 if (PyErr_Occurred()) SWIG_fail;
45390 }
45391 resultobj = SWIG_Py_Void();
45392 {
45393 if (temp3)
45394 delete arg3;
45395 }
45396 return resultobj;
45397 fail:
45398 {
45399 if (temp3)
45400 delete arg3;
45401 }
45402 return NULL;
45403 }
45404
45405
45406 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45407 PyObject *resultobj = 0;
45408 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45409 int arg2 ;
45410 wxString result;
45411 void *argp1 = 0 ;
45412 int res1 = 0 ;
45413 int val2 ;
45414 int ecode2 = 0 ;
45415 PyObject * obj0 = 0 ;
45416 PyObject * obj1 = 0 ;
45417 char * kwnames[] = {
45418 (char *) "self",(char *) "id", NULL
45419 };
45420
45421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45423 if (!SWIG_IsOK(res1)) {
45424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45425 }
45426 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45427 ecode2 = SWIG_AsVal_int(obj1, &val2);
45428 if (!SWIG_IsOK(ecode2)) {
45429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45430 }
45431 arg2 = static_cast< int >(val2);
45432 {
45433 PyThreadState* __tstate = wxPyBeginAllowThreads();
45434 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45435 wxPyEndAllowThreads(__tstate);
45436 if (PyErr_Occurred()) SWIG_fail;
45437 }
45438 {
45439 #if wxUSE_UNICODE
45440 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45441 #else
45442 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45443 #endif
45444 }
45445 return resultobj;
45446 fail:
45447 return NULL;
45448 }
45449
45450
45451 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45452 PyObject *resultobj = 0;
45453 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45454 wxFrame *result = 0 ;
45455 void *argp1 = 0 ;
45456 int res1 = 0 ;
45457 PyObject *swig_obj[1] ;
45458
45459 if (!args) SWIG_fail;
45460 swig_obj[0] = args;
45461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45462 if (!SWIG_IsOK(res1)) {
45463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45464 }
45465 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45466 {
45467 PyThreadState* __tstate = wxPyBeginAllowThreads();
45468 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45469 wxPyEndAllowThreads(__tstate);
45470 if (PyErr_Occurred()) SWIG_fail;
45471 }
45472 {
45473 resultobj = wxPyMake_wxObject(result, (bool)0);
45474 }
45475 return resultobj;
45476 fail:
45477 return NULL;
45478 }
45479
45480
45481 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45482 PyObject *resultobj = 0;
45483 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45484 bool result;
45485 void *argp1 = 0 ;
45486 int res1 = 0 ;
45487 PyObject *swig_obj[1] ;
45488
45489 if (!args) SWIG_fail;
45490 swig_obj[0] = args;
45491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45492 if (!SWIG_IsOK(res1)) {
45493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45494 }
45495 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45496 {
45497 PyThreadState* __tstate = wxPyBeginAllowThreads();
45498 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45499 wxPyEndAllowThreads(__tstate);
45500 if (PyErr_Occurred()) SWIG_fail;
45501 }
45502 {
45503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45504 }
45505 return resultobj;
45506 fail:
45507 return NULL;
45508 }
45509
45510
45511 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45512 PyObject *resultobj = 0;
45513 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45514 wxFrame *arg2 = (wxFrame *) 0 ;
45515 void *argp1 = 0 ;
45516 int res1 = 0 ;
45517 void *argp2 = 0 ;
45518 int res2 = 0 ;
45519 PyObject * obj0 = 0 ;
45520 PyObject * obj1 = 0 ;
45521 char * kwnames[] = {
45522 (char *) "self",(char *) "frame", NULL
45523 };
45524
45525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45527 if (!SWIG_IsOK(res1)) {
45528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45529 }
45530 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45531 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45532 if (!SWIG_IsOK(res2)) {
45533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45534 }
45535 arg2 = reinterpret_cast< wxFrame * >(argp2);
45536 {
45537 PyThreadState* __tstate = wxPyBeginAllowThreads();
45538 (arg1)->Attach(arg2);
45539 wxPyEndAllowThreads(__tstate);
45540 if (PyErr_Occurred()) SWIG_fail;
45541 }
45542 resultobj = SWIG_Py_Void();
45543 return resultobj;
45544 fail:
45545 return NULL;
45546 }
45547
45548
45549 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45550 PyObject *resultobj = 0;
45551 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45552 void *argp1 = 0 ;
45553 int res1 = 0 ;
45554 PyObject *swig_obj[1] ;
45555
45556 if (!args) SWIG_fail;
45557 swig_obj[0] = args;
45558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45559 if (!SWIG_IsOK(res1)) {
45560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45561 }
45562 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45563 {
45564 PyThreadState* __tstate = wxPyBeginAllowThreads();
45565 (arg1)->Detach();
45566 wxPyEndAllowThreads(__tstate);
45567 if (PyErr_Occurred()) SWIG_fail;
45568 }
45569 resultobj = SWIG_Py_Void();
45570 return resultobj;
45571 fail:
45572 return NULL;
45573 }
45574
45575
45576 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45577 PyObject *resultobj = 0;
45578 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45579 void *argp1 = 0 ;
45580 int res1 = 0 ;
45581 PyObject *swig_obj[1] ;
45582
45583 if (!args) SWIG_fail;
45584 swig_obj[0] = args;
45585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45586 if (!SWIG_IsOK(res1)) {
45587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45588 }
45589 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45590 {
45591 PyThreadState* __tstate = wxPyBeginAllowThreads();
45592 (arg1)->UpdateMenus();
45593 wxPyEndAllowThreads(__tstate);
45594 if (PyErr_Occurred()) SWIG_fail;
45595 }
45596 resultobj = SWIG_Py_Void();
45597 return resultobj;
45598 fail:
45599 return NULL;
45600 }
45601
45602
45603 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45604 PyObject *resultobj = 0;
45605 bool arg1 ;
45606 bool val1 ;
45607 int ecode1 = 0 ;
45608 PyObject * obj0 = 0 ;
45609 char * kwnames[] = {
45610 (char *) "enable", NULL
45611 };
45612
45613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45614 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45615 if (!SWIG_IsOK(ecode1)) {
45616 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45617 }
45618 arg1 = static_cast< bool >(val1);
45619 {
45620 PyThreadState* __tstate = wxPyBeginAllowThreads();
45621 wxMenuBar::SetAutoWindowMenu(arg1);
45622 wxPyEndAllowThreads(__tstate);
45623 if (PyErr_Occurred()) SWIG_fail;
45624 }
45625 resultobj = SWIG_Py_Void();
45626 return resultobj;
45627 fail:
45628 return NULL;
45629 }
45630
45631
45632 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45633 PyObject *resultobj = 0;
45634 bool result;
45635
45636 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45637 {
45638 PyThreadState* __tstate = wxPyBeginAllowThreads();
45639 result = (bool)wxMenuBar::GetAutoWindowMenu();
45640 wxPyEndAllowThreads(__tstate);
45641 if (PyErr_Occurred()) SWIG_fail;
45642 }
45643 {
45644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45645 }
45646 return resultobj;
45647 fail:
45648 return NULL;
45649 }
45650
45651
45652 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45653 PyObject *obj;
45654 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45655 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45656 return SWIG_Py_Void();
45657 }
45658
45659 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45660 return SWIG_Python_InitShadowInstance(args);
45661 }
45662
45663 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45664 PyObject *resultobj = 0;
45665 wxMenu *arg1 = (wxMenu *) NULL ;
45666 int arg2 = (int) wxID_ANY ;
45667 wxString const &arg3_defvalue = wxPyEmptyString ;
45668 wxString *arg3 = (wxString *) &arg3_defvalue ;
45669 wxString const &arg4_defvalue = wxPyEmptyString ;
45670 wxString *arg4 = (wxString *) &arg4_defvalue ;
45671 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45672 wxMenu *arg6 = (wxMenu *) NULL ;
45673 wxMenuItem *result = 0 ;
45674 void *argp1 = 0 ;
45675 int res1 = 0 ;
45676 int val2 ;
45677 int ecode2 = 0 ;
45678 bool temp3 = false ;
45679 bool temp4 = false ;
45680 int val5 ;
45681 int ecode5 = 0 ;
45682 void *argp6 = 0 ;
45683 int res6 = 0 ;
45684 PyObject * obj0 = 0 ;
45685 PyObject * obj1 = 0 ;
45686 PyObject * obj2 = 0 ;
45687 PyObject * obj3 = 0 ;
45688 PyObject * obj4 = 0 ;
45689 PyObject * obj5 = 0 ;
45690 char * kwnames[] = {
45691 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45692 };
45693
45694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45695 if (obj0) {
45696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45697 if (!SWIG_IsOK(res1)) {
45698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
45699 }
45700 arg1 = reinterpret_cast< wxMenu * >(argp1);
45701 }
45702 if (obj1) {
45703 ecode2 = SWIG_AsVal_int(obj1, &val2);
45704 if (!SWIG_IsOK(ecode2)) {
45705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45706 }
45707 arg2 = static_cast< int >(val2);
45708 }
45709 if (obj2) {
45710 {
45711 arg3 = wxString_in_helper(obj2);
45712 if (arg3 == NULL) SWIG_fail;
45713 temp3 = true;
45714 }
45715 }
45716 if (obj3) {
45717 {
45718 arg4 = wxString_in_helper(obj3);
45719 if (arg4 == NULL) SWIG_fail;
45720 temp4 = true;
45721 }
45722 }
45723 if (obj4) {
45724 ecode5 = SWIG_AsVal_int(obj4, &val5);
45725 if (!SWIG_IsOK(ecode5)) {
45726 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
45727 }
45728 arg5 = static_cast< wxItemKind >(val5);
45729 }
45730 if (obj5) {
45731 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
45732 if (!SWIG_IsOK(res6)) {
45733 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
45734 }
45735 arg6 = reinterpret_cast< wxMenu * >(argp6);
45736 }
45737 {
45738 PyThreadState* __tstate = wxPyBeginAllowThreads();
45739 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
45740 wxPyEndAllowThreads(__tstate);
45741 if (PyErr_Occurred()) SWIG_fail;
45742 }
45743 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
45744 {
45745 if (temp3)
45746 delete arg3;
45747 }
45748 {
45749 if (temp4)
45750 delete arg4;
45751 }
45752 return resultobj;
45753 fail:
45754 {
45755 if (temp3)
45756 delete arg3;
45757 }
45758 {
45759 if (temp4)
45760 delete arg4;
45761 }
45762 return NULL;
45763 }
45764
45765
45766 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45767 PyObject *resultobj = 0;
45768 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45769 void *argp1 = 0 ;
45770 int res1 = 0 ;
45771 PyObject *swig_obj[1] ;
45772
45773 if (!args) SWIG_fail;
45774 swig_obj[0] = args;
45775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
45776 if (!SWIG_IsOK(res1)) {
45777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45778 }
45779 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45780 {
45781 PyThreadState* __tstate = wxPyBeginAllowThreads();
45782 delete arg1;
45783
45784 wxPyEndAllowThreads(__tstate);
45785 if (PyErr_Occurred()) SWIG_fail;
45786 }
45787 resultobj = SWIG_Py_Void();
45788 return resultobj;
45789 fail:
45790 return NULL;
45791 }
45792
45793
45794 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45795 PyObject *resultobj = 0;
45796 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45797 wxMenu *result = 0 ;
45798 void *argp1 = 0 ;
45799 int res1 = 0 ;
45800 PyObject *swig_obj[1] ;
45801
45802 if (!args) SWIG_fail;
45803 swig_obj[0] = args;
45804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45805 if (!SWIG_IsOK(res1)) {
45806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45807 }
45808 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45809 {
45810 PyThreadState* __tstate = wxPyBeginAllowThreads();
45811 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
45812 wxPyEndAllowThreads(__tstate);
45813 if (PyErr_Occurred()) SWIG_fail;
45814 }
45815 {
45816 resultobj = wxPyMake_wxObject(result, 0);
45817 }
45818 return resultobj;
45819 fail:
45820 return NULL;
45821 }
45822
45823
45824 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45825 PyObject *resultobj = 0;
45826 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45827 wxMenu *arg2 = (wxMenu *) 0 ;
45828 void *argp1 = 0 ;
45829 int res1 = 0 ;
45830 void *argp2 = 0 ;
45831 int res2 = 0 ;
45832 PyObject * obj0 = 0 ;
45833 PyObject * obj1 = 0 ;
45834 char * kwnames[] = {
45835 (char *) "self",(char *) "menu", NULL
45836 };
45837
45838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45840 if (!SWIG_IsOK(res1)) {
45841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45842 }
45843 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45844 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45845 if (!SWIG_IsOK(res2)) {
45846 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
45847 }
45848 arg2 = reinterpret_cast< wxMenu * >(argp2);
45849 {
45850 PyThreadState* __tstate = wxPyBeginAllowThreads();
45851 (arg1)->SetMenu(arg2);
45852 wxPyEndAllowThreads(__tstate);
45853 if (PyErr_Occurred()) SWIG_fail;
45854 }
45855 resultobj = SWIG_Py_Void();
45856 return resultobj;
45857 fail:
45858 return NULL;
45859 }
45860
45861
45862 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45863 PyObject *resultobj = 0;
45864 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45865 int arg2 ;
45866 void *argp1 = 0 ;
45867 int res1 = 0 ;
45868 int val2 ;
45869 int ecode2 = 0 ;
45870 PyObject * obj0 = 0 ;
45871 PyObject * obj1 = 0 ;
45872 char * kwnames[] = {
45873 (char *) "self",(char *) "id", NULL
45874 };
45875
45876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
45877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45878 if (!SWIG_IsOK(res1)) {
45879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45880 }
45881 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45882 ecode2 = SWIG_AsVal_int(obj1, &val2);
45883 if (!SWIG_IsOK(ecode2)) {
45884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
45885 }
45886 arg2 = static_cast< int >(val2);
45887 {
45888 PyThreadState* __tstate = wxPyBeginAllowThreads();
45889 (arg1)->SetId(arg2);
45890 wxPyEndAllowThreads(__tstate);
45891 if (PyErr_Occurred()) SWIG_fail;
45892 }
45893 resultobj = SWIG_Py_Void();
45894 return resultobj;
45895 fail:
45896 return NULL;
45897 }
45898
45899
45900 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45901 PyObject *resultobj = 0;
45902 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45903 int result;
45904 void *argp1 = 0 ;
45905 int res1 = 0 ;
45906 PyObject *swig_obj[1] ;
45907
45908 if (!args) SWIG_fail;
45909 swig_obj[0] = args;
45910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45911 if (!SWIG_IsOK(res1)) {
45912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45913 }
45914 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45915 {
45916 PyThreadState* __tstate = wxPyBeginAllowThreads();
45917 result = (int)((wxMenuItem const *)arg1)->GetId();
45918 wxPyEndAllowThreads(__tstate);
45919 if (PyErr_Occurred()) SWIG_fail;
45920 }
45921 resultobj = SWIG_From_int(static_cast< int >(result));
45922 return resultobj;
45923 fail:
45924 return NULL;
45925 }
45926
45927
45928 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45929 PyObject *resultobj = 0;
45930 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45931 bool result;
45932 void *argp1 = 0 ;
45933 int res1 = 0 ;
45934 PyObject *swig_obj[1] ;
45935
45936 if (!args) SWIG_fail;
45937 swig_obj[0] = args;
45938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45939 if (!SWIG_IsOK(res1)) {
45940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45941 }
45942 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45943 {
45944 PyThreadState* __tstate = wxPyBeginAllowThreads();
45945 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
45946 wxPyEndAllowThreads(__tstate);
45947 if (PyErr_Occurred()) SWIG_fail;
45948 }
45949 {
45950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45951 }
45952 return resultobj;
45953 fail:
45954 return NULL;
45955 }
45956
45957
45958 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45959 PyObject *resultobj = 0;
45960 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45961 wxString *arg2 = 0 ;
45962 void *argp1 = 0 ;
45963 int res1 = 0 ;
45964 bool temp2 = false ;
45965 PyObject * obj0 = 0 ;
45966 PyObject * obj1 = 0 ;
45967 char * kwnames[] = {
45968 (char *) "self",(char *) "str", NULL
45969 };
45970
45971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
45972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45973 if (!SWIG_IsOK(res1)) {
45974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45975 }
45976 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45977 {
45978 arg2 = wxString_in_helper(obj1);
45979 if (arg2 == NULL) SWIG_fail;
45980 temp2 = true;
45981 }
45982 {
45983 PyThreadState* __tstate = wxPyBeginAllowThreads();
45984 (arg1)->SetText((wxString const &)*arg2);
45985 wxPyEndAllowThreads(__tstate);
45986 if (PyErr_Occurred()) SWIG_fail;
45987 }
45988 resultobj = SWIG_Py_Void();
45989 {
45990 if (temp2)
45991 delete arg2;
45992 }
45993 return resultobj;
45994 fail:
45995 {
45996 if (temp2)
45997 delete arg2;
45998 }
45999 return NULL;
46000 }
46001
46002
46003 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46004 PyObject *resultobj = 0;
46005 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46006 wxString result;
46007 void *argp1 = 0 ;
46008 int res1 = 0 ;
46009 PyObject *swig_obj[1] ;
46010
46011 if (!args) SWIG_fail;
46012 swig_obj[0] = args;
46013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46014 if (!SWIG_IsOK(res1)) {
46015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46016 }
46017 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46018 {
46019 PyThreadState* __tstate = wxPyBeginAllowThreads();
46020 result = ((wxMenuItem const *)arg1)->GetLabel();
46021 wxPyEndAllowThreads(__tstate);
46022 if (PyErr_Occurred()) SWIG_fail;
46023 }
46024 {
46025 #if wxUSE_UNICODE
46026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46027 #else
46028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46029 #endif
46030 }
46031 return resultobj;
46032 fail:
46033 return NULL;
46034 }
46035
46036
46037 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46038 PyObject *resultobj = 0;
46039 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46040 wxString *result = 0 ;
46041 void *argp1 = 0 ;
46042 int res1 = 0 ;
46043 PyObject *swig_obj[1] ;
46044
46045 if (!args) SWIG_fail;
46046 swig_obj[0] = args;
46047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46048 if (!SWIG_IsOK(res1)) {
46049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46050 }
46051 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46052 {
46053 PyThreadState* __tstate = wxPyBeginAllowThreads();
46054 {
46055 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46056 result = (wxString *) &_result_ref;
46057 }
46058 wxPyEndAllowThreads(__tstate);
46059 if (PyErr_Occurred()) SWIG_fail;
46060 }
46061 {
46062 #if wxUSE_UNICODE
46063 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46064 #else
46065 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46066 #endif
46067 }
46068 return resultobj;
46069 fail:
46070 return NULL;
46071 }
46072
46073
46074 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46075 PyObject *resultobj = 0;
46076 wxString *arg1 = 0 ;
46077 wxString result;
46078 bool temp1 = false ;
46079 PyObject * obj0 = 0 ;
46080 char * kwnames[] = {
46081 (char *) "text", NULL
46082 };
46083
46084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46085 {
46086 arg1 = wxString_in_helper(obj0);
46087 if (arg1 == NULL) SWIG_fail;
46088 temp1 = true;
46089 }
46090 {
46091 PyThreadState* __tstate = wxPyBeginAllowThreads();
46092 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46093 wxPyEndAllowThreads(__tstate);
46094 if (PyErr_Occurred()) SWIG_fail;
46095 }
46096 {
46097 #if wxUSE_UNICODE
46098 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46099 #else
46100 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46101 #endif
46102 }
46103 {
46104 if (temp1)
46105 delete arg1;
46106 }
46107 return resultobj;
46108 fail:
46109 {
46110 if (temp1)
46111 delete arg1;
46112 }
46113 return NULL;
46114 }
46115
46116
46117 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46118 PyObject *resultobj = 0;
46119 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46120 wxItemKind result;
46121 void *argp1 = 0 ;
46122 int res1 = 0 ;
46123 PyObject *swig_obj[1] ;
46124
46125 if (!args) SWIG_fail;
46126 swig_obj[0] = args;
46127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46128 if (!SWIG_IsOK(res1)) {
46129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46130 }
46131 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46132 {
46133 PyThreadState* __tstate = wxPyBeginAllowThreads();
46134 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46135 wxPyEndAllowThreads(__tstate);
46136 if (PyErr_Occurred()) SWIG_fail;
46137 }
46138 resultobj = SWIG_From_int(static_cast< int >(result));
46139 return resultobj;
46140 fail:
46141 return NULL;
46142 }
46143
46144
46145 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46146 PyObject *resultobj = 0;
46147 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46148 wxItemKind arg2 ;
46149 void *argp1 = 0 ;
46150 int res1 = 0 ;
46151 int val2 ;
46152 int ecode2 = 0 ;
46153 PyObject * obj0 = 0 ;
46154 PyObject * obj1 = 0 ;
46155 char * kwnames[] = {
46156 (char *) "self",(char *) "kind", NULL
46157 };
46158
46159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46161 if (!SWIG_IsOK(res1)) {
46162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46163 }
46164 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46165 ecode2 = SWIG_AsVal_int(obj1, &val2);
46166 if (!SWIG_IsOK(ecode2)) {
46167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46168 }
46169 arg2 = static_cast< wxItemKind >(val2);
46170 {
46171 PyThreadState* __tstate = wxPyBeginAllowThreads();
46172 (arg1)->SetKind(arg2);
46173 wxPyEndAllowThreads(__tstate);
46174 if (PyErr_Occurred()) SWIG_fail;
46175 }
46176 resultobj = SWIG_Py_Void();
46177 return resultobj;
46178 fail:
46179 return NULL;
46180 }
46181
46182
46183 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46184 PyObject *resultobj = 0;
46185 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46186 bool arg2 ;
46187 void *argp1 = 0 ;
46188 int res1 = 0 ;
46189 bool val2 ;
46190 int ecode2 = 0 ;
46191 PyObject * obj0 = 0 ;
46192 PyObject * obj1 = 0 ;
46193 char * kwnames[] = {
46194 (char *) "self",(char *) "checkable", NULL
46195 };
46196
46197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46199 if (!SWIG_IsOK(res1)) {
46200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46201 }
46202 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46203 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46204 if (!SWIG_IsOK(ecode2)) {
46205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46206 }
46207 arg2 = static_cast< bool >(val2);
46208 {
46209 PyThreadState* __tstate = wxPyBeginAllowThreads();
46210 (arg1)->SetCheckable(arg2);
46211 wxPyEndAllowThreads(__tstate);
46212 if (PyErr_Occurred()) SWIG_fail;
46213 }
46214 resultobj = SWIG_Py_Void();
46215 return resultobj;
46216 fail:
46217 return NULL;
46218 }
46219
46220
46221 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46222 PyObject *resultobj = 0;
46223 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46224 bool result;
46225 void *argp1 = 0 ;
46226 int res1 = 0 ;
46227 PyObject *swig_obj[1] ;
46228
46229 if (!args) SWIG_fail;
46230 swig_obj[0] = args;
46231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46232 if (!SWIG_IsOK(res1)) {
46233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46234 }
46235 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46236 {
46237 PyThreadState* __tstate = wxPyBeginAllowThreads();
46238 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46239 wxPyEndAllowThreads(__tstate);
46240 if (PyErr_Occurred()) SWIG_fail;
46241 }
46242 {
46243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46244 }
46245 return resultobj;
46246 fail:
46247 return NULL;
46248 }
46249
46250
46251 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46252 PyObject *resultobj = 0;
46253 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46254 bool result;
46255 void *argp1 = 0 ;
46256 int res1 = 0 ;
46257 PyObject *swig_obj[1] ;
46258
46259 if (!args) SWIG_fail;
46260 swig_obj[0] = args;
46261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46262 if (!SWIG_IsOK(res1)) {
46263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46264 }
46265 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46266 {
46267 PyThreadState* __tstate = wxPyBeginAllowThreads();
46268 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46269 wxPyEndAllowThreads(__tstate);
46270 if (PyErr_Occurred()) SWIG_fail;
46271 }
46272 {
46273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46274 }
46275 return resultobj;
46276 fail:
46277 return NULL;
46278 }
46279
46280
46281 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46282 PyObject *resultobj = 0;
46283 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46284 wxMenu *arg2 = (wxMenu *) 0 ;
46285 void *argp1 = 0 ;
46286 int res1 = 0 ;
46287 void *argp2 = 0 ;
46288 int res2 = 0 ;
46289 PyObject * obj0 = 0 ;
46290 PyObject * obj1 = 0 ;
46291 char * kwnames[] = {
46292 (char *) "self",(char *) "menu", NULL
46293 };
46294
46295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46297 if (!SWIG_IsOK(res1)) {
46298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46299 }
46300 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46301 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46302 if (!SWIG_IsOK(res2)) {
46303 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46304 }
46305 arg2 = reinterpret_cast< wxMenu * >(argp2);
46306 {
46307 PyThreadState* __tstate = wxPyBeginAllowThreads();
46308 (arg1)->SetSubMenu(arg2);
46309 wxPyEndAllowThreads(__tstate);
46310 if (PyErr_Occurred()) SWIG_fail;
46311 }
46312 resultobj = SWIG_Py_Void();
46313 return resultobj;
46314 fail:
46315 return NULL;
46316 }
46317
46318
46319 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46320 PyObject *resultobj = 0;
46321 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46322 wxMenu *result = 0 ;
46323 void *argp1 = 0 ;
46324 int res1 = 0 ;
46325 PyObject *swig_obj[1] ;
46326
46327 if (!args) SWIG_fail;
46328 swig_obj[0] = args;
46329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46330 if (!SWIG_IsOK(res1)) {
46331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46332 }
46333 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46334 {
46335 PyThreadState* __tstate = wxPyBeginAllowThreads();
46336 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46337 wxPyEndAllowThreads(__tstate);
46338 if (PyErr_Occurred()) SWIG_fail;
46339 }
46340 {
46341 resultobj = wxPyMake_wxObject(result, 0);
46342 }
46343 return resultobj;
46344 fail:
46345 return NULL;
46346 }
46347
46348
46349 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46350 PyObject *resultobj = 0;
46351 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46352 bool arg2 = (bool) true ;
46353 void *argp1 = 0 ;
46354 int res1 = 0 ;
46355 bool val2 ;
46356 int ecode2 = 0 ;
46357 PyObject * obj0 = 0 ;
46358 PyObject * obj1 = 0 ;
46359 char * kwnames[] = {
46360 (char *) "self",(char *) "enable", NULL
46361 };
46362
46363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46365 if (!SWIG_IsOK(res1)) {
46366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46367 }
46368 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46369 if (obj1) {
46370 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46371 if (!SWIG_IsOK(ecode2)) {
46372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46373 }
46374 arg2 = static_cast< bool >(val2);
46375 }
46376 {
46377 PyThreadState* __tstate = wxPyBeginAllowThreads();
46378 (arg1)->Enable(arg2);
46379 wxPyEndAllowThreads(__tstate);
46380 if (PyErr_Occurred()) SWIG_fail;
46381 }
46382 resultobj = SWIG_Py_Void();
46383 return resultobj;
46384 fail:
46385 return NULL;
46386 }
46387
46388
46389 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46390 PyObject *resultobj = 0;
46391 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46392 bool result;
46393 void *argp1 = 0 ;
46394 int res1 = 0 ;
46395 PyObject *swig_obj[1] ;
46396
46397 if (!args) SWIG_fail;
46398 swig_obj[0] = args;
46399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46400 if (!SWIG_IsOK(res1)) {
46401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46402 }
46403 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46404 {
46405 PyThreadState* __tstate = wxPyBeginAllowThreads();
46406 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46407 wxPyEndAllowThreads(__tstate);
46408 if (PyErr_Occurred()) SWIG_fail;
46409 }
46410 {
46411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46412 }
46413 return resultobj;
46414 fail:
46415 return NULL;
46416 }
46417
46418
46419 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46420 PyObject *resultobj = 0;
46421 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46422 bool arg2 = (bool) true ;
46423 void *argp1 = 0 ;
46424 int res1 = 0 ;
46425 bool val2 ;
46426 int ecode2 = 0 ;
46427 PyObject * obj0 = 0 ;
46428 PyObject * obj1 = 0 ;
46429 char * kwnames[] = {
46430 (char *) "self",(char *) "check", NULL
46431 };
46432
46433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46435 if (!SWIG_IsOK(res1)) {
46436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46437 }
46438 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46439 if (obj1) {
46440 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46441 if (!SWIG_IsOK(ecode2)) {
46442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46443 }
46444 arg2 = static_cast< bool >(val2);
46445 }
46446 {
46447 PyThreadState* __tstate = wxPyBeginAllowThreads();
46448 (arg1)->Check(arg2);
46449 wxPyEndAllowThreads(__tstate);
46450 if (PyErr_Occurred()) SWIG_fail;
46451 }
46452 resultobj = SWIG_Py_Void();
46453 return resultobj;
46454 fail:
46455 return NULL;
46456 }
46457
46458
46459 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46460 PyObject *resultobj = 0;
46461 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46462 bool result;
46463 void *argp1 = 0 ;
46464 int res1 = 0 ;
46465 PyObject *swig_obj[1] ;
46466
46467 if (!args) SWIG_fail;
46468 swig_obj[0] = args;
46469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46470 if (!SWIG_IsOK(res1)) {
46471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46472 }
46473 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46474 {
46475 PyThreadState* __tstate = wxPyBeginAllowThreads();
46476 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46477 wxPyEndAllowThreads(__tstate);
46478 if (PyErr_Occurred()) SWIG_fail;
46479 }
46480 {
46481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46482 }
46483 return resultobj;
46484 fail:
46485 return NULL;
46486 }
46487
46488
46489 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46490 PyObject *resultobj = 0;
46491 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46492 void *argp1 = 0 ;
46493 int res1 = 0 ;
46494 PyObject *swig_obj[1] ;
46495
46496 if (!args) SWIG_fail;
46497 swig_obj[0] = args;
46498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46499 if (!SWIG_IsOK(res1)) {
46500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46501 }
46502 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46503 {
46504 PyThreadState* __tstate = wxPyBeginAllowThreads();
46505 (arg1)->Toggle();
46506 wxPyEndAllowThreads(__tstate);
46507 if (PyErr_Occurred()) SWIG_fail;
46508 }
46509 resultobj = SWIG_Py_Void();
46510 return resultobj;
46511 fail:
46512 return NULL;
46513 }
46514
46515
46516 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46517 PyObject *resultobj = 0;
46518 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46519 wxString *arg2 = 0 ;
46520 void *argp1 = 0 ;
46521 int res1 = 0 ;
46522 bool temp2 = false ;
46523 PyObject * obj0 = 0 ;
46524 PyObject * obj1 = 0 ;
46525 char * kwnames[] = {
46526 (char *) "self",(char *) "str", NULL
46527 };
46528
46529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46531 if (!SWIG_IsOK(res1)) {
46532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46533 }
46534 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46535 {
46536 arg2 = wxString_in_helper(obj1);
46537 if (arg2 == NULL) SWIG_fail;
46538 temp2 = true;
46539 }
46540 {
46541 PyThreadState* __tstate = wxPyBeginAllowThreads();
46542 (arg1)->SetHelp((wxString const &)*arg2);
46543 wxPyEndAllowThreads(__tstate);
46544 if (PyErr_Occurred()) SWIG_fail;
46545 }
46546 resultobj = SWIG_Py_Void();
46547 {
46548 if (temp2)
46549 delete arg2;
46550 }
46551 return resultobj;
46552 fail:
46553 {
46554 if (temp2)
46555 delete arg2;
46556 }
46557 return NULL;
46558 }
46559
46560
46561 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46562 PyObject *resultobj = 0;
46563 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46564 wxString *result = 0 ;
46565 void *argp1 = 0 ;
46566 int res1 = 0 ;
46567 PyObject *swig_obj[1] ;
46568
46569 if (!args) SWIG_fail;
46570 swig_obj[0] = args;
46571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46572 if (!SWIG_IsOK(res1)) {
46573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46574 }
46575 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46576 {
46577 PyThreadState* __tstate = wxPyBeginAllowThreads();
46578 {
46579 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46580 result = (wxString *) &_result_ref;
46581 }
46582 wxPyEndAllowThreads(__tstate);
46583 if (PyErr_Occurred()) SWIG_fail;
46584 }
46585 {
46586 #if wxUSE_UNICODE
46587 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46588 #else
46589 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46590 #endif
46591 }
46592 return resultobj;
46593 fail:
46594 return NULL;
46595 }
46596
46597
46598 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46599 PyObject *resultobj = 0;
46600 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46601 wxAcceleratorEntry *result = 0 ;
46602 void *argp1 = 0 ;
46603 int res1 = 0 ;
46604 PyObject *swig_obj[1] ;
46605
46606 if (!args) SWIG_fail;
46607 swig_obj[0] = args;
46608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46609 if (!SWIG_IsOK(res1)) {
46610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46611 }
46612 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46613 {
46614 PyThreadState* __tstate = wxPyBeginAllowThreads();
46615 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46616 wxPyEndAllowThreads(__tstate);
46617 if (PyErr_Occurred()) SWIG_fail;
46618 }
46619 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46620 return resultobj;
46621 fail:
46622 return NULL;
46623 }
46624
46625
46626 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46627 PyObject *resultobj = 0;
46628 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46629 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46630 void *argp1 = 0 ;
46631 int res1 = 0 ;
46632 void *argp2 = 0 ;
46633 int res2 = 0 ;
46634 PyObject * obj0 = 0 ;
46635 PyObject * obj1 = 0 ;
46636 char * kwnames[] = {
46637 (char *) "self",(char *) "accel", NULL
46638 };
46639
46640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46642 if (!SWIG_IsOK(res1)) {
46643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46644 }
46645 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46646 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46647 if (!SWIG_IsOK(res2)) {
46648 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46649 }
46650 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46651 {
46652 PyThreadState* __tstate = wxPyBeginAllowThreads();
46653 (arg1)->SetAccel(arg2);
46654 wxPyEndAllowThreads(__tstate);
46655 if (PyErr_Occurred()) SWIG_fail;
46656 }
46657 resultobj = SWIG_Py_Void();
46658 return resultobj;
46659 fail:
46660 return NULL;
46661 }
46662
46663
46664 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46665 PyObject *resultobj = 0;
46666 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46667 wxBitmap *arg2 = 0 ;
46668 void *argp1 = 0 ;
46669 int res1 = 0 ;
46670 void *argp2 = 0 ;
46671 int res2 = 0 ;
46672 PyObject * obj0 = 0 ;
46673 PyObject * obj1 = 0 ;
46674 char * kwnames[] = {
46675 (char *) "self",(char *) "bitmap", NULL
46676 };
46677
46678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46680 if (!SWIG_IsOK(res1)) {
46681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46682 }
46683 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46684 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46685 if (!SWIG_IsOK(res2)) {
46686 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46687 }
46688 if (!argp2) {
46689 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46690 }
46691 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46692 {
46693 PyThreadState* __tstate = wxPyBeginAllowThreads();
46694 (arg1)->SetBitmap((wxBitmap const &)*arg2);
46695 wxPyEndAllowThreads(__tstate);
46696 if (PyErr_Occurred()) SWIG_fail;
46697 }
46698 resultobj = SWIG_Py_Void();
46699 return resultobj;
46700 fail:
46701 return NULL;
46702 }
46703
46704
46705 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46706 PyObject *resultobj = 0;
46707 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46708 wxBitmap *result = 0 ;
46709 void *argp1 = 0 ;
46710 int res1 = 0 ;
46711 PyObject *swig_obj[1] ;
46712
46713 if (!args) SWIG_fail;
46714 swig_obj[0] = args;
46715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46716 if (!SWIG_IsOK(res1)) {
46717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46718 }
46719 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46720 {
46721 PyThreadState* __tstate = wxPyBeginAllowThreads();
46722 {
46723 wxBitmap const &_result_ref = (arg1)->GetBitmap();
46724 result = (wxBitmap *) &_result_ref;
46725 }
46726 wxPyEndAllowThreads(__tstate);
46727 if (PyErr_Occurred()) SWIG_fail;
46728 }
46729 {
46730 wxBitmap* resultptr = new wxBitmap(*result);
46731 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46732 }
46733 return resultobj;
46734 fail:
46735 return NULL;
46736 }
46737
46738
46739 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46740 PyObject *resultobj = 0;
46741 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46742 wxFont *arg2 = 0 ;
46743 void *argp1 = 0 ;
46744 int res1 = 0 ;
46745 void *argp2 = 0 ;
46746 int res2 = 0 ;
46747 PyObject * obj0 = 0 ;
46748 PyObject * obj1 = 0 ;
46749 char * kwnames[] = {
46750 (char *) "self",(char *) "font", NULL
46751 };
46752
46753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
46754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46755 if (!SWIG_IsOK(res1)) {
46756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46757 }
46758 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46759 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
46760 if (!SWIG_IsOK(res2)) {
46761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46762 }
46763 if (!argp2) {
46764 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46765 }
46766 arg2 = reinterpret_cast< wxFont * >(argp2);
46767 {
46768 PyThreadState* __tstate = wxPyBeginAllowThreads();
46769 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
46770 wxPyEndAllowThreads(__tstate);
46771 if (PyErr_Occurred()) SWIG_fail;
46772 }
46773 resultobj = SWIG_Py_Void();
46774 return resultobj;
46775 fail:
46776 return NULL;
46777 }
46778
46779
46780 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46781 PyObject *resultobj = 0;
46782 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46783 wxFont result;
46784 void *argp1 = 0 ;
46785 int res1 = 0 ;
46786 PyObject *swig_obj[1] ;
46787
46788 if (!args) SWIG_fail;
46789 swig_obj[0] = args;
46790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46791 if (!SWIG_IsOK(res1)) {
46792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46793 }
46794 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46795 {
46796 PyThreadState* __tstate = wxPyBeginAllowThreads();
46797 result = wxMenuItem_GetFont(arg1);
46798 wxPyEndAllowThreads(__tstate);
46799 if (PyErr_Occurred()) SWIG_fail;
46800 }
46801 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
46802 return resultobj;
46803 fail:
46804 return NULL;
46805 }
46806
46807
46808 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46809 PyObject *resultobj = 0;
46810 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46811 wxColour *arg2 = 0 ;
46812 void *argp1 = 0 ;
46813 int res1 = 0 ;
46814 wxColour temp2 ;
46815 PyObject * obj0 = 0 ;
46816 PyObject * obj1 = 0 ;
46817 char * kwnames[] = {
46818 (char *) "self",(char *) "colText", NULL
46819 };
46820
46821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
46822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46823 if (!SWIG_IsOK(res1)) {
46824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46825 }
46826 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46827 {
46828 arg2 = &temp2;
46829 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46830 }
46831 {
46832 PyThreadState* __tstate = wxPyBeginAllowThreads();
46833 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
46834 wxPyEndAllowThreads(__tstate);
46835 if (PyErr_Occurred()) SWIG_fail;
46836 }
46837 resultobj = SWIG_Py_Void();
46838 return resultobj;
46839 fail:
46840 return NULL;
46841 }
46842
46843
46844 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46845 PyObject *resultobj = 0;
46846 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46847 wxColour result;
46848 void *argp1 = 0 ;
46849 int res1 = 0 ;
46850 PyObject *swig_obj[1] ;
46851
46852 if (!args) SWIG_fail;
46853 swig_obj[0] = args;
46854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46855 if (!SWIG_IsOK(res1)) {
46856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46857 }
46858 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46859 {
46860 PyThreadState* __tstate = wxPyBeginAllowThreads();
46861 result = wxMenuItem_GetTextColour(arg1);
46862 wxPyEndAllowThreads(__tstate);
46863 if (PyErr_Occurred()) SWIG_fail;
46864 }
46865 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46866 return resultobj;
46867 fail:
46868 return NULL;
46869 }
46870
46871
46872 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46873 PyObject *resultobj = 0;
46874 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46875 wxColour *arg2 = 0 ;
46876 void *argp1 = 0 ;
46877 int res1 = 0 ;
46878 wxColour temp2 ;
46879 PyObject * obj0 = 0 ;
46880 PyObject * obj1 = 0 ;
46881 char * kwnames[] = {
46882 (char *) "self",(char *) "colBack", NULL
46883 };
46884
46885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
46886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46887 if (!SWIG_IsOK(res1)) {
46888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46889 }
46890 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46891 {
46892 arg2 = &temp2;
46893 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46894 }
46895 {
46896 PyThreadState* __tstate = wxPyBeginAllowThreads();
46897 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
46898 wxPyEndAllowThreads(__tstate);
46899 if (PyErr_Occurred()) SWIG_fail;
46900 }
46901 resultobj = SWIG_Py_Void();
46902 return resultobj;
46903 fail:
46904 return NULL;
46905 }
46906
46907
46908 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46909 PyObject *resultobj = 0;
46910 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46911 wxColour result;
46912 void *argp1 = 0 ;
46913 int res1 = 0 ;
46914 PyObject *swig_obj[1] ;
46915
46916 if (!args) SWIG_fail;
46917 swig_obj[0] = args;
46918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46919 if (!SWIG_IsOK(res1)) {
46920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46921 }
46922 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46923 {
46924 PyThreadState* __tstate = wxPyBeginAllowThreads();
46925 result = wxMenuItem_GetBackgroundColour(arg1);
46926 wxPyEndAllowThreads(__tstate);
46927 if (PyErr_Occurred()) SWIG_fail;
46928 }
46929 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46930 return resultobj;
46931 fail:
46932 return NULL;
46933 }
46934
46935
46936 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46937 PyObject *resultobj = 0;
46938 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46939 wxBitmap *arg2 = 0 ;
46940 wxBitmap const &arg3_defvalue = wxNullBitmap ;
46941 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
46942 void *argp1 = 0 ;
46943 int res1 = 0 ;
46944 void *argp2 = 0 ;
46945 int res2 = 0 ;
46946 void *argp3 = 0 ;
46947 int res3 = 0 ;
46948 PyObject * obj0 = 0 ;
46949 PyObject * obj1 = 0 ;
46950 PyObject * obj2 = 0 ;
46951 char * kwnames[] = {
46952 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
46953 };
46954
46955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46957 if (!SWIG_IsOK(res1)) {
46958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46959 }
46960 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46961 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46962 if (!SWIG_IsOK(res2)) {
46963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46964 }
46965 if (!argp2) {
46966 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46967 }
46968 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46969 if (obj2) {
46970 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
46971 if (!SWIG_IsOK(res3)) {
46972 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46973 }
46974 if (!argp3) {
46975 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46976 }
46977 arg3 = reinterpret_cast< wxBitmap * >(argp3);
46978 }
46979 {
46980 PyThreadState* __tstate = wxPyBeginAllowThreads();
46981 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
46982 wxPyEndAllowThreads(__tstate);
46983 if (PyErr_Occurred()) SWIG_fail;
46984 }
46985 resultobj = SWIG_Py_Void();
46986 return resultobj;
46987 fail:
46988 return NULL;
46989 }
46990
46991
46992 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46993 PyObject *resultobj = 0;
46994 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46995 wxBitmap *arg2 = 0 ;
46996 void *argp1 = 0 ;
46997 int res1 = 0 ;
46998 void *argp2 = 0 ;
46999 int res2 = 0 ;
47000 PyObject * obj0 = 0 ;
47001 PyObject * obj1 = 0 ;
47002 char * kwnames[] = {
47003 (char *) "self",(char *) "bmpDisabled", NULL
47004 };
47005
47006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47008 if (!SWIG_IsOK(res1)) {
47009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47010 }
47011 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47012 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47013 if (!SWIG_IsOK(res2)) {
47014 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47015 }
47016 if (!argp2) {
47017 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47018 }
47019 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47020 {
47021 PyThreadState* __tstate = wxPyBeginAllowThreads();
47022 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
47023 wxPyEndAllowThreads(__tstate);
47024 if (PyErr_Occurred()) SWIG_fail;
47025 }
47026 resultobj = SWIG_Py_Void();
47027 return resultobj;
47028 fail:
47029 return NULL;
47030 }
47031
47032
47033 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47034 PyObject *resultobj = 0;
47035 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47036 wxBitmap *result = 0 ;
47037 void *argp1 = 0 ;
47038 int res1 = 0 ;
47039 PyObject *swig_obj[1] ;
47040
47041 if (!args) SWIG_fail;
47042 swig_obj[0] = args;
47043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47044 if (!SWIG_IsOK(res1)) {
47045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47046 }
47047 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47048 {
47049 PyThreadState* __tstate = wxPyBeginAllowThreads();
47050 {
47051 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
47052 result = (wxBitmap *) &_result_ref;
47053 }
47054 wxPyEndAllowThreads(__tstate);
47055 if (PyErr_Occurred()) SWIG_fail;
47056 }
47057 {
47058 wxBitmap* resultptr = new wxBitmap(*result);
47059 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47060 }
47061 return resultobj;
47062 fail:
47063 return NULL;
47064 }
47065
47066
47067 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47068 PyObject *resultobj = 0;
47069 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47070 int arg2 ;
47071 void *argp1 = 0 ;
47072 int res1 = 0 ;
47073 int val2 ;
47074 int ecode2 = 0 ;
47075 PyObject * obj0 = 0 ;
47076 PyObject * obj1 = 0 ;
47077 char * kwnames[] = {
47078 (char *) "self",(char *) "nWidth", NULL
47079 };
47080
47081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47083 if (!SWIG_IsOK(res1)) {
47084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47085 }
47086 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47087 ecode2 = SWIG_AsVal_int(obj1, &val2);
47088 if (!SWIG_IsOK(ecode2)) {
47089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47090 }
47091 arg2 = static_cast< int >(val2);
47092 {
47093 PyThreadState* __tstate = wxPyBeginAllowThreads();
47094 wxMenuItem_SetMarginWidth(arg1,arg2);
47095 wxPyEndAllowThreads(__tstate);
47096 if (PyErr_Occurred()) SWIG_fail;
47097 }
47098 resultobj = SWIG_Py_Void();
47099 return resultobj;
47100 fail:
47101 return NULL;
47102 }
47103
47104
47105 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47106 PyObject *resultobj = 0;
47107 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47108 int result;
47109 void *argp1 = 0 ;
47110 int res1 = 0 ;
47111 PyObject *swig_obj[1] ;
47112
47113 if (!args) SWIG_fail;
47114 swig_obj[0] = args;
47115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47116 if (!SWIG_IsOK(res1)) {
47117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47118 }
47119 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47120 {
47121 PyThreadState* __tstate = wxPyBeginAllowThreads();
47122 result = (int)wxMenuItem_GetMarginWidth(arg1);
47123 wxPyEndAllowThreads(__tstate);
47124 if (PyErr_Occurred()) SWIG_fail;
47125 }
47126 resultobj = SWIG_From_int(static_cast< int >(result));
47127 return resultobj;
47128 fail:
47129 return NULL;
47130 }
47131
47132
47133 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47134 PyObject *resultobj = 0;
47135 int result;
47136
47137 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47138 {
47139 PyThreadState* __tstate = wxPyBeginAllowThreads();
47140 result = (int)wxMenuItem_GetDefaultMarginWidth();
47141 wxPyEndAllowThreads(__tstate);
47142 if (PyErr_Occurred()) SWIG_fail;
47143 }
47144 resultobj = SWIG_From_int(static_cast< int >(result));
47145 return resultobj;
47146 fail:
47147 return NULL;
47148 }
47149
47150
47151 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47152 PyObject *resultobj = 0;
47153 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47154 bool result;
47155 void *argp1 = 0 ;
47156 int res1 = 0 ;
47157 PyObject *swig_obj[1] ;
47158
47159 if (!args) SWIG_fail;
47160 swig_obj[0] = args;
47161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47162 if (!SWIG_IsOK(res1)) {
47163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47164 }
47165 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47166 {
47167 PyThreadState* __tstate = wxPyBeginAllowThreads();
47168 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
47169 wxPyEndAllowThreads(__tstate);
47170 if (PyErr_Occurred()) SWIG_fail;
47171 }
47172 {
47173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47174 }
47175 return resultobj;
47176 fail:
47177 return NULL;
47178 }
47179
47180
47181 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47182 PyObject *resultobj = 0;
47183 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47184 bool arg2 = (bool) true ;
47185 void *argp1 = 0 ;
47186 int res1 = 0 ;
47187 bool val2 ;
47188 int ecode2 = 0 ;
47189 PyObject * obj0 = 0 ;
47190 PyObject * obj1 = 0 ;
47191 char * kwnames[] = {
47192 (char *) "self",(char *) "ownerDrawn", NULL
47193 };
47194
47195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47197 if (!SWIG_IsOK(res1)) {
47198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47199 }
47200 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47201 if (obj1) {
47202 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47203 if (!SWIG_IsOK(ecode2)) {
47204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47205 }
47206 arg2 = static_cast< bool >(val2);
47207 }
47208 {
47209 PyThreadState* __tstate = wxPyBeginAllowThreads();
47210 wxMenuItem_SetOwnerDrawn(arg1,arg2);
47211 wxPyEndAllowThreads(__tstate);
47212 if (PyErr_Occurred()) SWIG_fail;
47213 }
47214 resultobj = SWIG_Py_Void();
47215 return resultobj;
47216 fail:
47217 return NULL;
47218 }
47219
47220
47221 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47222 PyObject *resultobj = 0;
47223 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47224 void *argp1 = 0 ;
47225 int res1 = 0 ;
47226 PyObject *swig_obj[1] ;
47227
47228 if (!args) SWIG_fail;
47229 swig_obj[0] = args;
47230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47231 if (!SWIG_IsOK(res1)) {
47232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47233 }
47234 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47235 {
47236 PyThreadState* __tstate = wxPyBeginAllowThreads();
47237 wxMenuItem_ResetOwnerDrawn(arg1);
47238 wxPyEndAllowThreads(__tstate);
47239 if (PyErr_Occurred()) SWIG_fail;
47240 }
47241 resultobj = SWIG_Py_Void();
47242 return resultobj;
47243 fail:
47244 return NULL;
47245 }
47246
47247
47248 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47249 PyObject *obj;
47250 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47251 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47252 return SWIG_Py_Void();
47253 }
47254
47255 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47256 return SWIG_Python_InitShadowInstance(args);
47257 }
47258
47259 SWIGINTERN int ControlNameStr_set(PyObject *) {
47260 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47261 return 1;
47262 }
47263
47264
47265 SWIGINTERN PyObject *ControlNameStr_get(void) {
47266 PyObject *pyobj = 0;
47267
47268 {
47269 #if wxUSE_UNICODE
47270 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47271 #else
47272 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47273 #endif
47274 }
47275 return pyobj;
47276 }
47277
47278
47279 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47280 PyObject *resultobj = 0;
47281 wxWindow *arg1 = (wxWindow *) 0 ;
47282 int arg2 = (int) -1 ;
47283 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47284 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47285 wxSize const &arg4_defvalue = wxDefaultSize ;
47286 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47287 long arg5 = (long) 0 ;
47288 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47289 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47290 wxString const &arg7_defvalue = wxPyControlNameStr ;
47291 wxString *arg7 = (wxString *) &arg7_defvalue ;
47292 wxControl *result = 0 ;
47293 void *argp1 = 0 ;
47294 int res1 = 0 ;
47295 int val2 ;
47296 int ecode2 = 0 ;
47297 wxPoint temp3 ;
47298 wxSize temp4 ;
47299 long val5 ;
47300 int ecode5 = 0 ;
47301 void *argp6 = 0 ;
47302 int res6 = 0 ;
47303 bool temp7 = false ;
47304 PyObject * obj0 = 0 ;
47305 PyObject * obj1 = 0 ;
47306 PyObject * obj2 = 0 ;
47307 PyObject * obj3 = 0 ;
47308 PyObject * obj4 = 0 ;
47309 PyObject * obj5 = 0 ;
47310 PyObject * obj6 = 0 ;
47311 char * kwnames[] = {
47312 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47313 };
47314
47315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47317 if (!SWIG_IsOK(res1)) {
47318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47319 }
47320 arg1 = reinterpret_cast< wxWindow * >(argp1);
47321 if (obj1) {
47322 ecode2 = SWIG_AsVal_int(obj1, &val2);
47323 if (!SWIG_IsOK(ecode2)) {
47324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47325 }
47326 arg2 = static_cast< int >(val2);
47327 }
47328 if (obj2) {
47329 {
47330 arg3 = &temp3;
47331 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47332 }
47333 }
47334 if (obj3) {
47335 {
47336 arg4 = &temp4;
47337 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47338 }
47339 }
47340 if (obj4) {
47341 ecode5 = SWIG_AsVal_long(obj4, &val5);
47342 if (!SWIG_IsOK(ecode5)) {
47343 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47344 }
47345 arg5 = static_cast< long >(val5);
47346 }
47347 if (obj5) {
47348 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47349 if (!SWIG_IsOK(res6)) {
47350 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47351 }
47352 if (!argp6) {
47353 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47354 }
47355 arg6 = reinterpret_cast< wxValidator * >(argp6);
47356 }
47357 if (obj6) {
47358 {
47359 arg7 = wxString_in_helper(obj6);
47360 if (arg7 == NULL) SWIG_fail;
47361 temp7 = true;
47362 }
47363 }
47364 {
47365 if (!wxPyCheckForApp()) SWIG_fail;
47366 PyThreadState* __tstate = wxPyBeginAllowThreads();
47367 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47368 wxPyEndAllowThreads(__tstate);
47369 if (PyErr_Occurred()) SWIG_fail;
47370 }
47371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47372 {
47373 if (temp7)
47374 delete arg7;
47375 }
47376 return resultobj;
47377 fail:
47378 {
47379 if (temp7)
47380 delete arg7;
47381 }
47382 return NULL;
47383 }
47384
47385
47386 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47387 PyObject *resultobj = 0;
47388 wxControl *result = 0 ;
47389
47390 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47391 {
47392 if (!wxPyCheckForApp()) SWIG_fail;
47393 PyThreadState* __tstate = wxPyBeginAllowThreads();
47394 result = (wxControl *)new wxControl();
47395 wxPyEndAllowThreads(__tstate);
47396 if (PyErr_Occurred()) SWIG_fail;
47397 }
47398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47399 return resultobj;
47400 fail:
47401 return NULL;
47402 }
47403
47404
47405 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47406 PyObject *resultobj = 0;
47407 wxControl *arg1 = (wxControl *) 0 ;
47408 wxWindow *arg2 = (wxWindow *) 0 ;
47409 int arg3 = (int) -1 ;
47410 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47411 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47412 wxSize const &arg5_defvalue = wxDefaultSize ;
47413 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47414 long arg6 = (long) 0 ;
47415 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47416 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47417 wxString const &arg8_defvalue = wxPyControlNameStr ;
47418 wxString *arg8 = (wxString *) &arg8_defvalue ;
47419 bool result;
47420 void *argp1 = 0 ;
47421 int res1 = 0 ;
47422 void *argp2 = 0 ;
47423 int res2 = 0 ;
47424 int val3 ;
47425 int ecode3 = 0 ;
47426 wxPoint temp4 ;
47427 wxSize temp5 ;
47428 long val6 ;
47429 int ecode6 = 0 ;
47430 void *argp7 = 0 ;
47431 int res7 = 0 ;
47432 bool temp8 = false ;
47433 PyObject * obj0 = 0 ;
47434 PyObject * obj1 = 0 ;
47435 PyObject * obj2 = 0 ;
47436 PyObject * obj3 = 0 ;
47437 PyObject * obj4 = 0 ;
47438 PyObject * obj5 = 0 ;
47439 PyObject * obj6 = 0 ;
47440 PyObject * obj7 = 0 ;
47441 char * kwnames[] = {
47442 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47443 };
47444
47445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47447 if (!SWIG_IsOK(res1)) {
47448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47449 }
47450 arg1 = reinterpret_cast< wxControl * >(argp1);
47451 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47452 if (!SWIG_IsOK(res2)) {
47453 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47454 }
47455 arg2 = reinterpret_cast< wxWindow * >(argp2);
47456 if (obj2) {
47457 ecode3 = SWIG_AsVal_int(obj2, &val3);
47458 if (!SWIG_IsOK(ecode3)) {
47459 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47460 }
47461 arg3 = static_cast< int >(val3);
47462 }
47463 if (obj3) {
47464 {
47465 arg4 = &temp4;
47466 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47467 }
47468 }
47469 if (obj4) {
47470 {
47471 arg5 = &temp5;
47472 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47473 }
47474 }
47475 if (obj5) {
47476 ecode6 = SWIG_AsVal_long(obj5, &val6);
47477 if (!SWIG_IsOK(ecode6)) {
47478 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47479 }
47480 arg6 = static_cast< long >(val6);
47481 }
47482 if (obj6) {
47483 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47484 if (!SWIG_IsOK(res7)) {
47485 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47486 }
47487 if (!argp7) {
47488 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47489 }
47490 arg7 = reinterpret_cast< wxValidator * >(argp7);
47491 }
47492 if (obj7) {
47493 {
47494 arg8 = wxString_in_helper(obj7);
47495 if (arg8 == NULL) SWIG_fail;
47496 temp8 = true;
47497 }
47498 }
47499 {
47500 PyThreadState* __tstate = wxPyBeginAllowThreads();
47501 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47502 wxPyEndAllowThreads(__tstate);
47503 if (PyErr_Occurred()) SWIG_fail;
47504 }
47505 {
47506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47507 }
47508 {
47509 if (temp8)
47510 delete arg8;
47511 }
47512 return resultobj;
47513 fail:
47514 {
47515 if (temp8)
47516 delete arg8;
47517 }
47518 return NULL;
47519 }
47520
47521
47522 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47523 PyObject *resultobj = 0;
47524 wxControl *arg1 = (wxControl *) 0 ;
47525 int result;
47526 void *argp1 = 0 ;
47527 int res1 = 0 ;
47528 PyObject *swig_obj[1] ;
47529
47530 if (!args) SWIG_fail;
47531 swig_obj[0] = args;
47532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47533 if (!SWIG_IsOK(res1)) {
47534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47535 }
47536 arg1 = reinterpret_cast< wxControl * >(argp1);
47537 {
47538 PyThreadState* __tstate = wxPyBeginAllowThreads();
47539 result = (int)((wxControl const *)arg1)->GetAlignment();
47540 wxPyEndAllowThreads(__tstate);
47541 if (PyErr_Occurred()) SWIG_fail;
47542 }
47543 resultobj = SWIG_From_int(static_cast< int >(result));
47544 return resultobj;
47545 fail:
47546 return NULL;
47547 }
47548
47549
47550 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47551 PyObject *resultobj = 0;
47552 wxControl *arg1 = (wxControl *) 0 ;
47553 wxString result;
47554 void *argp1 = 0 ;
47555 int res1 = 0 ;
47556 PyObject *swig_obj[1] ;
47557
47558 if (!args) SWIG_fail;
47559 swig_obj[0] = args;
47560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47561 if (!SWIG_IsOK(res1)) {
47562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47563 }
47564 arg1 = reinterpret_cast< wxControl * >(argp1);
47565 {
47566 PyThreadState* __tstate = wxPyBeginAllowThreads();
47567 result = ((wxControl const *)arg1)->GetLabelText();
47568 wxPyEndAllowThreads(__tstate);
47569 if (PyErr_Occurred()) SWIG_fail;
47570 }
47571 {
47572 #if wxUSE_UNICODE
47573 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47574 #else
47575 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47576 #endif
47577 }
47578 return resultobj;
47579 fail:
47580 return NULL;
47581 }
47582
47583
47584 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47585 PyObject *resultobj = 0;
47586 wxControl *arg1 = (wxControl *) 0 ;
47587 wxCommandEvent *arg2 = 0 ;
47588 void *argp1 = 0 ;
47589 int res1 = 0 ;
47590 void *argp2 = 0 ;
47591 int res2 = 0 ;
47592 PyObject * obj0 = 0 ;
47593 PyObject * obj1 = 0 ;
47594 char * kwnames[] = {
47595 (char *) "self",(char *) "event", NULL
47596 };
47597
47598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47600 if (!SWIG_IsOK(res1)) {
47601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47602 }
47603 arg1 = reinterpret_cast< wxControl * >(argp1);
47604 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47605 if (!SWIG_IsOK(res2)) {
47606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47607 }
47608 if (!argp2) {
47609 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47610 }
47611 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47612 {
47613 PyThreadState* __tstate = wxPyBeginAllowThreads();
47614 (arg1)->Command(*arg2);
47615 wxPyEndAllowThreads(__tstate);
47616 if (PyErr_Occurred()) SWIG_fail;
47617 }
47618 resultobj = SWIG_Py_Void();
47619 return resultobj;
47620 fail:
47621 return NULL;
47622 }
47623
47624
47625 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47626 PyObject *resultobj = 0;
47627 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47628 SwigValueWrapper<wxVisualAttributes > result;
47629 int val1 ;
47630 int ecode1 = 0 ;
47631 PyObject * obj0 = 0 ;
47632 char * kwnames[] = {
47633 (char *) "variant", NULL
47634 };
47635
47636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47637 if (obj0) {
47638 ecode1 = SWIG_AsVal_int(obj0, &val1);
47639 if (!SWIG_IsOK(ecode1)) {
47640 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47641 }
47642 arg1 = static_cast< wxWindowVariant >(val1);
47643 }
47644 {
47645 if (!wxPyCheckForApp()) SWIG_fail;
47646 PyThreadState* __tstate = wxPyBeginAllowThreads();
47647 result = wxControl::GetClassDefaultAttributes(arg1);
47648 wxPyEndAllowThreads(__tstate);
47649 if (PyErr_Occurred()) SWIG_fail;
47650 }
47651 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47652 return resultobj;
47653 fail:
47654 return NULL;
47655 }
47656
47657
47658 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47659 PyObject *obj;
47660 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47661 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47662 return SWIG_Py_Void();
47663 }
47664
47665 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47666 return SWIG_Python_InitShadowInstance(args);
47667 }
47668
47669 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47670 PyObject *resultobj = 0;
47671 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47672 wxString *arg2 = 0 ;
47673 PyObject *arg3 = (PyObject *) NULL ;
47674 int result;
47675 void *argp1 = 0 ;
47676 int res1 = 0 ;
47677 bool temp2 = false ;
47678 PyObject * obj0 = 0 ;
47679 PyObject * obj1 = 0 ;
47680 PyObject * obj2 = 0 ;
47681 char * kwnames[] = {
47682 (char *) "self",(char *) "item",(char *) "clientData", NULL
47683 };
47684
47685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47687 if (!SWIG_IsOK(res1)) {
47688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47689 }
47690 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47691 {
47692 arg2 = wxString_in_helper(obj1);
47693 if (arg2 == NULL) SWIG_fail;
47694 temp2 = true;
47695 }
47696 if (obj2) {
47697 arg3 = obj2;
47698 }
47699 {
47700 PyThreadState* __tstate = wxPyBeginAllowThreads();
47701 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47702 wxPyEndAllowThreads(__tstate);
47703 if (PyErr_Occurred()) SWIG_fail;
47704 }
47705 resultobj = SWIG_From_int(static_cast< int >(result));
47706 {
47707 if (temp2)
47708 delete arg2;
47709 }
47710 return resultobj;
47711 fail:
47712 {
47713 if (temp2)
47714 delete arg2;
47715 }
47716 return NULL;
47717 }
47718
47719
47720 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47721 PyObject *resultobj = 0;
47722 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47723 wxArrayString *arg2 = 0 ;
47724 void *argp1 = 0 ;
47725 int res1 = 0 ;
47726 bool temp2 = false ;
47727 PyObject * obj0 = 0 ;
47728 PyObject * obj1 = 0 ;
47729 char * kwnames[] = {
47730 (char *) "self",(char *) "strings", NULL
47731 };
47732
47733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
47734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47735 if (!SWIG_IsOK(res1)) {
47736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47737 }
47738 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47739 {
47740 if (! PySequence_Check(obj1)) {
47741 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
47742 SWIG_fail;
47743 }
47744 arg2 = new wxArrayString;
47745 temp2 = true;
47746 int i, len=PySequence_Length(obj1);
47747 for (i=0; i<len; i++) {
47748 PyObject* item = PySequence_GetItem(obj1, i);
47749 wxString* s = wxString_in_helper(item);
47750 if (PyErr_Occurred()) SWIG_fail;
47751 arg2->Add(*s);
47752 delete s;
47753 Py_DECREF(item);
47754 }
47755 }
47756 {
47757 PyThreadState* __tstate = wxPyBeginAllowThreads();
47758 (arg1)->Append((wxArrayString const &)*arg2);
47759 wxPyEndAllowThreads(__tstate);
47760 if (PyErr_Occurred()) SWIG_fail;
47761 }
47762 resultobj = SWIG_Py_Void();
47763 {
47764 if (temp2) delete arg2;
47765 }
47766 return resultobj;
47767 fail:
47768 {
47769 if (temp2) delete arg2;
47770 }
47771 return NULL;
47772 }
47773
47774
47775 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47776 PyObject *resultobj = 0;
47777 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47778 wxString *arg2 = 0 ;
47779 unsigned int arg3 ;
47780 PyObject *arg4 = (PyObject *) NULL ;
47781 int result;
47782 void *argp1 = 0 ;
47783 int res1 = 0 ;
47784 bool temp2 = false ;
47785 unsigned int val3 ;
47786 int ecode3 = 0 ;
47787 PyObject * obj0 = 0 ;
47788 PyObject * obj1 = 0 ;
47789 PyObject * obj2 = 0 ;
47790 PyObject * obj3 = 0 ;
47791 char * kwnames[] = {
47792 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
47793 };
47794
47795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47797 if (!SWIG_IsOK(res1)) {
47798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47799 }
47800 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47801 {
47802 arg2 = wxString_in_helper(obj1);
47803 if (arg2 == NULL) SWIG_fail;
47804 temp2 = true;
47805 }
47806 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
47807 if (!SWIG_IsOK(ecode3)) {
47808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
47809 }
47810 arg3 = static_cast< unsigned int >(val3);
47811 if (obj3) {
47812 arg4 = obj3;
47813 }
47814 {
47815 PyThreadState* __tstate = wxPyBeginAllowThreads();
47816 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
47817 wxPyEndAllowThreads(__tstate);
47818 if (PyErr_Occurred()) SWIG_fail;
47819 }
47820 resultobj = SWIG_From_int(static_cast< int >(result));
47821 {
47822 if (temp2)
47823 delete arg2;
47824 }
47825 return resultobj;
47826 fail:
47827 {
47828 if (temp2)
47829 delete arg2;
47830 }
47831 return NULL;
47832 }
47833
47834
47835 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47836 PyObject *resultobj = 0;
47837 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47838 void *argp1 = 0 ;
47839 int res1 = 0 ;
47840 PyObject *swig_obj[1] ;
47841
47842 if (!args) SWIG_fail;
47843 swig_obj[0] = args;
47844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47845 if (!SWIG_IsOK(res1)) {
47846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47847 }
47848 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47849 {
47850 PyThreadState* __tstate = wxPyBeginAllowThreads();
47851 (arg1)->Clear();
47852 wxPyEndAllowThreads(__tstate);
47853 if (PyErr_Occurred()) SWIG_fail;
47854 }
47855 resultobj = SWIG_Py_Void();
47856 return resultobj;
47857 fail:
47858 return NULL;
47859 }
47860
47861
47862 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47863 PyObject *resultobj = 0;
47864 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47865 unsigned int arg2 ;
47866 void *argp1 = 0 ;
47867 int res1 = 0 ;
47868 unsigned int val2 ;
47869 int ecode2 = 0 ;
47870 PyObject * obj0 = 0 ;
47871 PyObject * obj1 = 0 ;
47872 char * kwnames[] = {
47873 (char *) "self",(char *) "n", NULL
47874 };
47875
47876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
47877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47878 if (!SWIG_IsOK(res1)) {
47879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47880 }
47881 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47882 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47883 if (!SWIG_IsOK(ecode2)) {
47884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
47885 }
47886 arg2 = static_cast< unsigned int >(val2);
47887 {
47888 PyThreadState* __tstate = wxPyBeginAllowThreads();
47889 (arg1)->Delete(arg2);
47890 wxPyEndAllowThreads(__tstate);
47891 if (PyErr_Occurred()) SWIG_fail;
47892 }
47893 resultobj = SWIG_Py_Void();
47894 return resultobj;
47895 fail:
47896 return NULL;
47897 }
47898
47899
47900 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47901 PyObject *resultobj = 0;
47902 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47903 unsigned int arg2 ;
47904 PyObject *result = 0 ;
47905 void *argp1 = 0 ;
47906 int res1 = 0 ;
47907 unsigned int val2 ;
47908 int ecode2 = 0 ;
47909 PyObject * obj0 = 0 ;
47910 PyObject * obj1 = 0 ;
47911 char * kwnames[] = {
47912 (char *) "self",(char *) "n", NULL
47913 };
47914
47915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
47916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47917 if (!SWIG_IsOK(res1)) {
47918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47919 }
47920 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47921 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47922 if (!SWIG_IsOK(ecode2)) {
47923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47924 }
47925 arg2 = static_cast< unsigned int >(val2);
47926 {
47927 PyThreadState* __tstate = wxPyBeginAllowThreads();
47928 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
47929 wxPyEndAllowThreads(__tstate);
47930 if (PyErr_Occurred()) SWIG_fail;
47931 }
47932 resultobj = result;
47933 return resultobj;
47934 fail:
47935 return NULL;
47936 }
47937
47938
47939 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47940 PyObject *resultobj = 0;
47941 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47942 unsigned int arg2 ;
47943 PyObject *arg3 = (PyObject *) 0 ;
47944 void *argp1 = 0 ;
47945 int res1 = 0 ;
47946 unsigned int val2 ;
47947 int ecode2 = 0 ;
47948 PyObject * obj0 = 0 ;
47949 PyObject * obj1 = 0 ;
47950 PyObject * obj2 = 0 ;
47951 char * kwnames[] = {
47952 (char *) "self",(char *) "n",(char *) "clientData", NULL
47953 };
47954
47955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47957 if (!SWIG_IsOK(res1)) {
47958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47959 }
47960 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47961 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47962 if (!SWIG_IsOK(ecode2)) {
47963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47964 }
47965 arg2 = static_cast< unsigned int >(val2);
47966 arg3 = obj2;
47967 {
47968 PyThreadState* __tstate = wxPyBeginAllowThreads();
47969 wxItemContainer_SetClientData(arg1,arg2,arg3);
47970 wxPyEndAllowThreads(__tstate);
47971 if (PyErr_Occurred()) SWIG_fail;
47972 }
47973 resultobj = SWIG_Py_Void();
47974 return resultobj;
47975 fail:
47976 return NULL;
47977 }
47978
47979
47980 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47981 PyObject *resultobj = 0;
47982 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47983 unsigned int result;
47984 void *argp1 = 0 ;
47985 int res1 = 0 ;
47986 PyObject *swig_obj[1] ;
47987
47988 if (!args) SWIG_fail;
47989 swig_obj[0] = args;
47990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47991 if (!SWIG_IsOK(res1)) {
47992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47993 }
47994 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47995 {
47996 PyThreadState* __tstate = wxPyBeginAllowThreads();
47997 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
47998 wxPyEndAllowThreads(__tstate);
47999 if (PyErr_Occurred()) SWIG_fail;
48000 }
48001 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
48002 return resultobj;
48003 fail:
48004 return NULL;
48005 }
48006
48007
48008 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48009 PyObject *resultobj = 0;
48010 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48011 bool result;
48012 void *argp1 = 0 ;
48013 int res1 = 0 ;
48014 PyObject *swig_obj[1] ;
48015
48016 if (!args) SWIG_fail;
48017 swig_obj[0] = args;
48018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48019 if (!SWIG_IsOK(res1)) {
48020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48021 }
48022 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48023 {
48024 PyThreadState* __tstate = wxPyBeginAllowThreads();
48025 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48026 wxPyEndAllowThreads(__tstate);
48027 if (PyErr_Occurred()) SWIG_fail;
48028 }
48029 {
48030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48031 }
48032 return resultobj;
48033 fail:
48034 return NULL;
48035 }
48036
48037
48038 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48039 PyObject *resultobj = 0;
48040 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48041 unsigned int arg2 ;
48042 wxString result;
48043 void *argp1 = 0 ;
48044 int res1 = 0 ;
48045 unsigned int val2 ;
48046 int ecode2 = 0 ;
48047 PyObject * obj0 = 0 ;
48048 PyObject * obj1 = 0 ;
48049 char * kwnames[] = {
48050 (char *) "self",(char *) "n", NULL
48051 };
48052
48053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48055 if (!SWIG_IsOK(res1)) {
48056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48057 }
48058 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48059 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
48060 if (!SWIG_IsOK(ecode2)) {
48061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
48062 }
48063 arg2 = static_cast< unsigned int >(val2);
48064 {
48065 PyThreadState* __tstate = wxPyBeginAllowThreads();
48066 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48067 wxPyEndAllowThreads(__tstate);
48068 if (PyErr_Occurred()) SWIG_fail;
48069 }
48070 {
48071 #if wxUSE_UNICODE
48072 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48073 #else
48074 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48075 #endif
48076 }
48077 return resultobj;
48078 fail:
48079 return NULL;
48080 }
48081
48082
48083 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48084 PyObject *resultobj = 0;
48085 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48086 wxArrayString result;
48087 void *argp1 = 0 ;
48088 int res1 = 0 ;
48089 PyObject *swig_obj[1] ;
48090
48091 if (!args) SWIG_fail;
48092 swig_obj[0] = args;
48093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48094 if (!SWIG_IsOK(res1)) {
48095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48096 }
48097 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48098 {
48099 PyThreadState* __tstate = wxPyBeginAllowThreads();
48100 result = ((wxItemContainer const *)arg1)->GetStrings();
48101 wxPyEndAllowThreads(__tstate);
48102 if (PyErr_Occurred()) SWIG_fail;
48103 }
48104 {
48105 resultobj = wxArrayString2PyList_helper(result);
48106 }
48107 return resultobj;
48108 fail:
48109 return NULL;
48110 }
48111
48112
48113 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48114 PyObject *resultobj = 0;
48115 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48116 unsigned int arg2 ;
48117 wxString *arg3 = 0 ;
48118 void *argp1 = 0 ;
48119 int res1 = 0 ;
48120 unsigned int val2 ;
48121 int ecode2 = 0 ;
48122 bool temp3 = false ;
48123 PyObject * obj0 = 0 ;
48124 PyObject * obj1 = 0 ;
48125 PyObject * obj2 = 0 ;
48126 char * kwnames[] = {
48127 (char *) "self",(char *) "n",(char *) "s", NULL
48128 };
48129
48130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48132 if (!SWIG_IsOK(res1)) {
48133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48134 }
48135 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48136 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
48137 if (!SWIG_IsOK(ecode2)) {
48138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
48139 }
48140 arg2 = static_cast< unsigned int >(val2);
48141 {
48142 arg3 = wxString_in_helper(obj2);
48143 if (arg3 == NULL) SWIG_fail;
48144 temp3 = true;
48145 }
48146 {
48147 PyThreadState* __tstate = wxPyBeginAllowThreads();
48148 (arg1)->SetString(arg2,(wxString const &)*arg3);
48149 wxPyEndAllowThreads(__tstate);
48150 if (PyErr_Occurred()) SWIG_fail;
48151 }
48152 resultobj = SWIG_Py_Void();
48153 {
48154 if (temp3)
48155 delete arg3;
48156 }
48157 return resultobj;
48158 fail:
48159 {
48160 if (temp3)
48161 delete arg3;
48162 }
48163 return NULL;
48164 }
48165
48166
48167 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48168 PyObject *resultobj = 0;
48169 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48170 wxString *arg2 = 0 ;
48171 int result;
48172 void *argp1 = 0 ;
48173 int res1 = 0 ;
48174 bool temp2 = false ;
48175 PyObject * obj0 = 0 ;
48176 PyObject * obj1 = 0 ;
48177 char * kwnames[] = {
48178 (char *) "self",(char *) "s", NULL
48179 };
48180
48181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48183 if (!SWIG_IsOK(res1)) {
48184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48185 }
48186 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48187 {
48188 arg2 = wxString_in_helper(obj1);
48189 if (arg2 == NULL) SWIG_fail;
48190 temp2 = true;
48191 }
48192 {
48193 PyThreadState* __tstate = wxPyBeginAllowThreads();
48194 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48195 wxPyEndAllowThreads(__tstate);
48196 if (PyErr_Occurred()) SWIG_fail;
48197 }
48198 resultobj = SWIG_From_int(static_cast< int >(result));
48199 {
48200 if (temp2)
48201 delete arg2;
48202 }
48203 return resultobj;
48204 fail:
48205 {
48206 if (temp2)
48207 delete arg2;
48208 }
48209 return NULL;
48210 }
48211
48212
48213 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48214 PyObject *resultobj = 0;
48215 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48216 int arg2 ;
48217 void *argp1 = 0 ;
48218 int res1 = 0 ;
48219 int val2 ;
48220 int ecode2 = 0 ;
48221 PyObject * obj0 = 0 ;
48222 PyObject * obj1 = 0 ;
48223 char * kwnames[] = {
48224 (char *) "self",(char *) "n", NULL
48225 };
48226
48227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48229 if (!SWIG_IsOK(res1)) {
48230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48231 }
48232 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48233 ecode2 = SWIG_AsVal_int(obj1, &val2);
48234 if (!SWIG_IsOK(ecode2)) {
48235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48236 }
48237 arg2 = static_cast< int >(val2);
48238 {
48239 PyThreadState* __tstate = wxPyBeginAllowThreads();
48240 (arg1)->SetSelection(arg2);
48241 wxPyEndAllowThreads(__tstate);
48242 if (PyErr_Occurred()) SWIG_fail;
48243 }
48244 resultobj = SWIG_Py_Void();
48245 return resultobj;
48246 fail:
48247 return NULL;
48248 }
48249
48250
48251 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48252 PyObject *resultobj = 0;
48253 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48254 int result;
48255 void *argp1 = 0 ;
48256 int res1 = 0 ;
48257 PyObject *swig_obj[1] ;
48258
48259 if (!args) SWIG_fail;
48260 swig_obj[0] = args;
48261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48262 if (!SWIG_IsOK(res1)) {
48263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48264 }
48265 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48266 {
48267 PyThreadState* __tstate = wxPyBeginAllowThreads();
48268 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48269 wxPyEndAllowThreads(__tstate);
48270 if (PyErr_Occurred()) SWIG_fail;
48271 }
48272 resultobj = SWIG_From_int(static_cast< int >(result));
48273 return resultobj;
48274 fail:
48275 return NULL;
48276 }
48277
48278
48279 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48280 PyObject *resultobj = 0;
48281 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48282 wxString *arg2 = 0 ;
48283 bool result;
48284 void *argp1 = 0 ;
48285 int res1 = 0 ;
48286 bool temp2 = false ;
48287 PyObject * obj0 = 0 ;
48288 PyObject * obj1 = 0 ;
48289 char * kwnames[] = {
48290 (char *) "self",(char *) "s", NULL
48291 };
48292
48293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48295 if (!SWIG_IsOK(res1)) {
48296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48297 }
48298 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48299 {
48300 arg2 = wxString_in_helper(obj1);
48301 if (arg2 == NULL) SWIG_fail;
48302 temp2 = true;
48303 }
48304 {
48305 PyThreadState* __tstate = wxPyBeginAllowThreads();
48306 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48307 wxPyEndAllowThreads(__tstate);
48308 if (PyErr_Occurred()) SWIG_fail;
48309 }
48310 {
48311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48312 }
48313 {
48314 if (temp2)
48315 delete arg2;
48316 }
48317 return resultobj;
48318 fail:
48319 {
48320 if (temp2)
48321 delete arg2;
48322 }
48323 return NULL;
48324 }
48325
48326
48327 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48328 PyObject *resultobj = 0;
48329 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48330 wxString result;
48331 void *argp1 = 0 ;
48332 int res1 = 0 ;
48333 PyObject *swig_obj[1] ;
48334
48335 if (!args) SWIG_fail;
48336 swig_obj[0] = args;
48337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48338 if (!SWIG_IsOK(res1)) {
48339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48340 }
48341 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48342 {
48343 PyThreadState* __tstate = wxPyBeginAllowThreads();
48344 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48345 wxPyEndAllowThreads(__tstate);
48346 if (PyErr_Occurred()) SWIG_fail;
48347 }
48348 {
48349 #if wxUSE_UNICODE
48350 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48351 #else
48352 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48353 #endif
48354 }
48355 return resultobj;
48356 fail:
48357 return NULL;
48358 }
48359
48360
48361 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48362 PyObject *resultobj = 0;
48363 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48364 int arg2 ;
48365 void *argp1 = 0 ;
48366 int res1 = 0 ;
48367 int val2 ;
48368 int ecode2 = 0 ;
48369 PyObject * obj0 = 0 ;
48370 PyObject * obj1 = 0 ;
48371 char * kwnames[] = {
48372 (char *) "self",(char *) "n", NULL
48373 };
48374
48375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48377 if (!SWIG_IsOK(res1)) {
48378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48379 }
48380 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48381 ecode2 = SWIG_AsVal_int(obj1, &val2);
48382 if (!SWIG_IsOK(ecode2)) {
48383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48384 }
48385 arg2 = static_cast< int >(val2);
48386 {
48387 PyThreadState* __tstate = wxPyBeginAllowThreads();
48388 (arg1)->Select(arg2);
48389 wxPyEndAllowThreads(__tstate);
48390 if (PyErr_Occurred()) SWIG_fail;
48391 }
48392 resultobj = SWIG_Py_Void();
48393 return resultobj;
48394 fail:
48395 return NULL;
48396 }
48397
48398
48399 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48400 PyObject *obj;
48401 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48402 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48403 return SWIG_Py_Void();
48404 }
48405
48406 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48407 PyObject *obj;
48408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48409 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48410 return SWIG_Py_Void();
48411 }
48412
48413 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48414 PyObject *resultobj = 0;
48415 wxSizerItem *result = 0 ;
48416
48417 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
48418 {
48419 PyThreadState* __tstate = wxPyBeginAllowThreads();
48420 result = (wxSizerItem *)new wxSizerItem();
48421 wxPyEndAllowThreads(__tstate);
48422 if (PyErr_Occurred()) SWIG_fail;
48423 }
48424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
48425 return resultobj;
48426 fail:
48427 return NULL;
48428 }
48429
48430
48431 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48432 PyObject *resultobj = 0;
48433 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48434 void *argp1 = 0 ;
48435 int res1 = 0 ;
48436 PyObject *swig_obj[1] ;
48437
48438 if (!args) SWIG_fail;
48439 swig_obj[0] = args;
48440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48441 if (!SWIG_IsOK(res1)) {
48442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48443 }
48444 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48445 {
48446 PyThreadState* __tstate = wxPyBeginAllowThreads();
48447 delete arg1;
48448
48449 wxPyEndAllowThreads(__tstate);
48450 if (PyErr_Occurred()) SWIG_fail;
48451 }
48452 resultobj = SWIG_Py_Void();
48453 return resultobj;
48454 fail:
48455 return NULL;
48456 }
48457
48458
48459 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48460 PyObject *resultobj = 0;
48461 wxWindow *arg1 = (wxWindow *) 0 ;
48462 int arg2 ;
48463 int arg3 ;
48464 int arg4 ;
48465 PyObject *arg5 = (PyObject *) NULL ;
48466 wxSizerItem *result = 0 ;
48467 void *argp1 = 0 ;
48468 int res1 = 0 ;
48469 int val2 ;
48470 int ecode2 = 0 ;
48471 int val3 ;
48472 int ecode3 = 0 ;
48473 int val4 ;
48474 int ecode4 = 0 ;
48475 PyObject * obj0 = 0 ;
48476 PyObject * obj1 = 0 ;
48477 PyObject * obj2 = 0 ;
48478 PyObject * obj3 = 0 ;
48479 PyObject * obj4 = 0 ;
48480 char * kwnames[] = {
48481 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48482 };
48483
48484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48486 if (!SWIG_IsOK(res1)) {
48487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
48488 }
48489 arg1 = reinterpret_cast< wxWindow * >(argp1);
48490 ecode2 = SWIG_AsVal_int(obj1, &val2);
48491 if (!SWIG_IsOK(ecode2)) {
48492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
48493 }
48494 arg2 = static_cast< int >(val2);
48495 ecode3 = SWIG_AsVal_int(obj2, &val3);
48496 if (!SWIG_IsOK(ecode3)) {
48497 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
48498 }
48499 arg3 = static_cast< int >(val3);
48500 ecode4 = SWIG_AsVal_int(obj3, &val4);
48501 if (!SWIG_IsOK(ecode4)) {
48502 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
48503 }
48504 arg4 = static_cast< int >(val4);
48505 if (obj4) {
48506 arg5 = obj4;
48507 }
48508 {
48509 PyThreadState* __tstate = wxPyBeginAllowThreads();
48510 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48511 wxPyEndAllowThreads(__tstate);
48512 if (PyErr_Occurred()) SWIG_fail;
48513 }
48514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48515 return resultobj;
48516 fail:
48517 return NULL;
48518 }
48519
48520
48521 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48522 PyObject *resultobj = 0;
48523 int arg1 ;
48524 int arg2 ;
48525 int arg3 ;
48526 int arg4 ;
48527 int arg5 ;
48528 PyObject *arg6 = (PyObject *) NULL ;
48529 wxSizerItem *result = 0 ;
48530 int val1 ;
48531 int ecode1 = 0 ;
48532 int val2 ;
48533 int ecode2 = 0 ;
48534 int val3 ;
48535 int ecode3 = 0 ;
48536 int val4 ;
48537 int ecode4 = 0 ;
48538 int val5 ;
48539 int ecode5 = 0 ;
48540 PyObject * obj0 = 0 ;
48541 PyObject * obj1 = 0 ;
48542 PyObject * obj2 = 0 ;
48543 PyObject * obj3 = 0 ;
48544 PyObject * obj4 = 0 ;
48545 PyObject * obj5 = 0 ;
48546 char * kwnames[] = {
48547 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48548 };
48549
48550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
48551 ecode1 = SWIG_AsVal_int(obj0, &val1);
48552 if (!SWIG_IsOK(ecode1)) {
48553 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
48554 }
48555 arg1 = static_cast< int >(val1);
48556 ecode2 = SWIG_AsVal_int(obj1, &val2);
48557 if (!SWIG_IsOK(ecode2)) {
48558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
48559 }
48560 arg2 = static_cast< int >(val2);
48561 ecode3 = SWIG_AsVal_int(obj2, &val3);
48562 if (!SWIG_IsOK(ecode3)) {
48563 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
48564 }
48565 arg3 = static_cast< int >(val3);
48566 ecode4 = SWIG_AsVal_int(obj3, &val4);
48567 if (!SWIG_IsOK(ecode4)) {
48568 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
48569 }
48570 arg4 = static_cast< int >(val4);
48571 ecode5 = SWIG_AsVal_int(obj4, &val5);
48572 if (!SWIG_IsOK(ecode5)) {
48573 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
48574 }
48575 arg5 = static_cast< int >(val5);
48576 if (obj5) {
48577 arg6 = obj5;
48578 }
48579 {
48580 PyThreadState* __tstate = wxPyBeginAllowThreads();
48581 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
48582 wxPyEndAllowThreads(__tstate);
48583 if (PyErr_Occurred()) SWIG_fail;
48584 }
48585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48586 return resultobj;
48587 fail:
48588 return NULL;
48589 }
48590
48591
48592 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48593 PyObject *resultobj = 0;
48594 wxSizer *arg1 = (wxSizer *) 0 ;
48595 int arg2 ;
48596 int arg3 ;
48597 int arg4 ;
48598 PyObject *arg5 = (PyObject *) NULL ;
48599 wxSizerItem *result = 0 ;
48600 int res1 = 0 ;
48601 int val2 ;
48602 int ecode2 = 0 ;
48603 int val3 ;
48604 int ecode3 = 0 ;
48605 int val4 ;
48606 int ecode4 = 0 ;
48607 PyObject * obj0 = 0 ;
48608 PyObject * obj1 = 0 ;
48609 PyObject * obj2 = 0 ;
48610 PyObject * obj3 = 0 ;
48611 PyObject * obj4 = 0 ;
48612 char * kwnames[] = {
48613 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48614 };
48615
48616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48617 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
48618 if (!SWIG_IsOK(res1)) {
48619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48620 }
48621 ecode2 = SWIG_AsVal_int(obj1, &val2);
48622 if (!SWIG_IsOK(ecode2)) {
48623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
48624 }
48625 arg2 = static_cast< int >(val2);
48626 ecode3 = SWIG_AsVal_int(obj2, &val3);
48627 if (!SWIG_IsOK(ecode3)) {
48628 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
48629 }
48630 arg3 = static_cast< int >(val3);
48631 ecode4 = SWIG_AsVal_int(obj3, &val4);
48632 if (!SWIG_IsOK(ecode4)) {
48633 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
48634 }
48635 arg4 = static_cast< int >(val4);
48636 if (obj4) {
48637 arg5 = obj4;
48638 }
48639 {
48640 PyThreadState* __tstate = wxPyBeginAllowThreads();
48641 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48642 wxPyEndAllowThreads(__tstate);
48643 if (PyErr_Occurred()) SWIG_fail;
48644 }
48645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48646 return resultobj;
48647 fail:
48648 return NULL;
48649 }
48650
48651
48652 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48653 PyObject *resultobj = 0;
48654 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48655 void *argp1 = 0 ;
48656 int res1 = 0 ;
48657 PyObject *swig_obj[1] ;
48658
48659 if (!args) SWIG_fail;
48660 swig_obj[0] = args;
48661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48662 if (!SWIG_IsOK(res1)) {
48663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48664 }
48665 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48666 {
48667 PyThreadState* __tstate = wxPyBeginAllowThreads();
48668 (arg1)->DeleteWindows();
48669 wxPyEndAllowThreads(__tstate);
48670 if (PyErr_Occurred()) SWIG_fail;
48671 }
48672 resultobj = SWIG_Py_Void();
48673 return resultobj;
48674 fail:
48675 return NULL;
48676 }
48677
48678
48679 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48680 PyObject *resultobj = 0;
48681 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48682 void *argp1 = 0 ;
48683 int res1 = 0 ;
48684 PyObject *swig_obj[1] ;
48685
48686 if (!args) SWIG_fail;
48687 swig_obj[0] = args;
48688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48689 if (!SWIG_IsOK(res1)) {
48690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48691 }
48692 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48693 {
48694 PyThreadState* __tstate = wxPyBeginAllowThreads();
48695 (arg1)->DetachSizer();
48696 wxPyEndAllowThreads(__tstate);
48697 if (PyErr_Occurred()) SWIG_fail;
48698 }
48699 resultobj = SWIG_Py_Void();
48700 return resultobj;
48701 fail:
48702 return NULL;
48703 }
48704
48705
48706 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48707 PyObject *resultobj = 0;
48708 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48709 wxSize result;
48710 void *argp1 = 0 ;
48711 int res1 = 0 ;
48712 PyObject *swig_obj[1] ;
48713
48714 if (!args) SWIG_fail;
48715 swig_obj[0] = args;
48716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48717 if (!SWIG_IsOK(res1)) {
48718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48719 }
48720 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48721 {
48722 PyThreadState* __tstate = wxPyBeginAllowThreads();
48723 result = (arg1)->GetSize();
48724 wxPyEndAllowThreads(__tstate);
48725 if (PyErr_Occurred()) SWIG_fail;
48726 }
48727 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48728 return resultobj;
48729 fail:
48730 return NULL;
48731 }
48732
48733
48734 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48735 PyObject *resultobj = 0;
48736 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48737 wxSize result;
48738 void *argp1 = 0 ;
48739 int res1 = 0 ;
48740 PyObject *swig_obj[1] ;
48741
48742 if (!args) SWIG_fail;
48743 swig_obj[0] = args;
48744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48745 if (!SWIG_IsOK(res1)) {
48746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48747 }
48748 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48749 {
48750 PyThreadState* __tstate = wxPyBeginAllowThreads();
48751 result = (arg1)->CalcMin();
48752 wxPyEndAllowThreads(__tstate);
48753 if (PyErr_Occurred()) SWIG_fail;
48754 }
48755 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48756 return resultobj;
48757 fail:
48758 return NULL;
48759 }
48760
48761
48762 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48763 PyObject *resultobj = 0;
48764 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48765 wxPoint *arg2 = 0 ;
48766 wxSize *arg3 = 0 ;
48767 void *argp1 = 0 ;
48768 int res1 = 0 ;
48769 wxPoint temp2 ;
48770 wxSize temp3 ;
48771 PyObject * obj0 = 0 ;
48772 PyObject * obj1 = 0 ;
48773 PyObject * obj2 = 0 ;
48774 char * kwnames[] = {
48775 (char *) "self",(char *) "pos",(char *) "size", NULL
48776 };
48777
48778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48780 if (!SWIG_IsOK(res1)) {
48781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48782 }
48783 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48784 {
48785 arg2 = &temp2;
48786 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
48787 }
48788 {
48789 arg3 = &temp3;
48790 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48791 }
48792 {
48793 PyThreadState* __tstate = wxPyBeginAllowThreads();
48794 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
48795 wxPyEndAllowThreads(__tstate);
48796 if (PyErr_Occurred()) SWIG_fail;
48797 }
48798 resultobj = SWIG_Py_Void();
48799 return resultobj;
48800 fail:
48801 return NULL;
48802 }
48803
48804
48805 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48806 PyObject *resultobj = 0;
48807 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48808 wxSize result;
48809 void *argp1 = 0 ;
48810 int res1 = 0 ;
48811 PyObject *swig_obj[1] ;
48812
48813 if (!args) SWIG_fail;
48814 swig_obj[0] = args;
48815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48816 if (!SWIG_IsOK(res1)) {
48817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48818 }
48819 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48820 {
48821 PyThreadState* __tstate = wxPyBeginAllowThreads();
48822 result = (arg1)->GetMinSize();
48823 wxPyEndAllowThreads(__tstate);
48824 if (PyErr_Occurred()) SWIG_fail;
48825 }
48826 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48827 return resultobj;
48828 fail:
48829 return NULL;
48830 }
48831
48832
48833 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48834 PyObject *resultobj = 0;
48835 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48836 wxSize result;
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_wxSizerItem, 0 | 0 );
48844 if (!SWIG_IsOK(res1)) {
48845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
48846 }
48847 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48848 {
48849 PyThreadState* __tstate = wxPyBeginAllowThreads();
48850 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
48851 wxPyEndAllowThreads(__tstate);
48852 if (PyErr_Occurred()) SWIG_fail;
48853 }
48854 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48855 return resultobj;
48856 fail:
48857 return NULL;
48858 }
48859
48860
48861 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48862 PyObject *resultobj = 0;
48863 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48864 int arg2 ;
48865 int arg3 ;
48866 void *argp1 = 0 ;
48867 int res1 = 0 ;
48868 int val2 ;
48869 int ecode2 = 0 ;
48870 int val3 ;
48871 int ecode3 = 0 ;
48872 PyObject * obj0 = 0 ;
48873 PyObject * obj1 = 0 ;
48874 PyObject * obj2 = 0 ;
48875 char * kwnames[] = {
48876 (char *) "self",(char *) "x",(char *) "y", NULL
48877 };
48878
48879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48881 if (!SWIG_IsOK(res1)) {
48882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48883 }
48884 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48885 ecode2 = SWIG_AsVal_int(obj1, &val2);
48886 if (!SWIG_IsOK(ecode2)) {
48887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
48888 }
48889 arg2 = static_cast< int >(val2);
48890 ecode3 = SWIG_AsVal_int(obj2, &val3);
48891 if (!SWIG_IsOK(ecode3)) {
48892 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
48893 }
48894 arg3 = static_cast< int >(val3);
48895 {
48896 PyThreadState* __tstate = wxPyBeginAllowThreads();
48897 (arg1)->SetInitSize(arg2,arg3);
48898 wxPyEndAllowThreads(__tstate);
48899 if (PyErr_Occurred()) SWIG_fail;
48900 }
48901 resultobj = SWIG_Py_Void();
48902 return resultobj;
48903 fail:
48904 return NULL;
48905 }
48906
48907
48908 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48909 PyObject *resultobj = 0;
48910 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48911 int arg2 ;
48912 int arg3 ;
48913 void *argp1 = 0 ;
48914 int res1 = 0 ;
48915 int val2 ;
48916 int ecode2 = 0 ;
48917 int val3 ;
48918 int ecode3 = 0 ;
48919 PyObject * obj0 = 0 ;
48920 PyObject * obj1 = 0 ;
48921 PyObject * obj2 = 0 ;
48922 char * kwnames[] = {
48923 (char *) "self",(char *) "width",(char *) "height", NULL
48924 };
48925
48926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48928 if (!SWIG_IsOK(res1)) {
48929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48930 }
48931 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48932 ecode2 = SWIG_AsVal_int(obj1, &val2);
48933 if (!SWIG_IsOK(ecode2)) {
48934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
48935 }
48936 arg2 = static_cast< int >(val2);
48937 ecode3 = SWIG_AsVal_int(obj2, &val3);
48938 if (!SWIG_IsOK(ecode3)) {
48939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
48940 }
48941 arg3 = static_cast< int >(val3);
48942 {
48943 PyThreadState* __tstate = wxPyBeginAllowThreads();
48944 (arg1)->SetRatio(arg2,arg3);
48945 wxPyEndAllowThreads(__tstate);
48946 if (PyErr_Occurred()) SWIG_fail;
48947 }
48948 resultobj = SWIG_Py_Void();
48949 return resultobj;
48950 fail:
48951 return NULL;
48952 }
48953
48954
48955 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48956 PyObject *resultobj = 0;
48957 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48958 wxSize *arg2 = 0 ;
48959 void *argp1 = 0 ;
48960 int res1 = 0 ;
48961 wxSize temp2 ;
48962 PyObject * obj0 = 0 ;
48963 PyObject * obj1 = 0 ;
48964 char * kwnames[] = {
48965 (char *) "self",(char *) "size", NULL
48966 };
48967
48968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
48969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48970 if (!SWIG_IsOK(res1)) {
48971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48972 }
48973 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48974 {
48975 arg2 = &temp2;
48976 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48977 }
48978 {
48979 PyThreadState* __tstate = wxPyBeginAllowThreads();
48980 (arg1)->SetRatio((wxSize const &)*arg2);
48981 wxPyEndAllowThreads(__tstate);
48982 if (PyErr_Occurred()) SWIG_fail;
48983 }
48984 resultobj = SWIG_Py_Void();
48985 return resultobj;
48986 fail:
48987 return NULL;
48988 }
48989
48990
48991 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48992 PyObject *resultobj = 0;
48993 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48994 float arg2 ;
48995 void *argp1 = 0 ;
48996 int res1 = 0 ;
48997 float val2 ;
48998 int ecode2 = 0 ;
48999 PyObject * obj0 = 0 ;
49000 PyObject * obj1 = 0 ;
49001 char * kwnames[] = {
49002 (char *) "self",(char *) "ratio", NULL
49003 };
49004
49005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
49006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49007 if (!SWIG_IsOK(res1)) {
49008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49009 }
49010 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49011 ecode2 = SWIG_AsVal_float(obj1, &val2);
49012 if (!SWIG_IsOK(ecode2)) {
49013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
49014 }
49015 arg2 = static_cast< float >(val2);
49016 {
49017 PyThreadState* __tstate = wxPyBeginAllowThreads();
49018 (arg1)->SetRatio(arg2);
49019 wxPyEndAllowThreads(__tstate);
49020 if (PyErr_Occurred()) SWIG_fail;
49021 }
49022 resultobj = SWIG_Py_Void();
49023 return resultobj;
49024 fail:
49025 return NULL;
49026 }
49027
49028
49029 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49030 PyObject *resultobj = 0;
49031 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49032 float result;
49033 void *argp1 = 0 ;
49034 int res1 = 0 ;
49035 PyObject *swig_obj[1] ;
49036
49037 if (!args) SWIG_fail;
49038 swig_obj[0] = args;
49039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49040 if (!SWIG_IsOK(res1)) {
49041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49042 }
49043 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49044 {
49045 PyThreadState* __tstate = wxPyBeginAllowThreads();
49046 result = (float)(arg1)->GetRatio();
49047 wxPyEndAllowThreads(__tstate);
49048 if (PyErr_Occurred()) SWIG_fail;
49049 }
49050 resultobj = SWIG_From_float(static_cast< float >(result));
49051 return resultobj;
49052 fail:
49053 return NULL;
49054 }
49055
49056
49057 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49058 PyObject *resultobj = 0;
49059 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49060 wxRect result;
49061 void *argp1 = 0 ;
49062 int res1 = 0 ;
49063 PyObject *swig_obj[1] ;
49064
49065 if (!args) SWIG_fail;
49066 swig_obj[0] = args;
49067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49068 if (!SWIG_IsOK(res1)) {
49069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49070 }
49071 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49072 {
49073 PyThreadState* __tstate = wxPyBeginAllowThreads();
49074 result = (arg1)->GetRect();
49075 wxPyEndAllowThreads(__tstate);
49076 if (PyErr_Occurred()) SWIG_fail;
49077 }
49078 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
49079 return resultobj;
49080 fail:
49081 return NULL;
49082 }
49083
49084
49085 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49086 PyObject *resultobj = 0;
49087 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49088 bool result;
49089 void *argp1 = 0 ;
49090 int res1 = 0 ;
49091 PyObject *swig_obj[1] ;
49092
49093 if (!args) SWIG_fail;
49094 swig_obj[0] = args;
49095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49096 if (!SWIG_IsOK(res1)) {
49097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49098 }
49099 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49100 {
49101 PyThreadState* __tstate = wxPyBeginAllowThreads();
49102 result = (bool)(arg1)->IsWindow();
49103 wxPyEndAllowThreads(__tstate);
49104 if (PyErr_Occurred()) SWIG_fail;
49105 }
49106 {
49107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49108 }
49109 return resultobj;
49110 fail:
49111 return NULL;
49112 }
49113
49114
49115 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49116 PyObject *resultobj = 0;
49117 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49118 bool result;
49119 void *argp1 = 0 ;
49120 int res1 = 0 ;
49121 PyObject *swig_obj[1] ;
49122
49123 if (!args) SWIG_fail;
49124 swig_obj[0] = args;
49125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49126 if (!SWIG_IsOK(res1)) {
49127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49128 }
49129 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49130 {
49131 PyThreadState* __tstate = wxPyBeginAllowThreads();
49132 result = (bool)(arg1)->IsSizer();
49133 wxPyEndAllowThreads(__tstate);
49134 if (PyErr_Occurred()) SWIG_fail;
49135 }
49136 {
49137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49138 }
49139 return resultobj;
49140 fail:
49141 return NULL;
49142 }
49143
49144
49145 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49146 PyObject *resultobj = 0;
49147 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49148 bool result;
49149 void *argp1 = 0 ;
49150 int res1 = 0 ;
49151 PyObject *swig_obj[1] ;
49152
49153 if (!args) SWIG_fail;
49154 swig_obj[0] = args;
49155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49156 if (!SWIG_IsOK(res1)) {
49157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49158 }
49159 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49160 {
49161 PyThreadState* __tstate = wxPyBeginAllowThreads();
49162 result = (bool)(arg1)->IsSpacer();
49163 wxPyEndAllowThreads(__tstate);
49164 if (PyErr_Occurred()) SWIG_fail;
49165 }
49166 {
49167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49168 }
49169 return resultobj;
49170 fail:
49171 return NULL;
49172 }
49173
49174
49175 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49176 PyObject *resultobj = 0;
49177 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49178 int arg2 ;
49179 void *argp1 = 0 ;
49180 int res1 = 0 ;
49181 int val2 ;
49182 int ecode2 = 0 ;
49183 PyObject * obj0 = 0 ;
49184 PyObject * obj1 = 0 ;
49185 char * kwnames[] = {
49186 (char *) "self",(char *) "proportion", NULL
49187 };
49188
49189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
49190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49191 if (!SWIG_IsOK(res1)) {
49192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49193 }
49194 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49195 ecode2 = SWIG_AsVal_int(obj1, &val2);
49196 if (!SWIG_IsOK(ecode2)) {
49197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
49198 }
49199 arg2 = static_cast< int >(val2);
49200 {
49201 PyThreadState* __tstate = wxPyBeginAllowThreads();
49202 (arg1)->SetProportion(arg2);
49203 wxPyEndAllowThreads(__tstate);
49204 if (PyErr_Occurred()) SWIG_fail;
49205 }
49206 resultobj = SWIG_Py_Void();
49207 return resultobj;
49208 fail:
49209 return NULL;
49210 }
49211
49212
49213 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49214 PyObject *resultobj = 0;
49215 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49216 int result;
49217 void *argp1 = 0 ;
49218 int res1 = 0 ;
49219 PyObject *swig_obj[1] ;
49220
49221 if (!args) SWIG_fail;
49222 swig_obj[0] = args;
49223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49224 if (!SWIG_IsOK(res1)) {
49225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49226 }
49227 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49228 {
49229 PyThreadState* __tstate = wxPyBeginAllowThreads();
49230 result = (int)(arg1)->GetProportion();
49231 wxPyEndAllowThreads(__tstate);
49232 if (PyErr_Occurred()) SWIG_fail;
49233 }
49234 resultobj = SWIG_From_int(static_cast< int >(result));
49235 return resultobj;
49236 fail:
49237 return NULL;
49238 }
49239
49240
49241 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49242 PyObject *resultobj = 0;
49243 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49244 int arg2 ;
49245 void *argp1 = 0 ;
49246 int res1 = 0 ;
49247 int val2 ;
49248 int ecode2 = 0 ;
49249 PyObject * obj0 = 0 ;
49250 PyObject * obj1 = 0 ;
49251 char * kwnames[] = {
49252 (char *) "self",(char *) "flag", NULL
49253 };
49254
49255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
49256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49257 if (!SWIG_IsOK(res1)) {
49258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49259 }
49260 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49261 ecode2 = SWIG_AsVal_int(obj1, &val2);
49262 if (!SWIG_IsOK(ecode2)) {
49263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
49264 }
49265 arg2 = static_cast< int >(val2);
49266 {
49267 PyThreadState* __tstate = wxPyBeginAllowThreads();
49268 (arg1)->SetFlag(arg2);
49269 wxPyEndAllowThreads(__tstate);
49270 if (PyErr_Occurred()) SWIG_fail;
49271 }
49272 resultobj = SWIG_Py_Void();
49273 return resultobj;
49274 fail:
49275 return NULL;
49276 }
49277
49278
49279 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49280 PyObject *resultobj = 0;
49281 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49282 int result;
49283 void *argp1 = 0 ;
49284 int res1 = 0 ;
49285 PyObject *swig_obj[1] ;
49286
49287 if (!args) SWIG_fail;
49288 swig_obj[0] = args;
49289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49290 if (!SWIG_IsOK(res1)) {
49291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49292 }
49293 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49294 {
49295 PyThreadState* __tstate = wxPyBeginAllowThreads();
49296 result = (int)(arg1)->GetFlag();
49297 wxPyEndAllowThreads(__tstate);
49298 if (PyErr_Occurred()) SWIG_fail;
49299 }
49300 resultobj = SWIG_From_int(static_cast< int >(result));
49301 return resultobj;
49302 fail:
49303 return NULL;
49304 }
49305
49306
49307 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49308 PyObject *resultobj = 0;
49309 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49310 int arg2 ;
49311 void *argp1 = 0 ;
49312 int res1 = 0 ;
49313 int val2 ;
49314 int ecode2 = 0 ;
49315 PyObject * obj0 = 0 ;
49316 PyObject * obj1 = 0 ;
49317 char * kwnames[] = {
49318 (char *) "self",(char *) "border", NULL
49319 };
49320
49321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49323 if (!SWIG_IsOK(res1)) {
49324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49325 }
49326 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49327 ecode2 = SWIG_AsVal_int(obj1, &val2);
49328 if (!SWIG_IsOK(ecode2)) {
49329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
49330 }
49331 arg2 = static_cast< int >(val2);
49332 {
49333 PyThreadState* __tstate = wxPyBeginAllowThreads();
49334 (arg1)->SetBorder(arg2);
49335 wxPyEndAllowThreads(__tstate);
49336 if (PyErr_Occurred()) SWIG_fail;
49337 }
49338 resultobj = SWIG_Py_Void();
49339 return resultobj;
49340 fail:
49341 return NULL;
49342 }
49343
49344
49345 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49346 PyObject *resultobj = 0;
49347 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49348 int result;
49349 void *argp1 = 0 ;
49350 int res1 = 0 ;
49351 PyObject *swig_obj[1] ;
49352
49353 if (!args) SWIG_fail;
49354 swig_obj[0] = args;
49355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49356 if (!SWIG_IsOK(res1)) {
49357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49358 }
49359 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49360 {
49361 PyThreadState* __tstate = wxPyBeginAllowThreads();
49362 result = (int)(arg1)->GetBorder();
49363 wxPyEndAllowThreads(__tstate);
49364 if (PyErr_Occurred()) SWIG_fail;
49365 }
49366 resultobj = SWIG_From_int(static_cast< int >(result));
49367 return resultobj;
49368 fail:
49369 return NULL;
49370 }
49371
49372
49373 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49374 PyObject *resultobj = 0;
49375 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49376 wxWindow *result = 0 ;
49377 void *argp1 = 0 ;
49378 int res1 = 0 ;
49379 PyObject *swig_obj[1] ;
49380
49381 if (!args) SWIG_fail;
49382 swig_obj[0] = args;
49383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49384 if (!SWIG_IsOK(res1)) {
49385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49386 }
49387 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49388 {
49389 PyThreadState* __tstate = wxPyBeginAllowThreads();
49390 result = (wxWindow *)(arg1)->GetWindow();
49391 wxPyEndAllowThreads(__tstate);
49392 if (PyErr_Occurred()) SWIG_fail;
49393 }
49394 {
49395 resultobj = wxPyMake_wxObject(result, 0);
49396 }
49397 return resultobj;
49398 fail:
49399 return NULL;
49400 }
49401
49402
49403 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49404 PyObject *resultobj = 0;
49405 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49406 wxWindow *arg2 = (wxWindow *) 0 ;
49407 void *argp1 = 0 ;
49408 int res1 = 0 ;
49409 void *argp2 = 0 ;
49410 int res2 = 0 ;
49411 PyObject * obj0 = 0 ;
49412 PyObject * obj1 = 0 ;
49413 char * kwnames[] = {
49414 (char *) "self",(char *) "window", NULL
49415 };
49416
49417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
49418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49419 if (!SWIG_IsOK(res1)) {
49420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49421 }
49422 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49423 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49424 if (!SWIG_IsOK(res2)) {
49425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
49426 }
49427 arg2 = reinterpret_cast< wxWindow * >(argp2);
49428 {
49429 PyThreadState* __tstate = wxPyBeginAllowThreads();
49430 (arg1)->SetWindow(arg2);
49431 wxPyEndAllowThreads(__tstate);
49432 if (PyErr_Occurred()) SWIG_fail;
49433 }
49434 resultobj = SWIG_Py_Void();
49435 return resultobj;
49436 fail:
49437 return NULL;
49438 }
49439
49440
49441 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49442 PyObject *resultobj = 0;
49443 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49444 wxSizer *result = 0 ;
49445 void *argp1 = 0 ;
49446 int res1 = 0 ;
49447 PyObject *swig_obj[1] ;
49448
49449 if (!args) SWIG_fail;
49450 swig_obj[0] = args;
49451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49452 if (!SWIG_IsOK(res1)) {
49453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49454 }
49455 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49456 {
49457 PyThreadState* __tstate = wxPyBeginAllowThreads();
49458 result = (wxSizer *)(arg1)->GetSizer();
49459 wxPyEndAllowThreads(__tstate);
49460 if (PyErr_Occurred()) SWIG_fail;
49461 }
49462 {
49463 resultobj = wxPyMake_wxObject(result, (bool)0);
49464 }
49465 return resultobj;
49466 fail:
49467 return NULL;
49468 }
49469
49470
49471 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49472 PyObject *resultobj = 0;
49473 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49474 wxSizer *arg2 = (wxSizer *) 0 ;
49475 void *argp1 = 0 ;
49476 int res1 = 0 ;
49477 int res2 = 0 ;
49478 PyObject * obj0 = 0 ;
49479 PyObject * obj1 = 0 ;
49480 char * kwnames[] = {
49481 (char *) "self",(char *) "sizer", NULL
49482 };
49483
49484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49486 if (!SWIG_IsOK(res1)) {
49487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49488 }
49489 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49490 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49491 if (!SWIG_IsOK(res2)) {
49492 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
49493 }
49494 {
49495 PyThreadState* __tstate = wxPyBeginAllowThreads();
49496 (arg1)->SetSizer(arg2);
49497 wxPyEndAllowThreads(__tstate);
49498 if (PyErr_Occurred()) SWIG_fail;
49499 }
49500 resultobj = SWIG_Py_Void();
49501 return resultobj;
49502 fail:
49503 return NULL;
49504 }
49505
49506
49507 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49508 PyObject *resultobj = 0;
49509 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49510 wxSize result;
49511 void *argp1 = 0 ;
49512 int res1 = 0 ;
49513 PyObject *swig_obj[1] ;
49514
49515 if (!args) SWIG_fail;
49516 swig_obj[0] = args;
49517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49518 if (!SWIG_IsOK(res1)) {
49519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49520 }
49521 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49522 {
49523 PyThreadState* __tstate = wxPyBeginAllowThreads();
49524 result = (arg1)->GetSpacer();
49525 wxPyEndAllowThreads(__tstate);
49526 if (PyErr_Occurred()) SWIG_fail;
49527 }
49528 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49529 return resultobj;
49530 fail:
49531 return NULL;
49532 }
49533
49534
49535 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49536 PyObject *resultobj = 0;
49537 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49538 wxSize *arg2 = 0 ;
49539 void *argp1 = 0 ;
49540 int res1 = 0 ;
49541 wxSize temp2 ;
49542 PyObject * obj0 = 0 ;
49543 PyObject * obj1 = 0 ;
49544 char * kwnames[] = {
49545 (char *) "self",(char *) "size", NULL
49546 };
49547
49548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
49549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49550 if (!SWIG_IsOK(res1)) {
49551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49552 }
49553 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49554 {
49555 arg2 = &temp2;
49556 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49557 }
49558 {
49559 PyThreadState* __tstate = wxPyBeginAllowThreads();
49560 (arg1)->SetSpacer((wxSize const &)*arg2);
49561 wxPyEndAllowThreads(__tstate);
49562 if (PyErr_Occurred()) SWIG_fail;
49563 }
49564 resultobj = SWIG_Py_Void();
49565 return resultobj;
49566 fail:
49567 return NULL;
49568 }
49569
49570
49571 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49572 PyObject *resultobj = 0;
49573 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49574 bool arg2 ;
49575 void *argp1 = 0 ;
49576 int res1 = 0 ;
49577 bool val2 ;
49578 int ecode2 = 0 ;
49579 PyObject * obj0 = 0 ;
49580 PyObject * obj1 = 0 ;
49581 char * kwnames[] = {
49582 (char *) "self",(char *) "show", NULL
49583 };
49584
49585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
49586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49587 if (!SWIG_IsOK(res1)) {
49588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49589 }
49590 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49591 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49592 if (!SWIG_IsOK(ecode2)) {
49593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
49594 }
49595 arg2 = static_cast< bool >(val2);
49596 {
49597 PyThreadState* __tstate = wxPyBeginAllowThreads();
49598 (arg1)->Show(arg2);
49599 wxPyEndAllowThreads(__tstate);
49600 if (PyErr_Occurred()) SWIG_fail;
49601 }
49602 resultobj = SWIG_Py_Void();
49603 return resultobj;
49604 fail:
49605 return NULL;
49606 }
49607
49608
49609 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49610 PyObject *resultobj = 0;
49611 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49612 bool result;
49613 void *argp1 = 0 ;
49614 int res1 = 0 ;
49615 PyObject *swig_obj[1] ;
49616
49617 if (!args) SWIG_fail;
49618 swig_obj[0] = args;
49619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49620 if (!SWIG_IsOK(res1)) {
49621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49622 }
49623 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49624 {
49625 PyThreadState* __tstate = wxPyBeginAllowThreads();
49626 result = (bool)(arg1)->IsShown();
49627 wxPyEndAllowThreads(__tstate);
49628 if (PyErr_Occurred()) SWIG_fail;
49629 }
49630 {
49631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49632 }
49633 return resultobj;
49634 fail:
49635 return NULL;
49636 }
49637
49638
49639 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49640 PyObject *resultobj = 0;
49641 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49642 wxPoint result;
49643 void *argp1 = 0 ;
49644 int res1 = 0 ;
49645 PyObject *swig_obj[1] ;
49646
49647 if (!args) SWIG_fail;
49648 swig_obj[0] = args;
49649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49650 if (!SWIG_IsOK(res1)) {
49651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49652 }
49653 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49654 {
49655 PyThreadState* __tstate = wxPyBeginAllowThreads();
49656 result = (arg1)->GetPosition();
49657 wxPyEndAllowThreads(__tstate);
49658 if (PyErr_Occurred()) SWIG_fail;
49659 }
49660 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
49661 return resultobj;
49662 fail:
49663 return NULL;
49664 }
49665
49666
49667 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49668 PyObject *resultobj = 0;
49669 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49670 PyObject *result = 0 ;
49671 void *argp1 = 0 ;
49672 int res1 = 0 ;
49673 PyObject *swig_obj[1] ;
49674
49675 if (!args) SWIG_fail;
49676 swig_obj[0] = args;
49677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49678 if (!SWIG_IsOK(res1)) {
49679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49680 }
49681 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49682 {
49683 PyThreadState* __tstate = wxPyBeginAllowThreads();
49684 result = (PyObject *)wxSizerItem_GetUserData(arg1);
49685 wxPyEndAllowThreads(__tstate);
49686 if (PyErr_Occurred()) SWIG_fail;
49687 }
49688 resultobj = result;
49689 return resultobj;
49690 fail:
49691 return NULL;
49692 }
49693
49694
49695 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49696 PyObject *resultobj = 0;
49697 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49698 PyObject *arg2 = (PyObject *) 0 ;
49699 void *argp1 = 0 ;
49700 int res1 = 0 ;
49701 PyObject * obj0 = 0 ;
49702 PyObject * obj1 = 0 ;
49703 char * kwnames[] = {
49704 (char *) "self",(char *) "userData", NULL
49705 };
49706
49707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
49708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49709 if (!SWIG_IsOK(res1)) {
49710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49711 }
49712 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49713 arg2 = obj1;
49714 {
49715 PyThreadState* __tstate = wxPyBeginAllowThreads();
49716 wxSizerItem_SetUserData(arg1,arg2);
49717 wxPyEndAllowThreads(__tstate);
49718 if (PyErr_Occurred()) SWIG_fail;
49719 }
49720 resultobj = SWIG_Py_Void();
49721 return resultobj;
49722 fail:
49723 return NULL;
49724 }
49725
49726
49727 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49728 PyObject *obj;
49729 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49730 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
49731 return SWIG_Py_Void();
49732 }
49733
49734 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49735 return SWIG_Python_InitShadowInstance(args);
49736 }
49737
49738 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49739 PyObject *resultobj = 0;
49740 wxSizer *arg1 = (wxSizer *) 0 ;
49741 void *argp1 = 0 ;
49742 int res1 = 0 ;
49743 PyObject *swig_obj[1] ;
49744
49745 if (!args) SWIG_fail;
49746 swig_obj[0] = args;
49747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49748 if (!SWIG_IsOK(res1)) {
49749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49750 }
49751 arg1 = reinterpret_cast< wxSizer * >(argp1);
49752 {
49753 PyThreadState* __tstate = wxPyBeginAllowThreads();
49754 delete arg1;
49755
49756 wxPyEndAllowThreads(__tstate);
49757 if (PyErr_Occurred()) SWIG_fail;
49758 }
49759 resultobj = SWIG_Py_Void();
49760 return resultobj;
49761 fail:
49762 return NULL;
49763 }
49764
49765
49766 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49767 PyObject *resultobj = 0;
49768 wxSizer *arg1 = (wxSizer *) 0 ;
49769 PyObject *arg2 = (PyObject *) 0 ;
49770 void *argp1 = 0 ;
49771 int res1 = 0 ;
49772 PyObject * obj0 = 0 ;
49773 PyObject * obj1 = 0 ;
49774 char * kwnames[] = {
49775 (char *) "self",(char *) "_self", NULL
49776 };
49777
49778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
49779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49780 if (!SWIG_IsOK(res1)) {
49781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
49782 }
49783 arg1 = reinterpret_cast< wxSizer * >(argp1);
49784 arg2 = obj1;
49785 {
49786 PyThreadState* __tstate = wxPyBeginAllowThreads();
49787 wxSizer__setOORInfo(arg1,arg2);
49788 wxPyEndAllowThreads(__tstate);
49789 if (PyErr_Occurred()) SWIG_fail;
49790 }
49791 resultobj = SWIG_Py_Void();
49792 return resultobj;
49793 fail:
49794 return NULL;
49795 }
49796
49797
49798 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49799 PyObject *resultobj = 0;
49800 wxSizer *arg1 = (wxSizer *) 0 ;
49801 PyObject *arg2 = (PyObject *) 0 ;
49802 int arg3 = (int) 0 ;
49803 int arg4 = (int) 0 ;
49804 int arg5 = (int) 0 ;
49805 PyObject *arg6 = (PyObject *) NULL ;
49806 wxSizerItem *result = 0 ;
49807 void *argp1 = 0 ;
49808 int res1 = 0 ;
49809 int val3 ;
49810 int ecode3 = 0 ;
49811 int val4 ;
49812 int ecode4 = 0 ;
49813 int val5 ;
49814 int ecode5 = 0 ;
49815 PyObject * obj0 = 0 ;
49816 PyObject * obj1 = 0 ;
49817 PyObject * obj2 = 0 ;
49818 PyObject * obj3 = 0 ;
49819 PyObject * obj4 = 0 ;
49820 PyObject * obj5 = 0 ;
49821 char * kwnames[] = {
49822 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49823 };
49824
49825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49827 if (!SWIG_IsOK(res1)) {
49828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
49829 }
49830 arg1 = reinterpret_cast< wxSizer * >(argp1);
49831 arg2 = obj1;
49832 if (obj2) {
49833 ecode3 = SWIG_AsVal_int(obj2, &val3);
49834 if (!SWIG_IsOK(ecode3)) {
49835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
49836 }
49837 arg3 = static_cast< int >(val3);
49838 }
49839 if (obj3) {
49840 ecode4 = SWIG_AsVal_int(obj3, &val4);
49841 if (!SWIG_IsOK(ecode4)) {
49842 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
49843 }
49844 arg4 = static_cast< int >(val4);
49845 }
49846 if (obj4) {
49847 ecode5 = SWIG_AsVal_int(obj4, &val5);
49848 if (!SWIG_IsOK(ecode5)) {
49849 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
49850 }
49851 arg5 = static_cast< int >(val5);
49852 }
49853 if (obj5) {
49854 arg6 = obj5;
49855 }
49856 {
49857 PyThreadState* __tstate = wxPyBeginAllowThreads();
49858 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
49859 wxPyEndAllowThreads(__tstate);
49860 if (PyErr_Occurred()) SWIG_fail;
49861 }
49862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49863 return resultobj;
49864 fail:
49865 return NULL;
49866 }
49867
49868
49869 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49870 PyObject *resultobj = 0;
49871 wxSizer *arg1 = (wxSizer *) 0 ;
49872 int arg2 ;
49873 PyObject *arg3 = (PyObject *) 0 ;
49874 int arg4 = (int) 0 ;
49875 int arg5 = (int) 0 ;
49876 int arg6 = (int) 0 ;
49877 PyObject *arg7 = (PyObject *) NULL ;
49878 wxSizerItem *result = 0 ;
49879 void *argp1 = 0 ;
49880 int res1 = 0 ;
49881 int val2 ;
49882 int ecode2 = 0 ;
49883 int val4 ;
49884 int ecode4 = 0 ;
49885 int val5 ;
49886 int ecode5 = 0 ;
49887 int val6 ;
49888 int ecode6 = 0 ;
49889 PyObject * obj0 = 0 ;
49890 PyObject * obj1 = 0 ;
49891 PyObject * obj2 = 0 ;
49892 PyObject * obj3 = 0 ;
49893 PyObject * obj4 = 0 ;
49894 PyObject * obj5 = 0 ;
49895 PyObject * obj6 = 0 ;
49896 char * kwnames[] = {
49897 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49898 };
49899
49900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49902 if (!SWIG_IsOK(res1)) {
49903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
49904 }
49905 arg1 = reinterpret_cast< wxSizer * >(argp1);
49906 ecode2 = SWIG_AsVal_int(obj1, &val2);
49907 if (!SWIG_IsOK(ecode2)) {
49908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
49909 }
49910 arg2 = static_cast< int >(val2);
49911 arg3 = obj2;
49912 if (obj3) {
49913 ecode4 = SWIG_AsVal_int(obj3, &val4);
49914 if (!SWIG_IsOK(ecode4)) {
49915 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
49916 }
49917 arg4 = static_cast< int >(val4);
49918 }
49919 if (obj4) {
49920 ecode5 = SWIG_AsVal_int(obj4, &val5);
49921 if (!SWIG_IsOK(ecode5)) {
49922 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
49923 }
49924 arg5 = static_cast< int >(val5);
49925 }
49926 if (obj5) {
49927 ecode6 = SWIG_AsVal_int(obj5, &val6);
49928 if (!SWIG_IsOK(ecode6)) {
49929 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
49930 }
49931 arg6 = static_cast< int >(val6);
49932 }
49933 if (obj6) {
49934 arg7 = obj6;
49935 }
49936 {
49937 PyThreadState* __tstate = wxPyBeginAllowThreads();
49938 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
49939 wxPyEndAllowThreads(__tstate);
49940 if (PyErr_Occurred()) SWIG_fail;
49941 }
49942 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49943 return resultobj;
49944 fail:
49945 return NULL;
49946 }
49947
49948
49949 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49950 PyObject *resultobj = 0;
49951 wxSizer *arg1 = (wxSizer *) 0 ;
49952 PyObject *arg2 = (PyObject *) 0 ;
49953 int arg3 = (int) 0 ;
49954 int arg4 = (int) 0 ;
49955 int arg5 = (int) 0 ;
49956 PyObject *arg6 = (PyObject *) NULL ;
49957 wxSizerItem *result = 0 ;
49958 void *argp1 = 0 ;
49959 int res1 = 0 ;
49960 int val3 ;
49961 int ecode3 = 0 ;
49962 int val4 ;
49963 int ecode4 = 0 ;
49964 int val5 ;
49965 int ecode5 = 0 ;
49966 PyObject * obj0 = 0 ;
49967 PyObject * obj1 = 0 ;
49968 PyObject * obj2 = 0 ;
49969 PyObject * obj3 = 0 ;
49970 PyObject * obj4 = 0 ;
49971 PyObject * obj5 = 0 ;
49972 char * kwnames[] = {
49973 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49974 };
49975
49976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49978 if (!SWIG_IsOK(res1)) {
49979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
49980 }
49981 arg1 = reinterpret_cast< wxSizer * >(argp1);
49982 arg2 = obj1;
49983 if (obj2) {
49984 ecode3 = SWIG_AsVal_int(obj2, &val3);
49985 if (!SWIG_IsOK(ecode3)) {
49986 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
49987 }
49988 arg3 = static_cast< int >(val3);
49989 }
49990 if (obj3) {
49991 ecode4 = SWIG_AsVal_int(obj3, &val4);
49992 if (!SWIG_IsOK(ecode4)) {
49993 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
49994 }
49995 arg4 = static_cast< int >(val4);
49996 }
49997 if (obj4) {
49998 ecode5 = SWIG_AsVal_int(obj4, &val5);
49999 if (!SWIG_IsOK(ecode5)) {
50000 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
50001 }
50002 arg5 = static_cast< int >(val5);
50003 }
50004 if (obj5) {
50005 arg6 = obj5;
50006 }
50007 {
50008 PyThreadState* __tstate = wxPyBeginAllowThreads();
50009 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
50010 wxPyEndAllowThreads(__tstate);
50011 if (PyErr_Occurred()) SWIG_fail;
50012 }
50013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50014 return resultobj;
50015 fail:
50016 return NULL;
50017 }
50018
50019
50020 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50021 PyObject *resultobj = 0;
50022 wxSizer *arg1 = (wxSizer *) 0 ;
50023 PyObject *arg2 = (PyObject *) 0 ;
50024 bool result;
50025 void *argp1 = 0 ;
50026 int res1 = 0 ;
50027 PyObject * obj0 = 0 ;
50028 PyObject * obj1 = 0 ;
50029 char * kwnames[] = {
50030 (char *) "self",(char *) "item", NULL
50031 };
50032
50033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
50034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50035 if (!SWIG_IsOK(res1)) {
50036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
50037 }
50038 arg1 = reinterpret_cast< wxSizer * >(argp1);
50039 arg2 = obj1;
50040 {
50041 PyThreadState* __tstate = wxPyBeginAllowThreads();
50042 result = (bool)wxSizer_Remove(arg1,arg2);
50043 wxPyEndAllowThreads(__tstate);
50044 if (PyErr_Occurred()) SWIG_fail;
50045 }
50046 {
50047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50048 }
50049 return resultobj;
50050 fail:
50051 return NULL;
50052 }
50053
50054
50055 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50056 PyObject *resultobj = 0;
50057 wxSizer *arg1 = (wxSizer *) 0 ;
50058 PyObject *arg2 = (PyObject *) 0 ;
50059 bool result;
50060 void *argp1 = 0 ;
50061 int res1 = 0 ;
50062 PyObject * obj0 = 0 ;
50063 PyObject * obj1 = 0 ;
50064 char * kwnames[] = {
50065 (char *) "self",(char *) "item", NULL
50066 };
50067
50068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
50069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50070 if (!SWIG_IsOK(res1)) {
50071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
50072 }
50073 arg1 = reinterpret_cast< wxSizer * >(argp1);
50074 arg2 = obj1;
50075 {
50076 PyThreadState* __tstate = wxPyBeginAllowThreads();
50077 result = (bool)wxSizer_Detach(arg1,arg2);
50078 wxPyEndAllowThreads(__tstate);
50079 if (PyErr_Occurred()) SWIG_fail;
50080 }
50081 {
50082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50083 }
50084 return resultobj;
50085 fail:
50086 return NULL;
50087 }
50088
50089
50090 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50091 PyObject *resultobj = 0;
50092 wxSizer *arg1 = (wxSizer *) 0 ;
50093 PyObject *arg2 = (PyObject *) 0 ;
50094 wxSizerItem *result = 0 ;
50095 void *argp1 = 0 ;
50096 int res1 = 0 ;
50097 PyObject * obj0 = 0 ;
50098 PyObject * obj1 = 0 ;
50099 char * kwnames[] = {
50100 (char *) "self",(char *) "item", NULL
50101 };
50102
50103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
50104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50105 if (!SWIG_IsOK(res1)) {
50106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50107 }
50108 arg1 = reinterpret_cast< wxSizer * >(argp1);
50109 arg2 = obj1;
50110 {
50111 PyThreadState* __tstate = wxPyBeginAllowThreads();
50112 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
50113 wxPyEndAllowThreads(__tstate);
50114 if (PyErr_Occurred()) SWIG_fail;
50115 }
50116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50117 return resultobj;
50118 fail:
50119 return NULL;
50120 }
50121
50122
50123 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50124 PyObject *resultobj = 0;
50125 wxSizer *arg1 = (wxSizer *) 0 ;
50126 PyObject *arg2 = (PyObject *) 0 ;
50127 wxSize *arg3 = 0 ;
50128 void *argp1 = 0 ;
50129 int res1 = 0 ;
50130 wxSize temp3 ;
50131 PyObject * obj0 = 0 ;
50132 PyObject * obj1 = 0 ;
50133 PyObject * obj2 = 0 ;
50134 char * kwnames[] = {
50135 (char *) "self",(char *) "item",(char *) "size", NULL
50136 };
50137
50138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50140 if (!SWIG_IsOK(res1)) {
50141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50142 }
50143 arg1 = reinterpret_cast< wxSizer * >(argp1);
50144 arg2 = obj1;
50145 {
50146 arg3 = &temp3;
50147 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50148 }
50149 {
50150 PyThreadState* __tstate = wxPyBeginAllowThreads();
50151 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
50152 wxPyEndAllowThreads(__tstate);
50153 if (PyErr_Occurred()) SWIG_fail;
50154 }
50155 resultobj = SWIG_Py_Void();
50156 return resultobj;
50157 fail:
50158 return NULL;
50159 }
50160
50161
50162 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50163 PyObject *resultobj = 0;
50164 wxSizer *arg1 = (wxSizer *) 0 ;
50165 wxWindow *arg2 = (wxWindow *) 0 ;
50166 wxWindow *arg3 = (wxWindow *) 0 ;
50167 bool arg4 = (bool) false ;
50168 bool result;
50169 void *argp1 = 0 ;
50170 int res1 = 0 ;
50171 void *argp2 = 0 ;
50172 int res2 = 0 ;
50173 void *argp3 = 0 ;
50174 int res3 = 0 ;
50175 bool val4 ;
50176 int ecode4 = 0 ;
50177 PyObject * obj0 = 0 ;
50178 PyObject * obj1 = 0 ;
50179 PyObject * obj2 = 0 ;
50180 PyObject * obj3 = 0 ;
50181 char * kwnames[] = {
50182 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
50183 };
50184
50185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50187 if (!SWIG_IsOK(res1)) {
50188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
50189 }
50190 arg1 = reinterpret_cast< wxSizer * >(argp1);
50191 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50192 if (!SWIG_IsOK(res2)) {
50193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
50194 }
50195 arg2 = reinterpret_cast< wxWindow * >(argp2);
50196 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50197 if (!SWIG_IsOK(res3)) {
50198 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
50199 }
50200 arg3 = reinterpret_cast< wxWindow * >(argp3);
50201 if (obj3) {
50202 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50203 if (!SWIG_IsOK(ecode4)) {
50204 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
50205 }
50206 arg4 = static_cast< bool >(val4);
50207 }
50208 {
50209 PyThreadState* __tstate = wxPyBeginAllowThreads();
50210 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50211 wxPyEndAllowThreads(__tstate);
50212 if (PyErr_Occurred()) SWIG_fail;
50213 }
50214 {
50215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50216 }
50217 return resultobj;
50218 fail:
50219 return NULL;
50220 }
50221
50222
50223 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50224 PyObject *resultobj = 0;
50225 wxSizer *arg1 = (wxSizer *) 0 ;
50226 wxSizer *arg2 = (wxSizer *) 0 ;
50227 wxSizer *arg3 = (wxSizer *) 0 ;
50228 bool arg4 = (bool) false ;
50229 bool result;
50230 void *argp1 = 0 ;
50231 int res1 = 0 ;
50232 void *argp2 = 0 ;
50233 int res2 = 0 ;
50234 void *argp3 = 0 ;
50235 int res3 = 0 ;
50236 bool val4 ;
50237 int ecode4 = 0 ;
50238 PyObject * obj0 = 0 ;
50239 PyObject * obj1 = 0 ;
50240 PyObject * obj2 = 0 ;
50241 PyObject * obj3 = 0 ;
50242 char * kwnames[] = {
50243 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
50244 };
50245
50246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50248 if (!SWIG_IsOK(res1)) {
50249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50250 }
50251 arg1 = reinterpret_cast< wxSizer * >(argp1);
50252 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50253 if (!SWIG_IsOK(res2)) {
50254 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50255 }
50256 arg2 = reinterpret_cast< wxSizer * >(argp2);
50257 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
50258 if (!SWIG_IsOK(res3)) {
50259 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
50260 }
50261 arg3 = reinterpret_cast< wxSizer * >(argp3);
50262 if (obj3) {
50263 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50264 if (!SWIG_IsOK(ecode4)) {
50265 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
50266 }
50267 arg4 = static_cast< bool >(val4);
50268 }
50269 {
50270 PyThreadState* __tstate = wxPyBeginAllowThreads();
50271 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50272 wxPyEndAllowThreads(__tstate);
50273 if (PyErr_Occurred()) SWIG_fail;
50274 }
50275 {
50276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50277 }
50278 return resultobj;
50279 fail:
50280 return NULL;
50281 }
50282
50283
50284 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50285 PyObject *resultobj = 0;
50286 wxSizer *arg1 = (wxSizer *) 0 ;
50287 size_t arg2 ;
50288 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50289 bool result;
50290 void *argp1 = 0 ;
50291 int res1 = 0 ;
50292 size_t val2 ;
50293 int ecode2 = 0 ;
50294 void *argp3 = 0 ;
50295 int res3 = 0 ;
50296 PyObject * obj0 = 0 ;
50297 PyObject * obj1 = 0 ;
50298 PyObject * obj2 = 0 ;
50299 char * kwnames[] = {
50300 (char *) "self",(char *) "index",(char *) "newitem", NULL
50301 };
50302
50303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50305 if (!SWIG_IsOK(res1)) {
50306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50307 }
50308 arg1 = reinterpret_cast< wxSizer * >(argp1);
50309 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50310 if (!SWIG_IsOK(ecode2)) {
50311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
50312 }
50313 arg2 = static_cast< size_t >(val2);
50314 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50315 if (!SWIG_IsOK(res3)) {
50316 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50317 }
50318 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
50319 {
50320 PyThreadState* __tstate = wxPyBeginAllowThreads();
50321 result = (bool)(arg1)->Replace(arg2,arg3);
50322 wxPyEndAllowThreads(__tstate);
50323 if (PyErr_Occurred()) SWIG_fail;
50324 }
50325 {
50326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50327 }
50328 return resultobj;
50329 fail:
50330 return NULL;
50331 }
50332
50333
50334 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50335 PyObject *resultobj = 0;
50336 wxSizer *arg1 = (wxSizer *) 0 ;
50337 wxWindow *arg2 = (wxWindow *) 0 ;
50338 void *argp1 = 0 ;
50339 int res1 = 0 ;
50340 void *argp2 = 0 ;
50341 int res2 = 0 ;
50342 PyObject * obj0 = 0 ;
50343 PyObject * obj1 = 0 ;
50344 char * kwnames[] = {
50345 (char *) "self",(char *) "window", NULL
50346 };
50347
50348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50350 if (!SWIG_IsOK(res1)) {
50351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
50352 }
50353 arg1 = reinterpret_cast< wxSizer * >(argp1);
50354 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50355 if (!SWIG_IsOK(res2)) {
50356 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50357 }
50358 arg2 = reinterpret_cast< wxWindow * >(argp2);
50359 {
50360 PyThreadState* __tstate = wxPyBeginAllowThreads();
50361 (arg1)->SetContainingWindow(arg2);
50362 wxPyEndAllowThreads(__tstate);
50363 if (PyErr_Occurred()) SWIG_fail;
50364 }
50365 resultobj = SWIG_Py_Void();
50366 return resultobj;
50367 fail:
50368 return NULL;
50369 }
50370
50371
50372 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50373 PyObject *resultobj = 0;
50374 wxSizer *arg1 = (wxSizer *) 0 ;
50375 wxWindow *result = 0 ;
50376 void *argp1 = 0 ;
50377 int res1 = 0 ;
50378 PyObject *swig_obj[1] ;
50379
50380 if (!args) SWIG_fail;
50381 swig_obj[0] = args;
50382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50383 if (!SWIG_IsOK(res1)) {
50384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
50385 }
50386 arg1 = reinterpret_cast< wxSizer * >(argp1);
50387 {
50388 PyThreadState* __tstate = wxPyBeginAllowThreads();
50389 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
50390 wxPyEndAllowThreads(__tstate);
50391 if (PyErr_Occurred()) SWIG_fail;
50392 }
50393 {
50394 resultobj = wxPyMake_wxObject(result, 0);
50395 }
50396 return resultobj;
50397 fail:
50398 return NULL;
50399 }
50400
50401
50402 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50403 PyObject *resultobj = 0;
50404 wxSizer *arg1 = (wxSizer *) 0 ;
50405 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50406 wxSizerItem *result = 0 ;
50407 void *argp1 = 0 ;
50408 int res1 = 0 ;
50409 int res2 = 0 ;
50410 PyObject * obj0 = 0 ;
50411 PyObject * obj1 = 0 ;
50412 char * kwnames[] = {
50413 (char *) "self",(char *) "item", NULL
50414 };
50415
50416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50418 if (!SWIG_IsOK(res1)) {
50419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50420 }
50421 arg1 = reinterpret_cast< wxSizer * >(argp1);
50422 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50423 if (!SWIG_IsOK(res2)) {
50424 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50425 }
50426 {
50427 PyThreadState* __tstate = wxPyBeginAllowThreads();
50428 result = (wxSizerItem *)(arg1)->Add(arg2);
50429 wxPyEndAllowThreads(__tstate);
50430 if (PyErr_Occurred()) SWIG_fail;
50431 }
50432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50433 return resultobj;
50434 fail:
50435 return NULL;
50436 }
50437
50438
50439 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50440 PyObject *resultobj = 0;
50441 wxSizer *arg1 = (wxSizer *) 0 ;
50442 size_t arg2 ;
50443 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50444 wxSizerItem *result = 0 ;
50445 void *argp1 = 0 ;
50446 int res1 = 0 ;
50447 size_t val2 ;
50448 int ecode2 = 0 ;
50449 int res3 = 0 ;
50450 PyObject * obj0 = 0 ;
50451 PyObject * obj1 = 0 ;
50452 PyObject * obj2 = 0 ;
50453 char * kwnames[] = {
50454 (char *) "self",(char *) "index",(char *) "item", NULL
50455 };
50456
50457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50459 if (!SWIG_IsOK(res1)) {
50460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50461 }
50462 arg1 = reinterpret_cast< wxSizer * >(argp1);
50463 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50464 if (!SWIG_IsOK(ecode2)) {
50465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
50466 }
50467 arg2 = static_cast< size_t >(val2);
50468 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50469 if (!SWIG_IsOK(res3)) {
50470 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50471 }
50472 {
50473 PyThreadState* __tstate = wxPyBeginAllowThreads();
50474 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
50475 wxPyEndAllowThreads(__tstate);
50476 if (PyErr_Occurred()) SWIG_fail;
50477 }
50478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50479 return resultobj;
50480 fail:
50481 return NULL;
50482 }
50483
50484
50485 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50486 PyObject *resultobj = 0;
50487 wxSizer *arg1 = (wxSizer *) 0 ;
50488 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50489 wxSizerItem *result = 0 ;
50490 void *argp1 = 0 ;
50491 int res1 = 0 ;
50492 int res2 = 0 ;
50493 PyObject * obj0 = 0 ;
50494 PyObject * obj1 = 0 ;
50495 char * kwnames[] = {
50496 (char *) "self",(char *) "item", NULL
50497 };
50498
50499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
50500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50501 if (!SWIG_IsOK(res1)) {
50502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50503 }
50504 arg1 = reinterpret_cast< wxSizer * >(argp1);
50505 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50506 if (!SWIG_IsOK(res2)) {
50507 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50508 }
50509 {
50510 PyThreadState* __tstate = wxPyBeginAllowThreads();
50511 result = (wxSizerItem *)(arg1)->Prepend(arg2);
50512 wxPyEndAllowThreads(__tstate);
50513 if (PyErr_Occurred()) SWIG_fail;
50514 }
50515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50516 return resultobj;
50517 fail:
50518 return NULL;
50519 }
50520
50521
50522 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50523 PyObject *resultobj = 0;
50524 wxSizer *arg1 = (wxSizer *) 0 ;
50525 int arg2 ;
50526 int arg3 ;
50527 int arg4 ;
50528 int arg5 ;
50529 void *argp1 = 0 ;
50530 int res1 = 0 ;
50531 int val2 ;
50532 int ecode2 = 0 ;
50533 int val3 ;
50534 int ecode3 = 0 ;
50535 int val4 ;
50536 int ecode4 = 0 ;
50537 int val5 ;
50538 int ecode5 = 0 ;
50539 PyObject * obj0 = 0 ;
50540 PyObject * obj1 = 0 ;
50541 PyObject * obj2 = 0 ;
50542 PyObject * obj3 = 0 ;
50543 PyObject * obj4 = 0 ;
50544 char * kwnames[] = {
50545 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
50546 };
50547
50548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50550 if (!SWIG_IsOK(res1)) {
50551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
50552 }
50553 arg1 = reinterpret_cast< wxSizer * >(argp1);
50554 ecode2 = SWIG_AsVal_int(obj1, &val2);
50555 if (!SWIG_IsOK(ecode2)) {
50556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
50557 }
50558 arg2 = static_cast< int >(val2);
50559 ecode3 = SWIG_AsVal_int(obj2, &val3);
50560 if (!SWIG_IsOK(ecode3)) {
50561 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
50562 }
50563 arg3 = static_cast< int >(val3);
50564 ecode4 = SWIG_AsVal_int(obj3, &val4);
50565 if (!SWIG_IsOK(ecode4)) {
50566 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
50567 }
50568 arg4 = static_cast< int >(val4);
50569 ecode5 = SWIG_AsVal_int(obj4, &val5);
50570 if (!SWIG_IsOK(ecode5)) {
50571 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
50572 }
50573 arg5 = static_cast< int >(val5);
50574 {
50575 PyThreadState* __tstate = wxPyBeginAllowThreads();
50576 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
50577 wxPyEndAllowThreads(__tstate);
50578 if (PyErr_Occurred()) SWIG_fail;
50579 }
50580 resultobj = SWIG_Py_Void();
50581 return resultobj;
50582 fail:
50583 return NULL;
50584 }
50585
50586
50587 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50588 PyObject *resultobj = 0;
50589 wxSizer *arg1 = (wxSizer *) 0 ;
50590 wxSize *arg2 = 0 ;
50591 void *argp1 = 0 ;
50592 int res1 = 0 ;
50593 wxSize temp2 ;
50594 PyObject * obj0 = 0 ;
50595 PyObject * obj1 = 0 ;
50596 char * kwnames[] = {
50597 (char *) "self",(char *) "size", NULL
50598 };
50599
50600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
50601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50602 if (!SWIG_IsOK(res1)) {
50603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50604 }
50605 arg1 = reinterpret_cast< wxSizer * >(argp1);
50606 {
50607 arg2 = &temp2;
50608 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50609 }
50610 {
50611 PyThreadState* __tstate = wxPyBeginAllowThreads();
50612 (arg1)->SetMinSize((wxSize const &)*arg2);
50613 wxPyEndAllowThreads(__tstate);
50614 if (PyErr_Occurred()) SWIG_fail;
50615 }
50616 resultobj = SWIG_Py_Void();
50617 return resultobj;
50618 fail:
50619 return NULL;
50620 }
50621
50622
50623 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50624 PyObject *resultobj = 0;
50625 wxSizer *arg1 = (wxSizer *) 0 ;
50626 wxSize result;
50627 void *argp1 = 0 ;
50628 int res1 = 0 ;
50629 PyObject *swig_obj[1] ;
50630
50631 if (!args) SWIG_fail;
50632 swig_obj[0] = args;
50633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50634 if (!SWIG_IsOK(res1)) {
50635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50636 }
50637 arg1 = reinterpret_cast< wxSizer * >(argp1);
50638 {
50639 PyThreadState* __tstate = wxPyBeginAllowThreads();
50640 result = (arg1)->GetSize();
50641 wxPyEndAllowThreads(__tstate);
50642 if (PyErr_Occurred()) SWIG_fail;
50643 }
50644 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50645 return resultobj;
50646 fail:
50647 return NULL;
50648 }
50649
50650
50651 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50652 PyObject *resultobj = 0;
50653 wxSizer *arg1 = (wxSizer *) 0 ;
50654 wxPoint result;
50655 void *argp1 = 0 ;
50656 int res1 = 0 ;
50657 PyObject *swig_obj[1] ;
50658
50659 if (!args) SWIG_fail;
50660 swig_obj[0] = args;
50661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50662 if (!SWIG_IsOK(res1)) {
50663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
50664 }
50665 arg1 = reinterpret_cast< wxSizer * >(argp1);
50666 {
50667 PyThreadState* __tstate = wxPyBeginAllowThreads();
50668 result = (arg1)->GetPosition();
50669 wxPyEndAllowThreads(__tstate);
50670 if (PyErr_Occurred()) SWIG_fail;
50671 }
50672 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50673 return resultobj;
50674 fail:
50675 return NULL;
50676 }
50677
50678
50679 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50680 PyObject *resultobj = 0;
50681 wxSizer *arg1 = (wxSizer *) 0 ;
50682 wxSize result;
50683 void *argp1 = 0 ;
50684 int res1 = 0 ;
50685 PyObject *swig_obj[1] ;
50686
50687 if (!args) SWIG_fail;
50688 swig_obj[0] = args;
50689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50690 if (!SWIG_IsOK(res1)) {
50691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50692 }
50693 arg1 = reinterpret_cast< wxSizer * >(argp1);
50694 {
50695 PyThreadState* __tstate = wxPyBeginAllowThreads();
50696 result = (arg1)->GetMinSize();
50697 wxPyEndAllowThreads(__tstate);
50698 if (PyErr_Occurred()) SWIG_fail;
50699 }
50700 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50701 return resultobj;
50702 fail:
50703 return NULL;
50704 }
50705
50706
50707 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50708 PyObject *resultobj = 0;
50709 wxSizer *arg1 = (wxSizer *) 0 ;
50710 void *argp1 = 0 ;
50711 int res1 = 0 ;
50712 PyObject *swig_obj[1] ;
50713
50714 if (!args) SWIG_fail;
50715 swig_obj[0] = args;
50716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50717 if (!SWIG_IsOK(res1)) {
50718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
50719 }
50720 arg1 = reinterpret_cast< wxSizer * >(argp1);
50721 {
50722 PyThreadState* __tstate = wxPyBeginAllowThreads();
50723 (arg1)->RecalcSizes();
50724 wxPyEndAllowThreads(__tstate);
50725 if (PyErr_Occurred()) SWIG_fail;
50726 }
50727 resultobj = SWIG_Py_Void();
50728 return resultobj;
50729 fail:
50730 return NULL;
50731 }
50732
50733
50734 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50735 PyObject *resultobj = 0;
50736 wxSizer *arg1 = (wxSizer *) 0 ;
50737 wxSize result;
50738 void *argp1 = 0 ;
50739 int res1 = 0 ;
50740 PyObject *swig_obj[1] ;
50741
50742 if (!args) SWIG_fail;
50743 swig_obj[0] = args;
50744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50745 if (!SWIG_IsOK(res1)) {
50746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
50747 }
50748 arg1 = reinterpret_cast< wxSizer * >(argp1);
50749 {
50750 PyThreadState* __tstate = wxPyBeginAllowThreads();
50751 result = (arg1)->CalcMin();
50752 wxPyEndAllowThreads(__tstate);
50753 if (PyErr_Occurred()) SWIG_fail;
50754 }
50755 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50756 return resultobj;
50757 fail:
50758 return NULL;
50759 }
50760
50761
50762 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50763 PyObject *resultobj = 0;
50764 wxSizer *arg1 = (wxSizer *) 0 ;
50765 void *argp1 = 0 ;
50766 int res1 = 0 ;
50767 PyObject *swig_obj[1] ;
50768
50769 if (!args) SWIG_fail;
50770 swig_obj[0] = args;
50771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50772 if (!SWIG_IsOK(res1)) {
50773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
50774 }
50775 arg1 = reinterpret_cast< wxSizer * >(argp1);
50776 {
50777 PyThreadState* __tstate = wxPyBeginAllowThreads();
50778 (arg1)->Layout();
50779 wxPyEndAllowThreads(__tstate);
50780 if (PyErr_Occurred()) SWIG_fail;
50781 }
50782 resultobj = SWIG_Py_Void();
50783 return resultobj;
50784 fail:
50785 return NULL;
50786 }
50787
50788
50789 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50790 PyObject *resultobj = 0;
50791 wxSizer *arg1 = (wxSizer *) 0 ;
50792 wxWindow *arg2 = (wxWindow *) 0 ;
50793 wxSize result;
50794 void *argp1 = 0 ;
50795 int res1 = 0 ;
50796 void *argp2 = 0 ;
50797 int res2 = 0 ;
50798 PyObject * obj0 = 0 ;
50799 PyObject * obj1 = 0 ;
50800 char * kwnames[] = {
50801 (char *) "self",(char *) "window", NULL
50802 };
50803
50804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
50805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50806 if (!SWIG_IsOK(res1)) {
50807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
50808 }
50809 arg1 = reinterpret_cast< wxSizer * >(argp1);
50810 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50811 if (!SWIG_IsOK(res2)) {
50812 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
50813 }
50814 arg2 = reinterpret_cast< wxWindow * >(argp2);
50815 {
50816 PyThreadState* __tstate = wxPyBeginAllowThreads();
50817 result = (arg1)->Fit(arg2);
50818 wxPyEndAllowThreads(__tstate);
50819 if (PyErr_Occurred()) SWIG_fail;
50820 }
50821 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50822 return resultobj;
50823 fail:
50824 return NULL;
50825 }
50826
50827
50828 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50829 PyObject *resultobj = 0;
50830 wxSizer *arg1 = (wxSizer *) 0 ;
50831 wxWindow *arg2 = (wxWindow *) 0 ;
50832 void *argp1 = 0 ;
50833 int res1 = 0 ;
50834 void *argp2 = 0 ;
50835 int res2 = 0 ;
50836 PyObject * obj0 = 0 ;
50837 PyObject * obj1 = 0 ;
50838 char * kwnames[] = {
50839 (char *) "self",(char *) "window", NULL
50840 };
50841
50842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
50843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50844 if (!SWIG_IsOK(res1)) {
50845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
50846 }
50847 arg1 = reinterpret_cast< wxSizer * >(argp1);
50848 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50849 if (!SWIG_IsOK(res2)) {
50850 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
50851 }
50852 arg2 = reinterpret_cast< wxWindow * >(argp2);
50853 {
50854 PyThreadState* __tstate = wxPyBeginAllowThreads();
50855 (arg1)->FitInside(arg2);
50856 wxPyEndAllowThreads(__tstate);
50857 if (PyErr_Occurred()) SWIG_fail;
50858 }
50859 resultobj = SWIG_Py_Void();
50860 return resultobj;
50861 fail:
50862 return NULL;
50863 }
50864
50865
50866 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50867 PyObject *resultobj = 0;
50868 wxSizer *arg1 = (wxSizer *) 0 ;
50869 wxWindow *arg2 = (wxWindow *) 0 ;
50870 void *argp1 = 0 ;
50871 int res1 = 0 ;
50872 void *argp2 = 0 ;
50873 int res2 = 0 ;
50874 PyObject * obj0 = 0 ;
50875 PyObject * obj1 = 0 ;
50876 char * kwnames[] = {
50877 (char *) "self",(char *) "window", NULL
50878 };
50879
50880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50882 if (!SWIG_IsOK(res1)) {
50883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50884 }
50885 arg1 = reinterpret_cast< wxSizer * >(argp1);
50886 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50887 if (!SWIG_IsOK(res2)) {
50888 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50889 }
50890 arg2 = reinterpret_cast< wxWindow * >(argp2);
50891 {
50892 PyThreadState* __tstate = wxPyBeginAllowThreads();
50893 (arg1)->SetSizeHints(arg2);
50894 wxPyEndAllowThreads(__tstate);
50895 if (PyErr_Occurred()) SWIG_fail;
50896 }
50897 resultobj = SWIG_Py_Void();
50898 return resultobj;
50899 fail:
50900 return NULL;
50901 }
50902
50903
50904 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50905 PyObject *resultobj = 0;
50906 wxSizer *arg1 = (wxSizer *) 0 ;
50907 wxWindow *arg2 = (wxWindow *) 0 ;
50908 void *argp1 = 0 ;
50909 int res1 = 0 ;
50910 void *argp2 = 0 ;
50911 int res2 = 0 ;
50912 PyObject * obj0 = 0 ;
50913 PyObject * obj1 = 0 ;
50914 char * kwnames[] = {
50915 (char *) "self",(char *) "window", NULL
50916 };
50917
50918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50920 if (!SWIG_IsOK(res1)) {
50921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50922 }
50923 arg1 = reinterpret_cast< wxSizer * >(argp1);
50924 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50925 if (!SWIG_IsOK(res2)) {
50926 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50927 }
50928 arg2 = reinterpret_cast< wxWindow * >(argp2);
50929 {
50930 PyThreadState* __tstate = wxPyBeginAllowThreads();
50931 (arg1)->SetVirtualSizeHints(arg2);
50932 wxPyEndAllowThreads(__tstate);
50933 if (PyErr_Occurred()) SWIG_fail;
50934 }
50935 resultobj = SWIG_Py_Void();
50936 return resultobj;
50937 fail:
50938 return NULL;
50939 }
50940
50941
50942 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50943 PyObject *resultobj = 0;
50944 wxSizer *arg1 = (wxSizer *) 0 ;
50945 bool arg2 = (bool) false ;
50946 void *argp1 = 0 ;
50947 int res1 = 0 ;
50948 bool val2 ;
50949 int ecode2 = 0 ;
50950 PyObject * obj0 = 0 ;
50951 PyObject * obj1 = 0 ;
50952 char * kwnames[] = {
50953 (char *) "self",(char *) "deleteWindows", NULL
50954 };
50955
50956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
50957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50958 if (!SWIG_IsOK(res1)) {
50959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
50960 }
50961 arg1 = reinterpret_cast< wxSizer * >(argp1);
50962 if (obj1) {
50963 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50964 if (!SWIG_IsOK(ecode2)) {
50965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
50966 }
50967 arg2 = static_cast< bool >(val2);
50968 }
50969 {
50970 PyThreadState* __tstate = wxPyBeginAllowThreads();
50971 (arg1)->Clear(arg2);
50972 wxPyEndAllowThreads(__tstate);
50973 if (PyErr_Occurred()) SWIG_fail;
50974 }
50975 resultobj = SWIG_Py_Void();
50976 return resultobj;
50977 fail:
50978 return NULL;
50979 }
50980
50981
50982 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50983 PyObject *resultobj = 0;
50984 wxSizer *arg1 = (wxSizer *) 0 ;
50985 void *argp1 = 0 ;
50986 int res1 = 0 ;
50987 PyObject *swig_obj[1] ;
50988
50989 if (!args) SWIG_fail;
50990 swig_obj[0] = args;
50991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50992 if (!SWIG_IsOK(res1)) {
50993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
50994 }
50995 arg1 = reinterpret_cast< wxSizer * >(argp1);
50996 {
50997 PyThreadState* __tstate = wxPyBeginAllowThreads();
50998 (arg1)->DeleteWindows();
50999 wxPyEndAllowThreads(__tstate);
51000 if (PyErr_Occurred()) SWIG_fail;
51001 }
51002 resultobj = SWIG_Py_Void();
51003 return resultobj;
51004 fail:
51005 return NULL;
51006 }
51007
51008
51009 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51010 PyObject *resultobj = 0;
51011 wxSizer *arg1 = (wxSizer *) 0 ;
51012 PyObject *result = 0 ;
51013 void *argp1 = 0 ;
51014 int res1 = 0 ;
51015 PyObject *swig_obj[1] ;
51016
51017 if (!args) SWIG_fail;
51018 swig_obj[0] = args;
51019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51020 if (!SWIG_IsOK(res1)) {
51021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
51022 }
51023 arg1 = reinterpret_cast< wxSizer * >(argp1);
51024 {
51025 PyThreadState* __tstate = wxPyBeginAllowThreads();
51026 result = (PyObject *)wxSizer_GetChildren(arg1);
51027 wxPyEndAllowThreads(__tstate);
51028 if (PyErr_Occurred()) SWIG_fail;
51029 }
51030 resultobj = result;
51031 return resultobj;
51032 fail:
51033 return NULL;
51034 }
51035
51036
51037 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51038 PyObject *resultobj = 0;
51039 wxSizer *arg1 = (wxSizer *) 0 ;
51040 PyObject *arg2 = (PyObject *) 0 ;
51041 bool arg3 = (bool) true ;
51042 bool arg4 = (bool) false ;
51043 bool result;
51044 void *argp1 = 0 ;
51045 int res1 = 0 ;
51046 bool val3 ;
51047 int ecode3 = 0 ;
51048 bool val4 ;
51049 int ecode4 = 0 ;
51050 PyObject * obj0 = 0 ;
51051 PyObject * obj1 = 0 ;
51052 PyObject * obj2 = 0 ;
51053 PyObject * obj3 = 0 ;
51054 char * kwnames[] = {
51055 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
51056 };
51057
51058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51060 if (!SWIG_IsOK(res1)) {
51061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
51062 }
51063 arg1 = reinterpret_cast< wxSizer * >(argp1);
51064 arg2 = obj1;
51065 if (obj2) {
51066 ecode3 = SWIG_AsVal_bool(obj2, &val3);
51067 if (!SWIG_IsOK(ecode3)) {
51068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
51069 }
51070 arg3 = static_cast< bool >(val3);
51071 }
51072 if (obj3) {
51073 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51074 if (!SWIG_IsOK(ecode4)) {
51075 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
51076 }
51077 arg4 = static_cast< bool >(val4);
51078 }
51079 {
51080 PyThreadState* __tstate = wxPyBeginAllowThreads();
51081 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
51082 wxPyEndAllowThreads(__tstate);
51083 if (PyErr_Occurred()) SWIG_fail;
51084 }
51085 {
51086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51087 }
51088 return resultobj;
51089 fail:
51090 return NULL;
51091 }
51092
51093
51094 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51095 PyObject *resultobj = 0;
51096 wxSizer *arg1 = (wxSizer *) 0 ;
51097 PyObject *arg2 = (PyObject *) 0 ;
51098 bool result;
51099 void *argp1 = 0 ;
51100 int res1 = 0 ;
51101 PyObject * obj0 = 0 ;
51102 PyObject * obj1 = 0 ;
51103 char * kwnames[] = {
51104 (char *) "self",(char *) "item", NULL
51105 };
51106
51107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
51108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51109 if (!SWIG_IsOK(res1)) {
51110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
51111 }
51112 arg1 = reinterpret_cast< wxSizer * >(argp1);
51113 arg2 = obj1;
51114 {
51115 PyThreadState* __tstate = wxPyBeginAllowThreads();
51116 result = (bool)wxSizer_IsShown(arg1,arg2);
51117 wxPyEndAllowThreads(__tstate);
51118 if (PyErr_Occurred()) SWIG_fail;
51119 }
51120 {
51121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51122 }
51123 return resultobj;
51124 fail:
51125 return NULL;
51126 }
51127
51128
51129 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51130 PyObject *resultobj = 0;
51131 wxSizer *arg1 = (wxSizer *) 0 ;
51132 bool arg2 ;
51133 void *argp1 = 0 ;
51134 int res1 = 0 ;
51135 bool val2 ;
51136 int ecode2 = 0 ;
51137 PyObject * obj0 = 0 ;
51138 PyObject * obj1 = 0 ;
51139 char * kwnames[] = {
51140 (char *) "self",(char *) "show", NULL
51141 };
51142
51143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
51144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51145 if (!SWIG_IsOK(res1)) {
51146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
51147 }
51148 arg1 = reinterpret_cast< wxSizer * >(argp1);
51149 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51150 if (!SWIG_IsOK(ecode2)) {
51151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
51152 }
51153 arg2 = static_cast< bool >(val2);
51154 {
51155 PyThreadState* __tstate = wxPyBeginAllowThreads();
51156 (arg1)->ShowItems(arg2);
51157 wxPyEndAllowThreads(__tstate);
51158 if (PyErr_Occurred()) SWIG_fail;
51159 }
51160 resultobj = SWIG_Py_Void();
51161 return resultobj;
51162 fail:
51163 return NULL;
51164 }
51165
51166
51167 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51168 PyObject *obj;
51169 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51170 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
51171 return SWIG_Py_Void();
51172 }
51173
51174 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51175 PyObject *resultobj = 0;
51176 wxPySizer *result = 0 ;
51177
51178 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
51179 {
51180 PyThreadState* __tstate = wxPyBeginAllowThreads();
51181 result = (wxPySizer *)new wxPySizer();
51182 wxPyEndAllowThreads(__tstate);
51183 if (PyErr_Occurred()) SWIG_fail;
51184 }
51185 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
51186 return resultobj;
51187 fail:
51188 return NULL;
51189 }
51190
51191
51192 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51193 PyObject *resultobj = 0;
51194 wxPySizer *arg1 = (wxPySizer *) 0 ;
51195 PyObject *arg2 = (PyObject *) 0 ;
51196 PyObject *arg3 = (PyObject *) 0 ;
51197 void *argp1 = 0 ;
51198 int res1 = 0 ;
51199 PyObject * obj0 = 0 ;
51200 PyObject * obj1 = 0 ;
51201 PyObject * obj2 = 0 ;
51202 char * kwnames[] = {
51203 (char *) "self",(char *) "self",(char *) "_class", NULL
51204 };
51205
51206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
51208 if (!SWIG_IsOK(res1)) {
51209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
51210 }
51211 arg1 = reinterpret_cast< wxPySizer * >(argp1);
51212 arg2 = obj1;
51213 arg3 = obj2;
51214 {
51215 PyThreadState* __tstate = wxPyBeginAllowThreads();
51216 (arg1)->_setCallbackInfo(arg2,arg3);
51217 wxPyEndAllowThreads(__tstate);
51218 if (PyErr_Occurred()) SWIG_fail;
51219 }
51220 resultobj = SWIG_Py_Void();
51221 return resultobj;
51222 fail:
51223 return NULL;
51224 }
51225
51226
51227 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51228 PyObject *obj;
51229 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51230 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
51231 return SWIG_Py_Void();
51232 }
51233
51234 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51235 return SWIG_Python_InitShadowInstance(args);
51236 }
51237
51238 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51239 PyObject *resultobj = 0;
51240 int arg1 = (int) wxHORIZONTAL ;
51241 wxBoxSizer *result = 0 ;
51242 int val1 ;
51243 int ecode1 = 0 ;
51244 PyObject * obj0 = 0 ;
51245 char * kwnames[] = {
51246 (char *) "orient", NULL
51247 };
51248
51249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
51250 if (obj0) {
51251 ecode1 = SWIG_AsVal_int(obj0, &val1);
51252 if (!SWIG_IsOK(ecode1)) {
51253 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
51254 }
51255 arg1 = static_cast< int >(val1);
51256 }
51257 {
51258 PyThreadState* __tstate = wxPyBeginAllowThreads();
51259 result = (wxBoxSizer *)new wxBoxSizer(arg1);
51260 wxPyEndAllowThreads(__tstate);
51261 if (PyErr_Occurred()) SWIG_fail;
51262 }
51263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
51264 return resultobj;
51265 fail:
51266 return NULL;
51267 }
51268
51269
51270 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51271 PyObject *resultobj = 0;
51272 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51273 int result;
51274 void *argp1 = 0 ;
51275 int res1 = 0 ;
51276 PyObject *swig_obj[1] ;
51277
51278 if (!args) SWIG_fail;
51279 swig_obj[0] = args;
51280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51281 if (!SWIG_IsOK(res1)) {
51282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51283 }
51284 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51285 {
51286 PyThreadState* __tstate = wxPyBeginAllowThreads();
51287 result = (int)(arg1)->GetOrientation();
51288 wxPyEndAllowThreads(__tstate);
51289 if (PyErr_Occurred()) SWIG_fail;
51290 }
51291 resultobj = SWIG_From_int(static_cast< int >(result));
51292 return resultobj;
51293 fail:
51294 return NULL;
51295 }
51296
51297
51298 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51299 PyObject *resultobj = 0;
51300 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51301 int arg2 ;
51302 void *argp1 = 0 ;
51303 int res1 = 0 ;
51304 int val2 ;
51305 int ecode2 = 0 ;
51306 PyObject * obj0 = 0 ;
51307 PyObject * obj1 = 0 ;
51308 char * kwnames[] = {
51309 (char *) "self",(char *) "orient", NULL
51310 };
51311
51312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
51313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51314 if (!SWIG_IsOK(res1)) {
51315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51316 }
51317 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51318 ecode2 = SWIG_AsVal_int(obj1, &val2);
51319 if (!SWIG_IsOK(ecode2)) {
51320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
51321 }
51322 arg2 = static_cast< int >(val2);
51323 {
51324 PyThreadState* __tstate = wxPyBeginAllowThreads();
51325 (arg1)->SetOrientation(arg2);
51326 wxPyEndAllowThreads(__tstate);
51327 if (PyErr_Occurred()) SWIG_fail;
51328 }
51329 resultobj = SWIG_Py_Void();
51330 return resultobj;
51331 fail:
51332 return NULL;
51333 }
51334
51335
51336 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51337 PyObject *obj;
51338 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51339 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
51340 return SWIG_Py_Void();
51341 }
51342
51343 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51344 return SWIG_Python_InitShadowInstance(args);
51345 }
51346
51347 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51348 PyObject *resultobj = 0;
51349 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
51350 int arg2 = (int) wxHORIZONTAL ;
51351 wxStaticBoxSizer *result = 0 ;
51352 void *argp1 = 0 ;
51353 int res1 = 0 ;
51354 int val2 ;
51355 int ecode2 = 0 ;
51356 PyObject * obj0 = 0 ;
51357 PyObject * obj1 = 0 ;
51358 char * kwnames[] = {
51359 (char *) "box",(char *) "orient", NULL
51360 };
51361
51362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
51364 if (!SWIG_IsOK(res1)) {
51365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
51366 }
51367 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
51368 if (obj1) {
51369 ecode2 = SWIG_AsVal_int(obj1, &val2);
51370 if (!SWIG_IsOK(ecode2)) {
51371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
51372 }
51373 arg2 = static_cast< int >(val2);
51374 }
51375 {
51376 PyThreadState* __tstate = wxPyBeginAllowThreads();
51377 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
51378 wxPyEndAllowThreads(__tstate);
51379 if (PyErr_Occurred()) SWIG_fail;
51380 }
51381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
51382 return resultobj;
51383 fail:
51384 return NULL;
51385 }
51386
51387
51388 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51389 PyObject *resultobj = 0;
51390 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
51391 wxStaticBox *result = 0 ;
51392 void *argp1 = 0 ;
51393 int res1 = 0 ;
51394 PyObject *swig_obj[1] ;
51395
51396 if (!args) SWIG_fail;
51397 swig_obj[0] = args;
51398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
51399 if (!SWIG_IsOK(res1)) {
51400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
51401 }
51402 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
51403 {
51404 PyThreadState* __tstate = wxPyBeginAllowThreads();
51405 result = (wxStaticBox *)(arg1)->GetStaticBox();
51406 wxPyEndAllowThreads(__tstate);
51407 if (PyErr_Occurred()) SWIG_fail;
51408 }
51409 {
51410 resultobj = wxPyMake_wxObject(result, (bool)0);
51411 }
51412 return resultobj;
51413 fail:
51414 return NULL;
51415 }
51416
51417
51418 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51419 PyObject *obj;
51420 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51421 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
51422 return SWIG_Py_Void();
51423 }
51424
51425 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51426 return SWIG_Python_InitShadowInstance(args);
51427 }
51428
51429 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51430 PyObject *resultobj = 0;
51431 int arg1 = (int) 1 ;
51432 int arg2 = (int) 0 ;
51433 int arg3 = (int) 0 ;
51434 int arg4 = (int) 0 ;
51435 wxGridSizer *result = 0 ;
51436 int val1 ;
51437 int ecode1 = 0 ;
51438 int val2 ;
51439 int ecode2 = 0 ;
51440 int val3 ;
51441 int ecode3 = 0 ;
51442 int val4 ;
51443 int ecode4 = 0 ;
51444 PyObject * obj0 = 0 ;
51445 PyObject * obj1 = 0 ;
51446 PyObject * obj2 = 0 ;
51447 PyObject * obj3 = 0 ;
51448 char * kwnames[] = {
51449 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51450 };
51451
51452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51453 if (obj0) {
51454 ecode1 = SWIG_AsVal_int(obj0, &val1);
51455 if (!SWIG_IsOK(ecode1)) {
51456 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
51457 }
51458 arg1 = static_cast< int >(val1);
51459 }
51460 if (obj1) {
51461 ecode2 = SWIG_AsVal_int(obj1, &val2);
51462 if (!SWIG_IsOK(ecode2)) {
51463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
51464 }
51465 arg2 = static_cast< int >(val2);
51466 }
51467 if (obj2) {
51468 ecode3 = SWIG_AsVal_int(obj2, &val3);
51469 if (!SWIG_IsOK(ecode3)) {
51470 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
51471 }
51472 arg3 = static_cast< int >(val3);
51473 }
51474 if (obj3) {
51475 ecode4 = SWIG_AsVal_int(obj3, &val4);
51476 if (!SWIG_IsOK(ecode4)) {
51477 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
51478 }
51479 arg4 = static_cast< int >(val4);
51480 }
51481 {
51482 PyThreadState* __tstate = wxPyBeginAllowThreads();
51483 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
51484 wxPyEndAllowThreads(__tstate);
51485 if (PyErr_Occurred()) SWIG_fail;
51486 }
51487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
51488 return resultobj;
51489 fail:
51490 return NULL;
51491 }
51492
51493
51494 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51495 PyObject *resultobj = 0;
51496 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51497 int arg2 ;
51498 void *argp1 = 0 ;
51499 int res1 = 0 ;
51500 int val2 ;
51501 int ecode2 = 0 ;
51502 PyObject * obj0 = 0 ;
51503 PyObject * obj1 = 0 ;
51504 char * kwnames[] = {
51505 (char *) "self",(char *) "cols", NULL
51506 };
51507
51508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
51509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51510 if (!SWIG_IsOK(res1)) {
51511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51512 }
51513 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51514 ecode2 = SWIG_AsVal_int(obj1, &val2);
51515 if (!SWIG_IsOK(ecode2)) {
51516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
51517 }
51518 arg2 = static_cast< int >(val2);
51519 {
51520 PyThreadState* __tstate = wxPyBeginAllowThreads();
51521 (arg1)->SetCols(arg2);
51522 wxPyEndAllowThreads(__tstate);
51523 if (PyErr_Occurred()) SWIG_fail;
51524 }
51525 resultobj = SWIG_Py_Void();
51526 return resultobj;
51527 fail:
51528 return NULL;
51529 }
51530
51531
51532 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51533 PyObject *resultobj = 0;
51534 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51535 int arg2 ;
51536 void *argp1 = 0 ;
51537 int res1 = 0 ;
51538 int val2 ;
51539 int ecode2 = 0 ;
51540 PyObject * obj0 = 0 ;
51541 PyObject * obj1 = 0 ;
51542 char * kwnames[] = {
51543 (char *) "self",(char *) "rows", NULL
51544 };
51545
51546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
51547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51548 if (!SWIG_IsOK(res1)) {
51549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51550 }
51551 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51552 ecode2 = SWIG_AsVal_int(obj1, &val2);
51553 if (!SWIG_IsOK(ecode2)) {
51554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
51555 }
51556 arg2 = static_cast< int >(val2);
51557 {
51558 PyThreadState* __tstate = wxPyBeginAllowThreads();
51559 (arg1)->SetRows(arg2);
51560 wxPyEndAllowThreads(__tstate);
51561 if (PyErr_Occurred()) SWIG_fail;
51562 }
51563 resultobj = SWIG_Py_Void();
51564 return resultobj;
51565 fail:
51566 return NULL;
51567 }
51568
51569
51570 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51571 PyObject *resultobj = 0;
51572 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51573 int arg2 ;
51574 void *argp1 = 0 ;
51575 int res1 = 0 ;
51576 int val2 ;
51577 int ecode2 = 0 ;
51578 PyObject * obj0 = 0 ;
51579 PyObject * obj1 = 0 ;
51580 char * kwnames[] = {
51581 (char *) "self",(char *) "gap", NULL
51582 };
51583
51584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
51585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51586 if (!SWIG_IsOK(res1)) {
51587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51588 }
51589 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51590 ecode2 = SWIG_AsVal_int(obj1, &val2);
51591 if (!SWIG_IsOK(ecode2)) {
51592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
51593 }
51594 arg2 = static_cast< int >(val2);
51595 {
51596 PyThreadState* __tstate = wxPyBeginAllowThreads();
51597 (arg1)->SetVGap(arg2);
51598 wxPyEndAllowThreads(__tstate);
51599 if (PyErr_Occurred()) SWIG_fail;
51600 }
51601 resultobj = SWIG_Py_Void();
51602 return resultobj;
51603 fail:
51604 return NULL;
51605 }
51606
51607
51608 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51609 PyObject *resultobj = 0;
51610 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51611 int arg2 ;
51612 void *argp1 = 0 ;
51613 int res1 = 0 ;
51614 int val2 ;
51615 int ecode2 = 0 ;
51616 PyObject * obj0 = 0 ;
51617 PyObject * obj1 = 0 ;
51618 char * kwnames[] = {
51619 (char *) "self",(char *) "gap", NULL
51620 };
51621
51622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
51623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51624 if (!SWIG_IsOK(res1)) {
51625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51626 }
51627 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51628 ecode2 = SWIG_AsVal_int(obj1, &val2);
51629 if (!SWIG_IsOK(ecode2)) {
51630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
51631 }
51632 arg2 = static_cast< int >(val2);
51633 {
51634 PyThreadState* __tstate = wxPyBeginAllowThreads();
51635 (arg1)->SetHGap(arg2);
51636 wxPyEndAllowThreads(__tstate);
51637 if (PyErr_Occurred()) SWIG_fail;
51638 }
51639 resultobj = SWIG_Py_Void();
51640 return resultobj;
51641 fail:
51642 return NULL;
51643 }
51644
51645
51646 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51647 PyObject *resultobj = 0;
51648 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51649 int result;
51650 void *argp1 = 0 ;
51651 int res1 = 0 ;
51652 PyObject *swig_obj[1] ;
51653
51654 if (!args) SWIG_fail;
51655 swig_obj[0] = args;
51656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51657 if (!SWIG_IsOK(res1)) {
51658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51659 }
51660 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51661 {
51662 PyThreadState* __tstate = wxPyBeginAllowThreads();
51663 result = (int)(arg1)->GetCols();
51664 wxPyEndAllowThreads(__tstate);
51665 if (PyErr_Occurred()) SWIG_fail;
51666 }
51667 resultobj = SWIG_From_int(static_cast< int >(result));
51668 return resultobj;
51669 fail:
51670 return NULL;
51671 }
51672
51673
51674 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51675 PyObject *resultobj = 0;
51676 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51677 int result;
51678 void *argp1 = 0 ;
51679 int res1 = 0 ;
51680 PyObject *swig_obj[1] ;
51681
51682 if (!args) SWIG_fail;
51683 swig_obj[0] = args;
51684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51685 if (!SWIG_IsOK(res1)) {
51686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51687 }
51688 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51689 {
51690 PyThreadState* __tstate = wxPyBeginAllowThreads();
51691 result = (int)(arg1)->GetRows();
51692 wxPyEndAllowThreads(__tstate);
51693 if (PyErr_Occurred()) SWIG_fail;
51694 }
51695 resultobj = SWIG_From_int(static_cast< int >(result));
51696 return resultobj;
51697 fail:
51698 return NULL;
51699 }
51700
51701
51702 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51703 PyObject *resultobj = 0;
51704 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51705 int result;
51706 void *argp1 = 0 ;
51707 int res1 = 0 ;
51708 PyObject *swig_obj[1] ;
51709
51710 if (!args) SWIG_fail;
51711 swig_obj[0] = args;
51712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51713 if (!SWIG_IsOK(res1)) {
51714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51715 }
51716 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51717 {
51718 PyThreadState* __tstate = wxPyBeginAllowThreads();
51719 result = (int)(arg1)->GetVGap();
51720 wxPyEndAllowThreads(__tstate);
51721 if (PyErr_Occurred()) SWIG_fail;
51722 }
51723 resultobj = SWIG_From_int(static_cast< int >(result));
51724 return resultobj;
51725 fail:
51726 return NULL;
51727 }
51728
51729
51730 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51731 PyObject *resultobj = 0;
51732 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51733 int result;
51734 void *argp1 = 0 ;
51735 int res1 = 0 ;
51736 PyObject *swig_obj[1] ;
51737
51738 if (!args) SWIG_fail;
51739 swig_obj[0] = args;
51740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51741 if (!SWIG_IsOK(res1)) {
51742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51743 }
51744 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51745 {
51746 PyThreadState* __tstate = wxPyBeginAllowThreads();
51747 result = (int)(arg1)->GetHGap();
51748 wxPyEndAllowThreads(__tstate);
51749 if (PyErr_Occurred()) SWIG_fail;
51750 }
51751 resultobj = SWIG_From_int(static_cast< int >(result));
51752 return resultobj;
51753 fail:
51754 return NULL;
51755 }
51756
51757
51758 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51759 PyObject *obj;
51760 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51761 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
51762 return SWIG_Py_Void();
51763 }
51764
51765 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51766 return SWIG_Python_InitShadowInstance(args);
51767 }
51768
51769 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51770 PyObject *resultobj = 0;
51771 int arg1 = (int) 1 ;
51772 int arg2 = (int) 0 ;
51773 int arg3 = (int) 0 ;
51774 int arg4 = (int) 0 ;
51775 wxFlexGridSizer *result = 0 ;
51776 int val1 ;
51777 int ecode1 = 0 ;
51778 int val2 ;
51779 int ecode2 = 0 ;
51780 int val3 ;
51781 int ecode3 = 0 ;
51782 int val4 ;
51783 int ecode4 = 0 ;
51784 PyObject * obj0 = 0 ;
51785 PyObject * obj1 = 0 ;
51786 PyObject * obj2 = 0 ;
51787 PyObject * obj3 = 0 ;
51788 char * kwnames[] = {
51789 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51790 };
51791
51792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51793 if (obj0) {
51794 ecode1 = SWIG_AsVal_int(obj0, &val1);
51795 if (!SWIG_IsOK(ecode1)) {
51796 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
51797 }
51798 arg1 = static_cast< int >(val1);
51799 }
51800 if (obj1) {
51801 ecode2 = SWIG_AsVal_int(obj1, &val2);
51802 if (!SWIG_IsOK(ecode2)) {
51803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
51804 }
51805 arg2 = static_cast< int >(val2);
51806 }
51807 if (obj2) {
51808 ecode3 = SWIG_AsVal_int(obj2, &val3);
51809 if (!SWIG_IsOK(ecode3)) {
51810 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
51811 }
51812 arg3 = static_cast< int >(val3);
51813 }
51814 if (obj3) {
51815 ecode4 = SWIG_AsVal_int(obj3, &val4);
51816 if (!SWIG_IsOK(ecode4)) {
51817 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
51818 }
51819 arg4 = static_cast< int >(val4);
51820 }
51821 {
51822 PyThreadState* __tstate = wxPyBeginAllowThreads();
51823 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
51824 wxPyEndAllowThreads(__tstate);
51825 if (PyErr_Occurred()) SWIG_fail;
51826 }
51827 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
51828 return resultobj;
51829 fail:
51830 return NULL;
51831 }
51832
51833
51834 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51835 PyObject *resultobj = 0;
51836 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51837 size_t arg2 ;
51838 int arg3 = (int) 0 ;
51839 void *argp1 = 0 ;
51840 int res1 = 0 ;
51841 size_t val2 ;
51842 int ecode2 = 0 ;
51843 int val3 ;
51844 int ecode3 = 0 ;
51845 PyObject * obj0 = 0 ;
51846 PyObject * obj1 = 0 ;
51847 PyObject * obj2 = 0 ;
51848 char * kwnames[] = {
51849 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51850 };
51851
51852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51854 if (!SWIG_IsOK(res1)) {
51855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51856 }
51857 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51858 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51859 if (!SWIG_IsOK(ecode2)) {
51860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51861 }
51862 arg2 = static_cast< size_t >(val2);
51863 if (obj2) {
51864 ecode3 = SWIG_AsVal_int(obj2, &val3);
51865 if (!SWIG_IsOK(ecode3)) {
51866 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
51867 }
51868 arg3 = static_cast< int >(val3);
51869 }
51870 {
51871 PyThreadState* __tstate = wxPyBeginAllowThreads();
51872 (arg1)->AddGrowableRow(arg2,arg3);
51873 wxPyEndAllowThreads(__tstate);
51874 if (PyErr_Occurred()) SWIG_fail;
51875 }
51876 resultobj = SWIG_Py_Void();
51877 return resultobj;
51878 fail:
51879 return NULL;
51880 }
51881
51882
51883 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51884 PyObject *resultobj = 0;
51885 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51886 size_t arg2 ;
51887 void *argp1 = 0 ;
51888 int res1 = 0 ;
51889 size_t val2 ;
51890 int ecode2 = 0 ;
51891 PyObject * obj0 = 0 ;
51892 PyObject * obj1 = 0 ;
51893 char * kwnames[] = {
51894 (char *) "self",(char *) "idx", NULL
51895 };
51896
51897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
51898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51899 if (!SWIG_IsOK(res1)) {
51900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51901 }
51902 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51903 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51904 if (!SWIG_IsOK(ecode2)) {
51905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51906 }
51907 arg2 = static_cast< size_t >(val2);
51908 {
51909 PyThreadState* __tstate = wxPyBeginAllowThreads();
51910 (arg1)->RemoveGrowableRow(arg2);
51911 wxPyEndAllowThreads(__tstate);
51912 if (PyErr_Occurred()) SWIG_fail;
51913 }
51914 resultobj = SWIG_Py_Void();
51915 return resultobj;
51916 fail:
51917 return NULL;
51918 }
51919
51920
51921 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51922 PyObject *resultobj = 0;
51923 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51924 size_t arg2 ;
51925 int arg3 = (int) 0 ;
51926 void *argp1 = 0 ;
51927 int res1 = 0 ;
51928 size_t val2 ;
51929 int ecode2 = 0 ;
51930 int val3 ;
51931 int ecode3 = 0 ;
51932 PyObject * obj0 = 0 ;
51933 PyObject * obj1 = 0 ;
51934 PyObject * obj2 = 0 ;
51935 char * kwnames[] = {
51936 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51937 };
51938
51939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51941 if (!SWIG_IsOK(res1)) {
51942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51943 }
51944 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51945 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51946 if (!SWIG_IsOK(ecode2)) {
51947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51948 }
51949 arg2 = static_cast< size_t >(val2);
51950 if (obj2) {
51951 ecode3 = SWIG_AsVal_int(obj2, &val3);
51952 if (!SWIG_IsOK(ecode3)) {
51953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
51954 }
51955 arg3 = static_cast< int >(val3);
51956 }
51957 {
51958 PyThreadState* __tstate = wxPyBeginAllowThreads();
51959 (arg1)->AddGrowableCol(arg2,arg3);
51960 wxPyEndAllowThreads(__tstate);
51961 if (PyErr_Occurred()) SWIG_fail;
51962 }
51963 resultobj = SWIG_Py_Void();
51964 return resultobj;
51965 fail:
51966 return NULL;
51967 }
51968
51969
51970 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51971 PyObject *resultobj = 0;
51972 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51973 size_t arg2 ;
51974 void *argp1 = 0 ;
51975 int res1 = 0 ;
51976 size_t val2 ;
51977 int ecode2 = 0 ;
51978 PyObject * obj0 = 0 ;
51979 PyObject * obj1 = 0 ;
51980 char * kwnames[] = {
51981 (char *) "self",(char *) "idx", NULL
51982 };
51983
51984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
51985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51986 if (!SWIG_IsOK(res1)) {
51987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51988 }
51989 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51990 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51991 if (!SWIG_IsOK(ecode2)) {
51992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51993 }
51994 arg2 = static_cast< size_t >(val2);
51995 {
51996 PyThreadState* __tstate = wxPyBeginAllowThreads();
51997 (arg1)->RemoveGrowableCol(arg2);
51998 wxPyEndAllowThreads(__tstate);
51999 if (PyErr_Occurred()) SWIG_fail;
52000 }
52001 resultobj = SWIG_Py_Void();
52002 return resultobj;
52003 fail:
52004 return NULL;
52005 }
52006
52007
52008 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52009 PyObject *resultobj = 0;
52010 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52011 int arg2 ;
52012 void *argp1 = 0 ;
52013 int res1 = 0 ;
52014 int val2 ;
52015 int ecode2 = 0 ;
52016 PyObject * obj0 = 0 ;
52017 PyObject * obj1 = 0 ;
52018 char * kwnames[] = {
52019 (char *) "self",(char *) "direction", NULL
52020 };
52021
52022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
52023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52024 if (!SWIG_IsOK(res1)) {
52025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52026 }
52027 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52028 ecode2 = SWIG_AsVal_int(obj1, &val2);
52029 if (!SWIG_IsOK(ecode2)) {
52030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
52031 }
52032 arg2 = static_cast< int >(val2);
52033 {
52034 PyThreadState* __tstate = wxPyBeginAllowThreads();
52035 (arg1)->SetFlexibleDirection(arg2);
52036 wxPyEndAllowThreads(__tstate);
52037 if (PyErr_Occurred()) SWIG_fail;
52038 }
52039 resultobj = SWIG_Py_Void();
52040 return resultobj;
52041 fail:
52042 return NULL;
52043 }
52044
52045
52046 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52047 PyObject *resultobj = 0;
52048 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52049 int result;
52050 void *argp1 = 0 ;
52051 int res1 = 0 ;
52052 PyObject *swig_obj[1] ;
52053
52054 if (!args) SWIG_fail;
52055 swig_obj[0] = args;
52056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52057 if (!SWIG_IsOK(res1)) {
52058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52059 }
52060 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52061 {
52062 PyThreadState* __tstate = wxPyBeginAllowThreads();
52063 result = (int)(arg1)->GetFlexibleDirection();
52064 wxPyEndAllowThreads(__tstate);
52065 if (PyErr_Occurred()) SWIG_fail;
52066 }
52067 resultobj = SWIG_From_int(static_cast< int >(result));
52068 return resultobj;
52069 fail:
52070 return NULL;
52071 }
52072
52073
52074 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52075 PyObject *resultobj = 0;
52076 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52077 wxFlexSizerGrowMode arg2 ;
52078 void *argp1 = 0 ;
52079 int res1 = 0 ;
52080 int val2 ;
52081 int ecode2 = 0 ;
52082 PyObject * obj0 = 0 ;
52083 PyObject * obj1 = 0 ;
52084 char * kwnames[] = {
52085 (char *) "self",(char *) "mode", NULL
52086 };
52087
52088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
52089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52090 if (!SWIG_IsOK(res1)) {
52091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52092 }
52093 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52094 ecode2 = SWIG_AsVal_int(obj1, &val2);
52095 if (!SWIG_IsOK(ecode2)) {
52096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
52097 }
52098 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
52099 {
52100 PyThreadState* __tstate = wxPyBeginAllowThreads();
52101 (arg1)->SetNonFlexibleGrowMode(arg2);
52102 wxPyEndAllowThreads(__tstate);
52103 if (PyErr_Occurred()) SWIG_fail;
52104 }
52105 resultobj = SWIG_Py_Void();
52106 return resultobj;
52107 fail:
52108 return NULL;
52109 }
52110
52111
52112 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52113 PyObject *resultobj = 0;
52114 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52115 wxFlexSizerGrowMode result;
52116 void *argp1 = 0 ;
52117 int res1 = 0 ;
52118 PyObject *swig_obj[1] ;
52119
52120 if (!args) SWIG_fail;
52121 swig_obj[0] = args;
52122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52123 if (!SWIG_IsOK(res1)) {
52124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52125 }
52126 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52127 {
52128 PyThreadState* __tstate = wxPyBeginAllowThreads();
52129 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
52130 wxPyEndAllowThreads(__tstate);
52131 if (PyErr_Occurred()) SWIG_fail;
52132 }
52133 resultobj = SWIG_From_int(static_cast< int >(result));
52134 return resultobj;
52135 fail:
52136 return NULL;
52137 }
52138
52139
52140 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52141 PyObject *resultobj = 0;
52142 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52143 wxArrayInt *result = 0 ;
52144 void *argp1 = 0 ;
52145 int res1 = 0 ;
52146 PyObject *swig_obj[1] ;
52147
52148 if (!args) SWIG_fail;
52149 swig_obj[0] = args;
52150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52151 if (!SWIG_IsOK(res1)) {
52152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52153 }
52154 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52155 {
52156 PyThreadState* __tstate = wxPyBeginAllowThreads();
52157 {
52158 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
52159 result = (wxArrayInt *) &_result_ref;
52160 }
52161 wxPyEndAllowThreads(__tstate);
52162 if (PyErr_Occurred()) SWIG_fail;
52163 }
52164 {
52165 resultobj = wxArrayInt2PyList_helper(*result);
52166 }
52167 return resultobj;
52168 fail:
52169 return NULL;
52170 }
52171
52172
52173 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52174 PyObject *resultobj = 0;
52175 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52176 wxArrayInt *result = 0 ;
52177 void *argp1 = 0 ;
52178 int res1 = 0 ;
52179 PyObject *swig_obj[1] ;
52180
52181 if (!args) SWIG_fail;
52182 swig_obj[0] = args;
52183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52184 if (!SWIG_IsOK(res1)) {
52185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52186 }
52187 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52188 {
52189 PyThreadState* __tstate = wxPyBeginAllowThreads();
52190 {
52191 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
52192 result = (wxArrayInt *) &_result_ref;
52193 }
52194 wxPyEndAllowThreads(__tstate);
52195 if (PyErr_Occurred()) SWIG_fail;
52196 }
52197 {
52198 resultobj = wxArrayInt2PyList_helper(*result);
52199 }
52200 return resultobj;
52201 fail:
52202 return NULL;
52203 }
52204
52205
52206 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52207 PyObject *obj;
52208 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52209 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
52210 return SWIG_Py_Void();
52211 }
52212
52213 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52214 return SWIG_Python_InitShadowInstance(args);
52215 }
52216
52217 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52218 PyObject *resultobj = 0;
52219 wxStdDialogButtonSizer *result = 0 ;
52220
52221 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
52222 {
52223 PyThreadState* __tstate = wxPyBeginAllowThreads();
52224 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
52225 wxPyEndAllowThreads(__tstate);
52226 if (PyErr_Occurred()) SWIG_fail;
52227 }
52228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
52229 return resultobj;
52230 fail:
52231 return NULL;
52232 }
52233
52234
52235 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52236 PyObject *resultobj = 0;
52237 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52238 wxButton *arg2 = (wxButton *) 0 ;
52239 void *argp1 = 0 ;
52240 int res1 = 0 ;
52241 void *argp2 = 0 ;
52242 int res2 = 0 ;
52243 PyObject * obj0 = 0 ;
52244 PyObject * obj1 = 0 ;
52245 char * kwnames[] = {
52246 (char *) "self",(char *) "button", NULL
52247 };
52248
52249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
52250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52251 if (!SWIG_IsOK(res1)) {
52252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52253 }
52254 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52255 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52256 if (!SWIG_IsOK(res2)) {
52257 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
52258 }
52259 arg2 = reinterpret_cast< wxButton * >(argp2);
52260 {
52261 PyThreadState* __tstate = wxPyBeginAllowThreads();
52262 (arg1)->AddButton(arg2);
52263 wxPyEndAllowThreads(__tstate);
52264 if (PyErr_Occurred()) SWIG_fail;
52265 }
52266 resultobj = SWIG_Py_Void();
52267 return resultobj;
52268 fail:
52269 return NULL;
52270 }
52271
52272
52273 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52274 PyObject *resultobj = 0;
52275 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52276 void *argp1 = 0 ;
52277 int res1 = 0 ;
52278 PyObject *swig_obj[1] ;
52279
52280 if (!args) SWIG_fail;
52281 swig_obj[0] = args;
52282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52283 if (!SWIG_IsOK(res1)) {
52284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52285 }
52286 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52287 {
52288 PyThreadState* __tstate = wxPyBeginAllowThreads();
52289 (arg1)->Realize();
52290 wxPyEndAllowThreads(__tstate);
52291 if (PyErr_Occurred()) SWIG_fail;
52292 }
52293 resultobj = SWIG_Py_Void();
52294 return resultobj;
52295 fail:
52296 return NULL;
52297 }
52298
52299
52300 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52301 PyObject *resultobj = 0;
52302 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52303 wxButton *arg2 = (wxButton *) 0 ;
52304 void *argp1 = 0 ;
52305 int res1 = 0 ;
52306 void *argp2 = 0 ;
52307 int res2 = 0 ;
52308 PyObject * obj0 = 0 ;
52309 PyObject * obj1 = 0 ;
52310 char * kwnames[] = {
52311 (char *) "self",(char *) "button", NULL
52312 };
52313
52314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52316 if (!SWIG_IsOK(res1)) {
52317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52318 }
52319 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52320 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52321 if (!SWIG_IsOK(res2)) {
52322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52323 }
52324 arg2 = reinterpret_cast< wxButton * >(argp2);
52325 {
52326 PyThreadState* __tstate = wxPyBeginAllowThreads();
52327 (arg1)->SetAffirmativeButton(arg2);
52328 wxPyEndAllowThreads(__tstate);
52329 if (PyErr_Occurred()) SWIG_fail;
52330 }
52331 resultobj = SWIG_Py_Void();
52332 return resultobj;
52333 fail:
52334 return NULL;
52335 }
52336
52337
52338 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52339 PyObject *resultobj = 0;
52340 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52341 wxButton *arg2 = (wxButton *) 0 ;
52342 void *argp1 = 0 ;
52343 int res1 = 0 ;
52344 void *argp2 = 0 ;
52345 int res2 = 0 ;
52346 PyObject * obj0 = 0 ;
52347 PyObject * obj1 = 0 ;
52348 char * kwnames[] = {
52349 (char *) "self",(char *) "button", NULL
52350 };
52351
52352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52354 if (!SWIG_IsOK(res1)) {
52355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52356 }
52357 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52358 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52359 if (!SWIG_IsOK(res2)) {
52360 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52361 }
52362 arg2 = reinterpret_cast< wxButton * >(argp2);
52363 {
52364 PyThreadState* __tstate = wxPyBeginAllowThreads();
52365 (arg1)->SetNegativeButton(arg2);
52366 wxPyEndAllowThreads(__tstate);
52367 if (PyErr_Occurred()) SWIG_fail;
52368 }
52369 resultobj = SWIG_Py_Void();
52370 return resultobj;
52371 fail:
52372 return NULL;
52373 }
52374
52375
52376 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52377 PyObject *resultobj = 0;
52378 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52379 wxButton *arg2 = (wxButton *) 0 ;
52380 void *argp1 = 0 ;
52381 int res1 = 0 ;
52382 void *argp2 = 0 ;
52383 int res2 = 0 ;
52384 PyObject * obj0 = 0 ;
52385 PyObject * obj1 = 0 ;
52386 char * kwnames[] = {
52387 (char *) "self",(char *) "button", NULL
52388 };
52389
52390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
52391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52392 if (!SWIG_IsOK(res1)) {
52393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52394 }
52395 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52396 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52397 if (!SWIG_IsOK(res2)) {
52398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
52399 }
52400 arg2 = reinterpret_cast< wxButton * >(argp2);
52401 {
52402 PyThreadState* __tstate = wxPyBeginAllowThreads();
52403 (arg1)->SetCancelButton(arg2);
52404 wxPyEndAllowThreads(__tstate);
52405 if (PyErr_Occurred()) SWIG_fail;
52406 }
52407 resultobj = SWIG_Py_Void();
52408 return resultobj;
52409 fail:
52410 return NULL;
52411 }
52412
52413
52414 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52415 PyObject *resultobj = 0;
52416 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52417 wxButton *result = 0 ;
52418 void *argp1 = 0 ;
52419 int res1 = 0 ;
52420 PyObject *swig_obj[1] ;
52421
52422 if (!args) SWIG_fail;
52423 swig_obj[0] = args;
52424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52425 if (!SWIG_IsOK(res1)) {
52426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52427 }
52428 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52429 {
52430 PyThreadState* __tstate = wxPyBeginAllowThreads();
52431 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
52432 wxPyEndAllowThreads(__tstate);
52433 if (PyErr_Occurred()) SWIG_fail;
52434 }
52435 {
52436 resultobj = wxPyMake_wxObject(result, (bool)0);
52437 }
52438 return resultobj;
52439 fail:
52440 return NULL;
52441 }
52442
52443
52444 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52445 PyObject *resultobj = 0;
52446 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52447 wxButton *result = 0 ;
52448 void *argp1 = 0 ;
52449 int res1 = 0 ;
52450 PyObject *swig_obj[1] ;
52451
52452 if (!args) SWIG_fail;
52453 swig_obj[0] = args;
52454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52455 if (!SWIG_IsOK(res1)) {
52456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52457 }
52458 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52459 {
52460 PyThreadState* __tstate = wxPyBeginAllowThreads();
52461 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
52462 wxPyEndAllowThreads(__tstate);
52463 if (PyErr_Occurred()) SWIG_fail;
52464 }
52465 {
52466 resultobj = wxPyMake_wxObject(result, (bool)0);
52467 }
52468 return resultobj;
52469 fail:
52470 return NULL;
52471 }
52472
52473
52474 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52475 PyObject *resultobj = 0;
52476 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52477 wxButton *result = 0 ;
52478 void *argp1 = 0 ;
52479 int res1 = 0 ;
52480 PyObject *swig_obj[1] ;
52481
52482 if (!args) SWIG_fail;
52483 swig_obj[0] = args;
52484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52485 if (!SWIG_IsOK(res1)) {
52486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52487 }
52488 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52489 {
52490 PyThreadState* __tstate = wxPyBeginAllowThreads();
52491 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
52492 wxPyEndAllowThreads(__tstate);
52493 if (PyErr_Occurred()) SWIG_fail;
52494 }
52495 {
52496 resultobj = wxPyMake_wxObject(result, (bool)0);
52497 }
52498 return resultobj;
52499 fail:
52500 return NULL;
52501 }
52502
52503
52504 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52505 PyObject *resultobj = 0;
52506 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52507 wxButton *result = 0 ;
52508 void *argp1 = 0 ;
52509 int res1 = 0 ;
52510 PyObject *swig_obj[1] ;
52511
52512 if (!args) SWIG_fail;
52513 swig_obj[0] = args;
52514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52515 if (!SWIG_IsOK(res1)) {
52516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52517 }
52518 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52519 {
52520 PyThreadState* __tstate = wxPyBeginAllowThreads();
52521 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
52522 wxPyEndAllowThreads(__tstate);
52523 if (PyErr_Occurred()) SWIG_fail;
52524 }
52525 {
52526 resultobj = wxPyMake_wxObject(result, (bool)0);
52527 }
52528 return resultobj;
52529 fail:
52530 return NULL;
52531 }
52532
52533
52534 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52535 PyObject *resultobj = 0;
52536 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52537 wxButton *result = 0 ;
52538 void *argp1 = 0 ;
52539 int res1 = 0 ;
52540 PyObject *swig_obj[1] ;
52541
52542 if (!args) SWIG_fail;
52543 swig_obj[0] = args;
52544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52545 if (!SWIG_IsOK(res1)) {
52546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52547 }
52548 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52549 {
52550 PyThreadState* __tstate = wxPyBeginAllowThreads();
52551 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
52552 wxPyEndAllowThreads(__tstate);
52553 if (PyErr_Occurred()) SWIG_fail;
52554 }
52555 {
52556 resultobj = wxPyMake_wxObject(result, (bool)0);
52557 }
52558 return resultobj;
52559 fail:
52560 return NULL;
52561 }
52562
52563
52564 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52565 PyObject *obj;
52566 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52567 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
52568 return SWIG_Py_Void();
52569 }
52570
52571 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52572 return SWIG_Python_InitShadowInstance(args);
52573 }
52574
52575 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52576 PyObject *resultobj = 0;
52577 int arg1 = (int) 0 ;
52578 int arg2 = (int) 0 ;
52579 wxGBPosition *result = 0 ;
52580 int val1 ;
52581 int ecode1 = 0 ;
52582 int val2 ;
52583 int ecode2 = 0 ;
52584 PyObject * obj0 = 0 ;
52585 PyObject * obj1 = 0 ;
52586 char * kwnames[] = {
52587 (char *) "row",(char *) "col", NULL
52588 };
52589
52590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52591 if (obj0) {
52592 ecode1 = SWIG_AsVal_int(obj0, &val1);
52593 if (!SWIG_IsOK(ecode1)) {
52594 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
52595 }
52596 arg1 = static_cast< int >(val1);
52597 }
52598 if (obj1) {
52599 ecode2 = SWIG_AsVal_int(obj1, &val2);
52600 if (!SWIG_IsOK(ecode2)) {
52601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
52602 }
52603 arg2 = static_cast< int >(val2);
52604 }
52605 {
52606 PyThreadState* __tstate = wxPyBeginAllowThreads();
52607 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
52608 wxPyEndAllowThreads(__tstate);
52609 if (PyErr_Occurred()) SWIG_fail;
52610 }
52611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
52612 return resultobj;
52613 fail:
52614 return NULL;
52615 }
52616
52617
52618 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52619 PyObject *resultobj = 0;
52620 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52621 void *argp1 = 0 ;
52622 int res1 = 0 ;
52623 PyObject *swig_obj[1] ;
52624
52625 if (!args) SWIG_fail;
52626 swig_obj[0] = args;
52627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
52628 if (!SWIG_IsOK(res1)) {
52629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52630 }
52631 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52632 {
52633 PyThreadState* __tstate = wxPyBeginAllowThreads();
52634 delete arg1;
52635
52636 wxPyEndAllowThreads(__tstate);
52637 if (PyErr_Occurred()) SWIG_fail;
52638 }
52639 resultobj = SWIG_Py_Void();
52640 return resultobj;
52641 fail:
52642 return NULL;
52643 }
52644
52645
52646 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52647 PyObject *resultobj = 0;
52648 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52649 int result;
52650 void *argp1 = 0 ;
52651 int res1 = 0 ;
52652 PyObject *swig_obj[1] ;
52653
52654 if (!args) SWIG_fail;
52655 swig_obj[0] = args;
52656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52657 if (!SWIG_IsOK(res1)) {
52658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52659 }
52660 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52661 {
52662 PyThreadState* __tstate = wxPyBeginAllowThreads();
52663 result = (int)((wxGBPosition const *)arg1)->GetRow();
52664 wxPyEndAllowThreads(__tstate);
52665 if (PyErr_Occurred()) SWIG_fail;
52666 }
52667 resultobj = SWIG_From_int(static_cast< int >(result));
52668 return resultobj;
52669 fail:
52670 return NULL;
52671 }
52672
52673
52674 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52675 PyObject *resultobj = 0;
52676 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52677 int result;
52678 void *argp1 = 0 ;
52679 int res1 = 0 ;
52680 PyObject *swig_obj[1] ;
52681
52682 if (!args) SWIG_fail;
52683 swig_obj[0] = args;
52684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52685 if (!SWIG_IsOK(res1)) {
52686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52687 }
52688 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52689 {
52690 PyThreadState* __tstate = wxPyBeginAllowThreads();
52691 result = (int)((wxGBPosition const *)arg1)->GetCol();
52692 wxPyEndAllowThreads(__tstate);
52693 if (PyErr_Occurred()) SWIG_fail;
52694 }
52695 resultobj = SWIG_From_int(static_cast< int >(result));
52696 return resultobj;
52697 fail:
52698 return NULL;
52699 }
52700
52701
52702 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52703 PyObject *resultobj = 0;
52704 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52705 int arg2 ;
52706 void *argp1 = 0 ;
52707 int res1 = 0 ;
52708 int val2 ;
52709 int ecode2 = 0 ;
52710 PyObject * obj0 = 0 ;
52711 PyObject * obj1 = 0 ;
52712 char * kwnames[] = {
52713 (char *) "self",(char *) "row", NULL
52714 };
52715
52716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
52717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52718 if (!SWIG_IsOK(res1)) {
52719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52720 }
52721 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52722 ecode2 = SWIG_AsVal_int(obj1, &val2);
52723 if (!SWIG_IsOK(ecode2)) {
52724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
52725 }
52726 arg2 = static_cast< int >(val2);
52727 {
52728 PyThreadState* __tstate = wxPyBeginAllowThreads();
52729 (arg1)->SetRow(arg2);
52730 wxPyEndAllowThreads(__tstate);
52731 if (PyErr_Occurred()) SWIG_fail;
52732 }
52733 resultobj = SWIG_Py_Void();
52734 return resultobj;
52735 fail:
52736 return NULL;
52737 }
52738
52739
52740 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52741 PyObject *resultobj = 0;
52742 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52743 int arg2 ;
52744 void *argp1 = 0 ;
52745 int res1 = 0 ;
52746 int val2 ;
52747 int ecode2 = 0 ;
52748 PyObject * obj0 = 0 ;
52749 PyObject * obj1 = 0 ;
52750 char * kwnames[] = {
52751 (char *) "self",(char *) "col", NULL
52752 };
52753
52754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
52755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52756 if (!SWIG_IsOK(res1)) {
52757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52758 }
52759 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52760 ecode2 = SWIG_AsVal_int(obj1, &val2);
52761 if (!SWIG_IsOK(ecode2)) {
52762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
52763 }
52764 arg2 = static_cast< int >(val2);
52765 {
52766 PyThreadState* __tstate = wxPyBeginAllowThreads();
52767 (arg1)->SetCol(arg2);
52768 wxPyEndAllowThreads(__tstate);
52769 if (PyErr_Occurred()) SWIG_fail;
52770 }
52771 resultobj = SWIG_Py_Void();
52772 return resultobj;
52773 fail:
52774 return NULL;
52775 }
52776
52777
52778 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52779 PyObject *resultobj = 0;
52780 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52781 PyObject *arg2 = (PyObject *) 0 ;
52782 bool result;
52783 void *argp1 = 0 ;
52784 int res1 = 0 ;
52785 PyObject * obj0 = 0 ;
52786 PyObject * obj1 = 0 ;
52787 char * kwnames[] = {
52788 (char *) "self",(char *) "other", NULL
52789 };
52790
52791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
52792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52793 if (!SWIG_IsOK(res1)) {
52794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52795 }
52796 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52797 arg2 = obj1;
52798 {
52799 result = (bool)wxGBPosition___eq__(arg1,arg2);
52800 if (PyErr_Occurred()) SWIG_fail;
52801 }
52802 {
52803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52804 }
52805 return resultobj;
52806 fail:
52807 return NULL;
52808 }
52809
52810
52811 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52812 PyObject *resultobj = 0;
52813 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52814 PyObject *arg2 = (PyObject *) 0 ;
52815 bool result;
52816 void *argp1 = 0 ;
52817 int res1 = 0 ;
52818 PyObject * obj0 = 0 ;
52819 PyObject * obj1 = 0 ;
52820 char * kwnames[] = {
52821 (char *) "self",(char *) "other", NULL
52822 };
52823
52824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
52825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52826 if (!SWIG_IsOK(res1)) {
52827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52828 }
52829 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52830 arg2 = obj1;
52831 {
52832 result = (bool)wxGBPosition___ne__(arg1,arg2);
52833 if (PyErr_Occurred()) SWIG_fail;
52834 }
52835 {
52836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52837 }
52838 return resultobj;
52839 fail:
52840 return NULL;
52841 }
52842
52843
52844 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52845 PyObject *resultobj = 0;
52846 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52847 int arg2 = (int) 0 ;
52848 int arg3 = (int) 0 ;
52849 void *argp1 = 0 ;
52850 int res1 = 0 ;
52851 int val2 ;
52852 int ecode2 = 0 ;
52853 int val3 ;
52854 int ecode3 = 0 ;
52855 PyObject * obj0 = 0 ;
52856 PyObject * obj1 = 0 ;
52857 PyObject * obj2 = 0 ;
52858 char * kwnames[] = {
52859 (char *) "self",(char *) "row",(char *) "col", NULL
52860 };
52861
52862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52864 if (!SWIG_IsOK(res1)) {
52865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52866 }
52867 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52868 if (obj1) {
52869 ecode2 = SWIG_AsVal_int(obj1, &val2);
52870 if (!SWIG_IsOK(ecode2)) {
52871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
52872 }
52873 arg2 = static_cast< int >(val2);
52874 }
52875 if (obj2) {
52876 ecode3 = SWIG_AsVal_int(obj2, &val3);
52877 if (!SWIG_IsOK(ecode3)) {
52878 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
52879 }
52880 arg3 = static_cast< int >(val3);
52881 }
52882 {
52883 PyThreadState* __tstate = wxPyBeginAllowThreads();
52884 wxGBPosition_Set(arg1,arg2,arg3);
52885 wxPyEndAllowThreads(__tstate);
52886 if (PyErr_Occurred()) SWIG_fail;
52887 }
52888 resultobj = SWIG_Py_Void();
52889 return resultobj;
52890 fail:
52891 return NULL;
52892 }
52893
52894
52895 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52896 PyObject *resultobj = 0;
52897 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52898 PyObject *result = 0 ;
52899 void *argp1 = 0 ;
52900 int res1 = 0 ;
52901 PyObject *swig_obj[1] ;
52902
52903 if (!args) SWIG_fail;
52904 swig_obj[0] = args;
52905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52906 if (!SWIG_IsOK(res1)) {
52907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52908 }
52909 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52910 {
52911 PyThreadState* __tstate = wxPyBeginAllowThreads();
52912 result = (PyObject *)wxGBPosition_Get(arg1);
52913 wxPyEndAllowThreads(__tstate);
52914 if (PyErr_Occurred()) SWIG_fail;
52915 }
52916 resultobj = result;
52917 return resultobj;
52918 fail:
52919 return NULL;
52920 }
52921
52922
52923 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52924 PyObject *obj;
52925 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52926 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
52927 return SWIG_Py_Void();
52928 }
52929
52930 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52931 return SWIG_Python_InitShadowInstance(args);
52932 }
52933
52934 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52935 PyObject *resultobj = 0;
52936 int arg1 = (int) 1 ;
52937 int arg2 = (int) 1 ;
52938 wxGBSpan *result = 0 ;
52939 int val1 ;
52940 int ecode1 = 0 ;
52941 int val2 ;
52942 int ecode2 = 0 ;
52943 PyObject * obj0 = 0 ;
52944 PyObject * obj1 = 0 ;
52945 char * kwnames[] = {
52946 (char *) "rowspan",(char *) "colspan", NULL
52947 };
52948
52949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
52950 if (obj0) {
52951 ecode1 = SWIG_AsVal_int(obj0, &val1);
52952 if (!SWIG_IsOK(ecode1)) {
52953 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
52954 }
52955 arg1 = static_cast< int >(val1);
52956 }
52957 if (obj1) {
52958 ecode2 = SWIG_AsVal_int(obj1, &val2);
52959 if (!SWIG_IsOK(ecode2)) {
52960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
52961 }
52962 arg2 = static_cast< int >(val2);
52963 }
52964 {
52965 PyThreadState* __tstate = wxPyBeginAllowThreads();
52966 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
52967 wxPyEndAllowThreads(__tstate);
52968 if (PyErr_Occurred()) SWIG_fail;
52969 }
52970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
52971 return resultobj;
52972 fail:
52973 return NULL;
52974 }
52975
52976
52977 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52978 PyObject *resultobj = 0;
52979 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52980 void *argp1 = 0 ;
52981 int res1 = 0 ;
52982 PyObject *swig_obj[1] ;
52983
52984 if (!args) SWIG_fail;
52985 swig_obj[0] = args;
52986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
52987 if (!SWIG_IsOK(res1)) {
52988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52989 }
52990 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52991 {
52992 PyThreadState* __tstate = wxPyBeginAllowThreads();
52993 delete arg1;
52994
52995 wxPyEndAllowThreads(__tstate);
52996 if (PyErr_Occurred()) SWIG_fail;
52997 }
52998 resultobj = SWIG_Py_Void();
52999 return resultobj;
53000 fail:
53001 return NULL;
53002 }
53003
53004
53005 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53006 PyObject *resultobj = 0;
53007 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53008 int result;
53009 void *argp1 = 0 ;
53010 int res1 = 0 ;
53011 PyObject *swig_obj[1] ;
53012
53013 if (!args) SWIG_fail;
53014 swig_obj[0] = args;
53015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53016 if (!SWIG_IsOK(res1)) {
53017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53018 }
53019 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53020 {
53021 PyThreadState* __tstate = wxPyBeginAllowThreads();
53022 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
53023 wxPyEndAllowThreads(__tstate);
53024 if (PyErr_Occurred()) SWIG_fail;
53025 }
53026 resultobj = SWIG_From_int(static_cast< int >(result));
53027 return resultobj;
53028 fail:
53029 return NULL;
53030 }
53031
53032
53033 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53034 PyObject *resultobj = 0;
53035 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53036 int result;
53037 void *argp1 = 0 ;
53038 int res1 = 0 ;
53039 PyObject *swig_obj[1] ;
53040
53041 if (!args) SWIG_fail;
53042 swig_obj[0] = args;
53043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53044 if (!SWIG_IsOK(res1)) {
53045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53046 }
53047 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53048 {
53049 PyThreadState* __tstate = wxPyBeginAllowThreads();
53050 result = (int)((wxGBSpan const *)arg1)->GetColspan();
53051 wxPyEndAllowThreads(__tstate);
53052 if (PyErr_Occurred()) SWIG_fail;
53053 }
53054 resultobj = SWIG_From_int(static_cast< int >(result));
53055 return resultobj;
53056 fail:
53057 return NULL;
53058 }
53059
53060
53061 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53062 PyObject *resultobj = 0;
53063 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53064 int arg2 ;
53065 void *argp1 = 0 ;
53066 int res1 = 0 ;
53067 int val2 ;
53068 int ecode2 = 0 ;
53069 PyObject * obj0 = 0 ;
53070 PyObject * obj1 = 0 ;
53071 char * kwnames[] = {
53072 (char *) "self",(char *) "rowspan", NULL
53073 };
53074
53075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
53076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53077 if (!SWIG_IsOK(res1)) {
53078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53079 }
53080 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53081 ecode2 = SWIG_AsVal_int(obj1, &val2);
53082 if (!SWIG_IsOK(ecode2)) {
53083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
53084 }
53085 arg2 = static_cast< int >(val2);
53086 {
53087 PyThreadState* __tstate = wxPyBeginAllowThreads();
53088 (arg1)->SetRowspan(arg2);
53089 wxPyEndAllowThreads(__tstate);
53090 if (PyErr_Occurred()) SWIG_fail;
53091 }
53092 resultobj = SWIG_Py_Void();
53093 return resultobj;
53094 fail:
53095 return NULL;
53096 }
53097
53098
53099 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53100 PyObject *resultobj = 0;
53101 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53102 int arg2 ;
53103 void *argp1 = 0 ;
53104 int res1 = 0 ;
53105 int val2 ;
53106 int ecode2 = 0 ;
53107 PyObject * obj0 = 0 ;
53108 PyObject * obj1 = 0 ;
53109 char * kwnames[] = {
53110 (char *) "self",(char *) "colspan", NULL
53111 };
53112
53113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
53114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53115 if (!SWIG_IsOK(res1)) {
53116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53117 }
53118 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53119 ecode2 = SWIG_AsVal_int(obj1, &val2);
53120 if (!SWIG_IsOK(ecode2)) {
53121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
53122 }
53123 arg2 = static_cast< int >(val2);
53124 {
53125 PyThreadState* __tstate = wxPyBeginAllowThreads();
53126 (arg1)->SetColspan(arg2);
53127 wxPyEndAllowThreads(__tstate);
53128 if (PyErr_Occurred()) SWIG_fail;
53129 }
53130 resultobj = SWIG_Py_Void();
53131 return resultobj;
53132 fail:
53133 return NULL;
53134 }
53135
53136
53137 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53138 PyObject *resultobj = 0;
53139 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53140 PyObject *arg2 = (PyObject *) 0 ;
53141 bool result;
53142 void *argp1 = 0 ;
53143 int res1 = 0 ;
53144 PyObject * obj0 = 0 ;
53145 PyObject * obj1 = 0 ;
53146 char * kwnames[] = {
53147 (char *) "self",(char *) "other", NULL
53148 };
53149
53150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
53151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53152 if (!SWIG_IsOK(res1)) {
53153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53154 }
53155 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53156 arg2 = obj1;
53157 {
53158 result = (bool)wxGBSpan___eq__(arg1,arg2);
53159 if (PyErr_Occurred()) SWIG_fail;
53160 }
53161 {
53162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53163 }
53164 return resultobj;
53165 fail:
53166 return NULL;
53167 }
53168
53169
53170 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53171 PyObject *resultobj = 0;
53172 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53173 PyObject *arg2 = (PyObject *) 0 ;
53174 bool result;
53175 void *argp1 = 0 ;
53176 int res1 = 0 ;
53177 PyObject * obj0 = 0 ;
53178 PyObject * obj1 = 0 ;
53179 char * kwnames[] = {
53180 (char *) "self",(char *) "other", NULL
53181 };
53182
53183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
53184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53185 if (!SWIG_IsOK(res1)) {
53186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53187 }
53188 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53189 arg2 = obj1;
53190 {
53191 result = (bool)wxGBSpan___ne__(arg1,arg2);
53192 if (PyErr_Occurred()) SWIG_fail;
53193 }
53194 {
53195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53196 }
53197 return resultobj;
53198 fail:
53199 return NULL;
53200 }
53201
53202
53203 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53204 PyObject *resultobj = 0;
53205 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53206 int arg2 = (int) 1 ;
53207 int arg3 = (int) 1 ;
53208 void *argp1 = 0 ;
53209 int res1 = 0 ;
53210 int val2 ;
53211 int ecode2 = 0 ;
53212 int val3 ;
53213 int ecode3 = 0 ;
53214 PyObject * obj0 = 0 ;
53215 PyObject * obj1 = 0 ;
53216 PyObject * obj2 = 0 ;
53217 char * kwnames[] = {
53218 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
53219 };
53220
53221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53223 if (!SWIG_IsOK(res1)) {
53224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53225 }
53226 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53227 if (obj1) {
53228 ecode2 = SWIG_AsVal_int(obj1, &val2);
53229 if (!SWIG_IsOK(ecode2)) {
53230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
53231 }
53232 arg2 = static_cast< int >(val2);
53233 }
53234 if (obj2) {
53235 ecode3 = SWIG_AsVal_int(obj2, &val3);
53236 if (!SWIG_IsOK(ecode3)) {
53237 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
53238 }
53239 arg3 = static_cast< int >(val3);
53240 }
53241 {
53242 PyThreadState* __tstate = wxPyBeginAllowThreads();
53243 wxGBSpan_Set(arg1,arg2,arg3);
53244 wxPyEndAllowThreads(__tstate);
53245 if (PyErr_Occurred()) SWIG_fail;
53246 }
53247 resultobj = SWIG_Py_Void();
53248 return resultobj;
53249 fail:
53250 return NULL;
53251 }
53252
53253
53254 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53255 PyObject *resultobj = 0;
53256 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53257 PyObject *result = 0 ;
53258 void *argp1 = 0 ;
53259 int res1 = 0 ;
53260 PyObject *swig_obj[1] ;
53261
53262 if (!args) SWIG_fail;
53263 swig_obj[0] = args;
53264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53265 if (!SWIG_IsOK(res1)) {
53266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53267 }
53268 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53269 {
53270 PyThreadState* __tstate = wxPyBeginAllowThreads();
53271 result = (PyObject *)wxGBSpan_Get(arg1);
53272 wxPyEndAllowThreads(__tstate);
53273 if (PyErr_Occurred()) SWIG_fail;
53274 }
53275 resultobj = result;
53276 return resultobj;
53277 fail:
53278 return NULL;
53279 }
53280
53281
53282 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53283 PyObject *obj;
53284 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53285 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
53286 return SWIG_Py_Void();
53287 }
53288
53289 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53290 return SWIG_Python_InitShadowInstance(args);
53291 }
53292
53293 SWIGINTERN int DefaultSpan_set(PyObject *) {
53294 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
53295 return 1;
53296 }
53297
53298
53299 SWIGINTERN PyObject *DefaultSpan_get(void) {
53300 PyObject *pyobj = 0;
53301
53302 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
53303 return pyobj;
53304 }
53305
53306
53307 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53308 PyObject *resultobj = 0;
53309 wxGBSizerItem *result = 0 ;
53310
53311 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
53312 {
53313 PyThreadState* __tstate = wxPyBeginAllowThreads();
53314 result = (wxGBSizerItem *)new wxGBSizerItem();
53315 wxPyEndAllowThreads(__tstate);
53316 if (PyErr_Occurred()) SWIG_fail;
53317 }
53318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
53319 return resultobj;
53320 fail:
53321 return NULL;
53322 }
53323
53324
53325 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53326 PyObject *resultobj = 0;
53327 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53328 void *argp1 = 0 ;
53329 int res1 = 0 ;
53330 PyObject *swig_obj[1] ;
53331
53332 if (!args) SWIG_fail;
53333 swig_obj[0] = args;
53334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53335 if (!SWIG_IsOK(res1)) {
53336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53337 }
53338 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53339 {
53340 PyThreadState* __tstate = wxPyBeginAllowThreads();
53341 delete arg1;
53342
53343 wxPyEndAllowThreads(__tstate);
53344 if (PyErr_Occurred()) SWIG_fail;
53345 }
53346 resultobj = SWIG_Py_Void();
53347 return resultobj;
53348 fail:
53349 return NULL;
53350 }
53351
53352
53353 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53354 PyObject *resultobj = 0;
53355 wxWindow *arg1 = (wxWindow *) 0 ;
53356 wxGBPosition *arg2 = 0 ;
53357 wxGBSpan *arg3 = 0 ;
53358 int arg4 ;
53359 int arg5 ;
53360 PyObject *arg6 = (PyObject *) NULL ;
53361 wxGBSizerItem *result = 0 ;
53362 void *argp1 = 0 ;
53363 int res1 = 0 ;
53364 wxGBPosition temp2 ;
53365 wxGBSpan temp3 ;
53366 int val4 ;
53367 int ecode4 = 0 ;
53368 int val5 ;
53369 int ecode5 = 0 ;
53370 PyObject * obj0 = 0 ;
53371 PyObject * obj1 = 0 ;
53372 PyObject * obj2 = 0 ;
53373 PyObject * obj3 = 0 ;
53374 PyObject * obj4 = 0 ;
53375 PyObject * obj5 = 0 ;
53376 char * kwnames[] = {
53377 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53378 };
53379
53380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
53382 if (!SWIG_IsOK(res1)) {
53383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
53384 }
53385 arg1 = reinterpret_cast< wxWindow * >(argp1);
53386 {
53387 arg2 = &temp2;
53388 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53389 }
53390 {
53391 arg3 = &temp3;
53392 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53393 }
53394 ecode4 = SWIG_AsVal_int(obj3, &val4);
53395 if (!SWIG_IsOK(ecode4)) {
53396 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
53397 }
53398 arg4 = static_cast< int >(val4);
53399 ecode5 = SWIG_AsVal_int(obj4, &val5);
53400 if (!SWIG_IsOK(ecode5)) {
53401 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
53402 }
53403 arg5 = static_cast< int >(val5);
53404 if (obj5) {
53405 arg6 = obj5;
53406 }
53407 {
53408 PyThreadState* __tstate = wxPyBeginAllowThreads();
53409 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53410 wxPyEndAllowThreads(__tstate);
53411 if (PyErr_Occurred()) SWIG_fail;
53412 }
53413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53414 return resultobj;
53415 fail:
53416 return NULL;
53417 }
53418
53419
53420 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53421 PyObject *resultobj = 0;
53422 wxSizer *arg1 = (wxSizer *) 0 ;
53423 wxGBPosition *arg2 = 0 ;
53424 wxGBSpan *arg3 = 0 ;
53425 int arg4 ;
53426 int arg5 ;
53427 PyObject *arg6 = (PyObject *) NULL ;
53428 wxGBSizerItem *result = 0 ;
53429 int res1 = 0 ;
53430 wxGBPosition temp2 ;
53431 wxGBSpan temp3 ;
53432 int val4 ;
53433 int ecode4 = 0 ;
53434 int val5 ;
53435 int ecode5 = 0 ;
53436 PyObject * obj0 = 0 ;
53437 PyObject * obj1 = 0 ;
53438 PyObject * obj2 = 0 ;
53439 PyObject * obj3 = 0 ;
53440 PyObject * obj4 = 0 ;
53441 PyObject * obj5 = 0 ;
53442 char * kwnames[] = {
53443 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53444 };
53445
53446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53447 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
53448 if (!SWIG_IsOK(res1)) {
53449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
53450 }
53451 {
53452 arg2 = &temp2;
53453 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53454 }
53455 {
53456 arg3 = &temp3;
53457 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53458 }
53459 ecode4 = SWIG_AsVal_int(obj3, &val4);
53460 if (!SWIG_IsOK(ecode4)) {
53461 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
53462 }
53463 arg4 = static_cast< int >(val4);
53464 ecode5 = SWIG_AsVal_int(obj4, &val5);
53465 if (!SWIG_IsOK(ecode5)) {
53466 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
53467 }
53468 arg5 = static_cast< int >(val5);
53469 if (obj5) {
53470 arg6 = obj5;
53471 }
53472 {
53473 PyThreadState* __tstate = wxPyBeginAllowThreads();
53474 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53475 wxPyEndAllowThreads(__tstate);
53476 if (PyErr_Occurred()) SWIG_fail;
53477 }
53478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53479 return resultobj;
53480 fail:
53481 return NULL;
53482 }
53483
53484
53485 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53486 PyObject *resultobj = 0;
53487 int arg1 ;
53488 int arg2 ;
53489 wxGBPosition *arg3 = 0 ;
53490 wxGBSpan *arg4 = 0 ;
53491 int arg5 ;
53492 int arg6 ;
53493 PyObject *arg7 = (PyObject *) NULL ;
53494 wxGBSizerItem *result = 0 ;
53495 int val1 ;
53496 int ecode1 = 0 ;
53497 int val2 ;
53498 int ecode2 = 0 ;
53499 wxGBPosition temp3 ;
53500 wxGBSpan temp4 ;
53501 int val5 ;
53502 int ecode5 = 0 ;
53503 int val6 ;
53504 int ecode6 = 0 ;
53505 PyObject * obj0 = 0 ;
53506 PyObject * obj1 = 0 ;
53507 PyObject * obj2 = 0 ;
53508 PyObject * obj3 = 0 ;
53509 PyObject * obj4 = 0 ;
53510 PyObject * obj5 = 0 ;
53511 PyObject * obj6 = 0 ;
53512 char * kwnames[] = {
53513 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53514 };
53515
53516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53517 ecode1 = SWIG_AsVal_int(obj0, &val1);
53518 if (!SWIG_IsOK(ecode1)) {
53519 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
53520 }
53521 arg1 = static_cast< int >(val1);
53522 ecode2 = SWIG_AsVal_int(obj1, &val2);
53523 if (!SWIG_IsOK(ecode2)) {
53524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
53525 }
53526 arg2 = static_cast< int >(val2);
53527 {
53528 arg3 = &temp3;
53529 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53530 }
53531 {
53532 arg4 = &temp4;
53533 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53534 }
53535 ecode5 = SWIG_AsVal_int(obj4, &val5);
53536 if (!SWIG_IsOK(ecode5)) {
53537 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
53538 }
53539 arg5 = static_cast< int >(val5);
53540 ecode6 = SWIG_AsVal_int(obj5, &val6);
53541 if (!SWIG_IsOK(ecode6)) {
53542 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
53543 }
53544 arg6 = static_cast< int >(val6);
53545 if (obj6) {
53546 arg7 = obj6;
53547 }
53548 {
53549 PyThreadState* __tstate = wxPyBeginAllowThreads();
53550 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53551 wxPyEndAllowThreads(__tstate);
53552 if (PyErr_Occurred()) SWIG_fail;
53553 }
53554 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53555 return resultobj;
53556 fail:
53557 return NULL;
53558 }
53559
53560
53561 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53562 PyObject *resultobj = 0;
53563 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53564 wxGBPosition result;
53565 void *argp1 = 0 ;
53566 int res1 = 0 ;
53567 PyObject *swig_obj[1] ;
53568
53569 if (!args) SWIG_fail;
53570 swig_obj[0] = args;
53571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53572 if (!SWIG_IsOK(res1)) {
53573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53574 }
53575 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53576 {
53577 PyThreadState* __tstate = wxPyBeginAllowThreads();
53578 result = ((wxGBSizerItem const *)arg1)->GetPos();
53579 wxPyEndAllowThreads(__tstate);
53580 if (PyErr_Occurred()) SWIG_fail;
53581 }
53582 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53583 return resultobj;
53584 fail:
53585 return NULL;
53586 }
53587
53588
53589 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53590 PyObject *resultobj = 0;
53591 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53592 wxGBSpan result;
53593 void *argp1 = 0 ;
53594 int res1 = 0 ;
53595 PyObject *swig_obj[1] ;
53596
53597 if (!args) SWIG_fail;
53598 swig_obj[0] = args;
53599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53600 if (!SWIG_IsOK(res1)) {
53601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53602 }
53603 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53604 {
53605 PyThreadState* __tstate = wxPyBeginAllowThreads();
53606 result = ((wxGBSizerItem const *)arg1)->GetSpan();
53607 wxPyEndAllowThreads(__tstate);
53608 if (PyErr_Occurred()) SWIG_fail;
53609 }
53610 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
53611 return resultobj;
53612 fail:
53613 return NULL;
53614 }
53615
53616
53617 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53618 PyObject *resultobj = 0;
53619 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53620 wxGBPosition *arg2 = 0 ;
53621 bool result;
53622 void *argp1 = 0 ;
53623 int res1 = 0 ;
53624 wxGBPosition temp2 ;
53625 PyObject * obj0 = 0 ;
53626 PyObject * obj1 = 0 ;
53627 char * kwnames[] = {
53628 (char *) "self",(char *) "pos", NULL
53629 };
53630
53631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
53632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53633 if (!SWIG_IsOK(res1)) {
53634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53635 }
53636 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53637 {
53638 arg2 = &temp2;
53639 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53640 }
53641 {
53642 PyThreadState* __tstate = wxPyBeginAllowThreads();
53643 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
53644 wxPyEndAllowThreads(__tstate);
53645 if (PyErr_Occurred()) SWIG_fail;
53646 }
53647 {
53648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53649 }
53650 return resultobj;
53651 fail:
53652 return NULL;
53653 }
53654
53655
53656 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53657 PyObject *resultobj = 0;
53658 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53659 wxGBSpan *arg2 = 0 ;
53660 bool result;
53661 void *argp1 = 0 ;
53662 int res1 = 0 ;
53663 wxGBSpan temp2 ;
53664 PyObject * obj0 = 0 ;
53665 PyObject * obj1 = 0 ;
53666 char * kwnames[] = {
53667 (char *) "self",(char *) "span", NULL
53668 };
53669
53670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53672 if (!SWIG_IsOK(res1)) {
53673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53674 }
53675 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53676 {
53677 arg2 = &temp2;
53678 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
53679 }
53680 {
53681 PyThreadState* __tstate = wxPyBeginAllowThreads();
53682 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
53683 wxPyEndAllowThreads(__tstate);
53684 if (PyErr_Occurred()) SWIG_fail;
53685 }
53686 {
53687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53688 }
53689 return resultobj;
53690 fail:
53691 return NULL;
53692 }
53693
53694
53695 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53696 PyObject *resultobj = 0;
53697 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53698 wxGBSizerItem *arg2 = 0 ;
53699 bool result;
53700 void *argp1 = 0 ;
53701 int res1 = 0 ;
53702 void *argp2 = 0 ;
53703 int res2 = 0 ;
53704 PyObject * obj0 = 0 ;
53705 PyObject * obj1 = 0 ;
53706 char * kwnames[] = {
53707 (char *) "self",(char *) "other", NULL
53708 };
53709
53710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
53711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53712 if (!SWIG_IsOK(res1)) {
53713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53714 }
53715 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53716 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
53717 if (!SWIG_IsOK(res2)) {
53718 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53719 }
53720 if (!argp2) {
53721 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53722 }
53723 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
53724 {
53725 PyThreadState* __tstate = wxPyBeginAllowThreads();
53726 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
53727 wxPyEndAllowThreads(__tstate);
53728 if (PyErr_Occurred()) SWIG_fail;
53729 }
53730 {
53731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53732 }
53733 return resultobj;
53734 fail:
53735 return NULL;
53736 }
53737
53738
53739 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53740 PyObject *resultobj = 0;
53741 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53742 wxGBPosition *arg2 = 0 ;
53743 wxGBSpan *arg3 = 0 ;
53744 bool result;
53745 void *argp1 = 0 ;
53746 int res1 = 0 ;
53747 wxGBPosition temp2 ;
53748 wxGBSpan temp3 ;
53749 PyObject * obj0 = 0 ;
53750 PyObject * obj1 = 0 ;
53751 PyObject * obj2 = 0 ;
53752 char * kwnames[] = {
53753 (char *) "self",(char *) "pos",(char *) "span", NULL
53754 };
53755
53756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53758 if (!SWIG_IsOK(res1)) {
53759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53760 }
53761 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53762 {
53763 arg2 = &temp2;
53764 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53765 }
53766 {
53767 arg3 = &temp3;
53768 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53769 }
53770 {
53771 PyThreadState* __tstate = wxPyBeginAllowThreads();
53772 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
53773 wxPyEndAllowThreads(__tstate);
53774 if (PyErr_Occurred()) SWIG_fail;
53775 }
53776 {
53777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53778 }
53779 return resultobj;
53780 fail:
53781 return NULL;
53782 }
53783
53784
53785 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53786 PyObject *resultobj = 0;
53787 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53788 wxGBPosition result;
53789 void *argp1 = 0 ;
53790 int res1 = 0 ;
53791 PyObject *swig_obj[1] ;
53792
53793 if (!args) SWIG_fail;
53794 swig_obj[0] = args;
53795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53796 if (!SWIG_IsOK(res1)) {
53797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53798 }
53799 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53800 {
53801 PyThreadState* __tstate = wxPyBeginAllowThreads();
53802 result = wxGBSizerItem_GetEndPos(arg1);
53803 wxPyEndAllowThreads(__tstate);
53804 if (PyErr_Occurred()) SWIG_fail;
53805 }
53806 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53807 return resultobj;
53808 fail:
53809 return NULL;
53810 }
53811
53812
53813 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53814 PyObject *resultobj = 0;
53815 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53816 wxGridBagSizer *result = 0 ;
53817 void *argp1 = 0 ;
53818 int res1 = 0 ;
53819 PyObject *swig_obj[1] ;
53820
53821 if (!args) SWIG_fail;
53822 swig_obj[0] = args;
53823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53824 if (!SWIG_IsOK(res1)) {
53825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53826 }
53827 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53828 {
53829 PyThreadState* __tstate = wxPyBeginAllowThreads();
53830 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
53831 wxPyEndAllowThreads(__tstate);
53832 if (PyErr_Occurred()) SWIG_fail;
53833 }
53834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53835 return resultobj;
53836 fail:
53837 return NULL;
53838 }
53839
53840
53841 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53842 PyObject *resultobj = 0;
53843 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53844 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
53845 void *argp1 = 0 ;
53846 int res1 = 0 ;
53847 void *argp2 = 0 ;
53848 int res2 = 0 ;
53849 PyObject * obj0 = 0 ;
53850 PyObject * obj1 = 0 ;
53851 char * kwnames[] = {
53852 (char *) "self",(char *) "sizer", NULL
53853 };
53854
53855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53857 if (!SWIG_IsOK(res1)) {
53858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53859 }
53860 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53861 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53862 if (!SWIG_IsOK(res2)) {
53863 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
53864 }
53865 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
53866 {
53867 PyThreadState* __tstate = wxPyBeginAllowThreads();
53868 (arg1)->SetGBSizer(arg2);
53869 wxPyEndAllowThreads(__tstate);
53870 if (PyErr_Occurred()) SWIG_fail;
53871 }
53872 resultobj = SWIG_Py_Void();
53873 return resultobj;
53874 fail:
53875 return NULL;
53876 }
53877
53878
53879 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53880 PyObject *obj;
53881 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53882 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
53883 return SWIG_Py_Void();
53884 }
53885
53886 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53887 return SWIG_Python_InitShadowInstance(args);
53888 }
53889
53890 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53891 PyObject *resultobj = 0;
53892 int arg1 = (int) 0 ;
53893 int arg2 = (int) 0 ;
53894 wxGridBagSizer *result = 0 ;
53895 int val1 ;
53896 int ecode1 = 0 ;
53897 int val2 ;
53898 int ecode2 = 0 ;
53899 PyObject * obj0 = 0 ;
53900 PyObject * obj1 = 0 ;
53901 char * kwnames[] = {
53902 (char *) "vgap",(char *) "hgap", NULL
53903 };
53904
53905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53906 if (obj0) {
53907 ecode1 = SWIG_AsVal_int(obj0, &val1);
53908 if (!SWIG_IsOK(ecode1)) {
53909 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
53910 }
53911 arg1 = static_cast< int >(val1);
53912 }
53913 if (obj1) {
53914 ecode2 = SWIG_AsVal_int(obj1, &val2);
53915 if (!SWIG_IsOK(ecode2)) {
53916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
53917 }
53918 arg2 = static_cast< int >(val2);
53919 }
53920 {
53921 PyThreadState* __tstate = wxPyBeginAllowThreads();
53922 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
53923 wxPyEndAllowThreads(__tstate);
53924 if (PyErr_Occurred()) SWIG_fail;
53925 }
53926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
53927 return resultobj;
53928 fail:
53929 return NULL;
53930 }
53931
53932
53933 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53934 PyObject *resultobj = 0;
53935 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53936 PyObject *arg2 = (PyObject *) 0 ;
53937 wxGBPosition *arg3 = 0 ;
53938 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
53939 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
53940 int arg5 = (int) 0 ;
53941 int arg6 = (int) 0 ;
53942 PyObject *arg7 = (PyObject *) NULL ;
53943 wxGBSizerItem *result = 0 ;
53944 void *argp1 = 0 ;
53945 int res1 = 0 ;
53946 wxGBPosition temp3 ;
53947 wxGBSpan temp4 ;
53948 int val5 ;
53949 int ecode5 = 0 ;
53950 int val6 ;
53951 int ecode6 = 0 ;
53952 PyObject * obj0 = 0 ;
53953 PyObject * obj1 = 0 ;
53954 PyObject * obj2 = 0 ;
53955 PyObject * obj3 = 0 ;
53956 PyObject * obj4 = 0 ;
53957 PyObject * obj5 = 0 ;
53958 PyObject * obj6 = 0 ;
53959 char * kwnames[] = {
53960 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53961 };
53962
53963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53965 if (!SWIG_IsOK(res1)) {
53966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53967 }
53968 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53969 arg2 = obj1;
53970 {
53971 arg3 = &temp3;
53972 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53973 }
53974 if (obj3) {
53975 {
53976 arg4 = &temp4;
53977 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53978 }
53979 }
53980 if (obj4) {
53981 ecode5 = SWIG_AsVal_int(obj4, &val5);
53982 if (!SWIG_IsOK(ecode5)) {
53983 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
53984 }
53985 arg5 = static_cast< int >(val5);
53986 }
53987 if (obj5) {
53988 ecode6 = SWIG_AsVal_int(obj5, &val6);
53989 if (!SWIG_IsOK(ecode6)) {
53990 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
53991 }
53992 arg6 = static_cast< int >(val6);
53993 }
53994 if (obj6) {
53995 arg7 = obj6;
53996 }
53997 {
53998 PyThreadState* __tstate = wxPyBeginAllowThreads();
53999 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
54000 wxPyEndAllowThreads(__tstate);
54001 if (PyErr_Occurred()) SWIG_fail;
54002 }
54003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54004 return resultobj;
54005 fail:
54006 return NULL;
54007 }
54008
54009
54010 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54011 PyObject *resultobj = 0;
54012 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54013 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54014 wxGBSizerItem *result = 0 ;
54015 void *argp1 = 0 ;
54016 int res1 = 0 ;
54017 int res2 = 0 ;
54018 PyObject * obj0 = 0 ;
54019 PyObject * obj1 = 0 ;
54020 char * kwnames[] = {
54021 (char *) "self",(char *) "item", NULL
54022 };
54023
54024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
54025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54026 if (!SWIG_IsOK(res1)) {
54027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54028 }
54029 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54030 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
54031 if (!SWIG_IsOK(res2)) {
54032 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54033 }
54034 {
54035 PyThreadState* __tstate = wxPyBeginAllowThreads();
54036 result = (wxGBSizerItem *)(arg1)->Add(arg2);
54037 wxPyEndAllowThreads(__tstate);
54038 if (PyErr_Occurred()) SWIG_fail;
54039 }
54040 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54041 return resultobj;
54042 fail:
54043 return NULL;
54044 }
54045
54046
54047 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54048 PyObject *resultobj = 0;
54049 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54050 int arg2 ;
54051 int arg3 ;
54052 wxSize result;
54053 void *argp1 = 0 ;
54054 int res1 = 0 ;
54055 int val2 ;
54056 int ecode2 = 0 ;
54057 int val3 ;
54058 int ecode3 = 0 ;
54059 PyObject * obj0 = 0 ;
54060 PyObject * obj1 = 0 ;
54061 PyObject * obj2 = 0 ;
54062 char * kwnames[] = {
54063 (char *) "self",(char *) "row",(char *) "col", NULL
54064 };
54065
54066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54068 if (!SWIG_IsOK(res1)) {
54069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54070 }
54071 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54072 ecode2 = SWIG_AsVal_int(obj1, &val2);
54073 if (!SWIG_IsOK(ecode2)) {
54074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
54075 }
54076 arg2 = static_cast< int >(val2);
54077 ecode3 = SWIG_AsVal_int(obj2, &val3);
54078 if (!SWIG_IsOK(ecode3)) {
54079 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
54080 }
54081 arg3 = static_cast< int >(val3);
54082 {
54083 PyThreadState* __tstate = wxPyBeginAllowThreads();
54084 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
54085 wxPyEndAllowThreads(__tstate);
54086 if (PyErr_Occurred()) SWIG_fail;
54087 }
54088 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54089 return resultobj;
54090 fail:
54091 return NULL;
54092 }
54093
54094
54095 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54096 PyObject *resultobj = 0;
54097 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54098 wxSize result;
54099 void *argp1 = 0 ;
54100 int res1 = 0 ;
54101 PyObject *swig_obj[1] ;
54102
54103 if (!args) SWIG_fail;
54104 swig_obj[0] = args;
54105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54106 if (!SWIG_IsOK(res1)) {
54107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54108 }
54109 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54110 {
54111 PyThreadState* __tstate = wxPyBeginAllowThreads();
54112 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
54113 wxPyEndAllowThreads(__tstate);
54114 if (PyErr_Occurred()) SWIG_fail;
54115 }
54116 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54117 return resultobj;
54118 fail:
54119 return NULL;
54120 }
54121
54122
54123 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54124 PyObject *resultobj = 0;
54125 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54126 wxSize *arg2 = 0 ;
54127 void *argp1 = 0 ;
54128 int res1 = 0 ;
54129 wxSize temp2 ;
54130 PyObject * obj0 = 0 ;
54131 PyObject * obj1 = 0 ;
54132 char * kwnames[] = {
54133 (char *) "self",(char *) "sz", NULL
54134 };
54135
54136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
54137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54138 if (!SWIG_IsOK(res1)) {
54139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54140 }
54141 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54142 {
54143 arg2 = &temp2;
54144 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
54145 }
54146 {
54147 PyThreadState* __tstate = wxPyBeginAllowThreads();
54148 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
54149 wxPyEndAllowThreads(__tstate);
54150 if (PyErr_Occurred()) SWIG_fail;
54151 }
54152 resultobj = SWIG_Py_Void();
54153 return resultobj;
54154 fail:
54155 return NULL;
54156 }
54157
54158
54159 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54160 PyObject *resultobj = 0;
54161 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54162 wxWindow *arg2 = (wxWindow *) 0 ;
54163 wxGBPosition result;
54164 void *argp1 = 0 ;
54165 int res1 = 0 ;
54166 void *argp2 = 0 ;
54167 int res2 = 0 ;
54168
54169 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54171 if (!SWIG_IsOK(res1)) {
54172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54173 }
54174 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54175 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54176 if (!SWIG_IsOK(res2)) {
54177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54178 }
54179 arg2 = reinterpret_cast< wxWindow * >(argp2);
54180 {
54181 PyThreadState* __tstate = wxPyBeginAllowThreads();
54182 result = (arg1)->GetItemPosition(arg2);
54183 wxPyEndAllowThreads(__tstate);
54184 if (PyErr_Occurred()) SWIG_fail;
54185 }
54186 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54187 return resultobj;
54188 fail:
54189 return NULL;
54190 }
54191
54192
54193 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54194 PyObject *resultobj = 0;
54195 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54196 wxSizer *arg2 = (wxSizer *) 0 ;
54197 wxGBPosition result;
54198 void *argp1 = 0 ;
54199 int res1 = 0 ;
54200 void *argp2 = 0 ;
54201 int res2 = 0 ;
54202
54203 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54205 if (!SWIG_IsOK(res1)) {
54206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54207 }
54208 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54209 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54210 if (!SWIG_IsOK(res2)) {
54211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54212 }
54213 arg2 = reinterpret_cast< wxSizer * >(argp2);
54214 {
54215 PyThreadState* __tstate = wxPyBeginAllowThreads();
54216 result = (arg1)->GetItemPosition(arg2);
54217 wxPyEndAllowThreads(__tstate);
54218 if (PyErr_Occurred()) SWIG_fail;
54219 }
54220 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54221 return resultobj;
54222 fail:
54223 return NULL;
54224 }
54225
54226
54227 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54228 PyObject *resultobj = 0;
54229 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54230 size_t arg2 ;
54231 wxGBPosition result;
54232 void *argp1 = 0 ;
54233 int res1 = 0 ;
54234 size_t val2 ;
54235 int ecode2 = 0 ;
54236
54237 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54239 if (!SWIG_IsOK(res1)) {
54240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54241 }
54242 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54243 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54244 if (!SWIG_IsOK(ecode2)) {
54245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54246 }
54247 arg2 = static_cast< size_t >(val2);
54248 {
54249 PyThreadState* __tstate = wxPyBeginAllowThreads();
54250 result = (arg1)->GetItemPosition(arg2);
54251 wxPyEndAllowThreads(__tstate);
54252 if (PyErr_Occurred()) SWIG_fail;
54253 }
54254 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54255 return resultobj;
54256 fail:
54257 return NULL;
54258 }
54259
54260
54261 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
54262 int argc;
54263 PyObject *argv[3];
54264
54265 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
54266 --argc;
54267 if (argc == 2) {
54268 int _v = 0;
54269 {
54270 void *vptr = 0;
54271 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54272 _v = SWIG_CheckState(res);
54273 }
54274 if (!_v) goto check_1;
54275 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
54276 }
54277 check_1:
54278
54279 if (argc == 2) {
54280 int _v = 0;
54281 {
54282 void *vptr = 0;
54283 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54284 _v = SWIG_CheckState(res);
54285 }
54286 if (!_v) goto check_2;
54287 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
54288 }
54289 check_2:
54290
54291 if (argc == 2) {
54292 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
54293 }
54294
54295 fail:
54296 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
54297 return NULL;
54298 }
54299
54300
54301 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54302 PyObject *resultobj = 0;
54303 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54304 wxWindow *arg2 = (wxWindow *) 0 ;
54305 wxGBPosition *arg3 = 0 ;
54306 bool result;
54307 void *argp1 = 0 ;
54308 int res1 = 0 ;
54309 void *argp2 = 0 ;
54310 int res2 = 0 ;
54311 wxGBPosition temp3 ;
54312
54313 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54315 if (!SWIG_IsOK(res1)) {
54316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54317 }
54318 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54319 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54320 if (!SWIG_IsOK(res2)) {
54321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54322 }
54323 arg2 = reinterpret_cast< wxWindow * >(argp2);
54324 {
54325 arg3 = &temp3;
54326 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54327 }
54328 {
54329 PyThreadState* __tstate = wxPyBeginAllowThreads();
54330 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54331 wxPyEndAllowThreads(__tstate);
54332 if (PyErr_Occurred()) SWIG_fail;
54333 }
54334 {
54335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54336 }
54337 return resultobj;
54338 fail:
54339 return NULL;
54340 }
54341
54342
54343 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54344 PyObject *resultobj = 0;
54345 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54346 wxSizer *arg2 = (wxSizer *) 0 ;
54347 wxGBPosition *arg3 = 0 ;
54348 bool result;
54349 void *argp1 = 0 ;
54350 int res1 = 0 ;
54351 void *argp2 = 0 ;
54352 int res2 = 0 ;
54353 wxGBPosition temp3 ;
54354
54355 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54357 if (!SWIG_IsOK(res1)) {
54358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54359 }
54360 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54361 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54362 if (!SWIG_IsOK(res2)) {
54363 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54364 }
54365 arg2 = reinterpret_cast< wxSizer * >(argp2);
54366 {
54367 arg3 = &temp3;
54368 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54369 }
54370 {
54371 PyThreadState* __tstate = wxPyBeginAllowThreads();
54372 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54373 wxPyEndAllowThreads(__tstate);
54374 if (PyErr_Occurred()) SWIG_fail;
54375 }
54376 {
54377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54378 }
54379 return resultobj;
54380 fail:
54381 return NULL;
54382 }
54383
54384
54385 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54386 PyObject *resultobj = 0;
54387 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54388 size_t arg2 ;
54389 wxGBPosition *arg3 = 0 ;
54390 bool result;
54391 void *argp1 = 0 ;
54392 int res1 = 0 ;
54393 size_t val2 ;
54394 int ecode2 = 0 ;
54395 wxGBPosition temp3 ;
54396
54397 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54399 if (!SWIG_IsOK(res1)) {
54400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54401 }
54402 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54403 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54404 if (!SWIG_IsOK(ecode2)) {
54405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54406 }
54407 arg2 = static_cast< size_t >(val2);
54408 {
54409 arg3 = &temp3;
54410 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54411 }
54412 {
54413 PyThreadState* __tstate = wxPyBeginAllowThreads();
54414 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54415 wxPyEndAllowThreads(__tstate);
54416 if (PyErr_Occurred()) SWIG_fail;
54417 }
54418 {
54419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54420 }
54421 return resultobj;
54422 fail:
54423 return NULL;
54424 }
54425
54426
54427 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
54428 int argc;
54429 PyObject *argv[4];
54430
54431 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
54432 --argc;
54433 if (argc == 3) {
54434 int _v = 0;
54435 {
54436 void *vptr = 0;
54437 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54438 _v = SWIG_CheckState(res);
54439 }
54440 if (!_v) goto check_1;
54441 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
54442 }
54443 check_1:
54444
54445 if (argc == 3) {
54446 int _v = 0;
54447 {
54448 void *vptr = 0;
54449 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54450 _v = SWIG_CheckState(res);
54451 }
54452 if (!_v) goto check_2;
54453 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
54454 }
54455 check_2:
54456
54457 if (argc == 3) {
54458 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
54459 }
54460
54461 fail:
54462 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
54463 return NULL;
54464 }
54465
54466
54467 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54468 PyObject *resultobj = 0;
54469 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54470 wxWindow *arg2 = (wxWindow *) 0 ;
54471 wxGBSpan result;
54472 void *argp1 = 0 ;
54473 int res1 = 0 ;
54474 void *argp2 = 0 ;
54475 int res2 = 0 ;
54476
54477 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54479 if (!SWIG_IsOK(res1)) {
54480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54481 }
54482 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54483 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54484 if (!SWIG_IsOK(res2)) {
54485 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54486 }
54487 arg2 = reinterpret_cast< wxWindow * >(argp2);
54488 {
54489 PyThreadState* __tstate = wxPyBeginAllowThreads();
54490 result = (arg1)->GetItemSpan(arg2);
54491 wxPyEndAllowThreads(__tstate);
54492 if (PyErr_Occurred()) SWIG_fail;
54493 }
54494 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54495 return resultobj;
54496 fail:
54497 return NULL;
54498 }
54499
54500
54501 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54502 PyObject *resultobj = 0;
54503 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54504 wxSizer *arg2 = (wxSizer *) 0 ;
54505 wxGBSpan result;
54506 void *argp1 = 0 ;
54507 int res1 = 0 ;
54508 void *argp2 = 0 ;
54509 int res2 = 0 ;
54510
54511 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54513 if (!SWIG_IsOK(res1)) {
54514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54515 }
54516 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54517 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54518 if (!SWIG_IsOK(res2)) {
54519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54520 }
54521 arg2 = reinterpret_cast< wxSizer * >(argp2);
54522 {
54523 PyThreadState* __tstate = wxPyBeginAllowThreads();
54524 result = (arg1)->GetItemSpan(arg2);
54525 wxPyEndAllowThreads(__tstate);
54526 if (PyErr_Occurred()) SWIG_fail;
54527 }
54528 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54529 return resultobj;
54530 fail:
54531 return NULL;
54532 }
54533
54534
54535 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54536 PyObject *resultobj = 0;
54537 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54538 size_t arg2 ;
54539 wxGBSpan result;
54540 void *argp1 = 0 ;
54541 int res1 = 0 ;
54542 size_t val2 ;
54543 int ecode2 = 0 ;
54544
54545 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54547 if (!SWIG_IsOK(res1)) {
54548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54549 }
54550 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54551 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54552 if (!SWIG_IsOK(ecode2)) {
54553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54554 }
54555 arg2 = static_cast< size_t >(val2);
54556 {
54557 PyThreadState* __tstate = wxPyBeginAllowThreads();
54558 result = (arg1)->GetItemSpan(arg2);
54559 wxPyEndAllowThreads(__tstate);
54560 if (PyErr_Occurred()) SWIG_fail;
54561 }
54562 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54563 return resultobj;
54564 fail:
54565 return NULL;
54566 }
54567
54568
54569 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
54570 int argc;
54571 PyObject *argv[3];
54572
54573 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
54574 --argc;
54575 if (argc == 2) {
54576 int _v = 0;
54577 {
54578 void *vptr = 0;
54579 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54580 _v = SWIG_CheckState(res);
54581 }
54582 if (!_v) goto check_1;
54583 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
54584 }
54585 check_1:
54586
54587 if (argc == 2) {
54588 int _v = 0;
54589 {
54590 void *vptr = 0;
54591 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54592 _v = SWIG_CheckState(res);
54593 }
54594 if (!_v) goto check_2;
54595 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
54596 }
54597 check_2:
54598
54599 if (argc == 2) {
54600 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
54601 }
54602
54603 fail:
54604 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
54605 return NULL;
54606 }
54607
54608
54609 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54610 PyObject *resultobj = 0;
54611 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54612 wxWindow *arg2 = (wxWindow *) 0 ;
54613 wxGBSpan *arg3 = 0 ;
54614 bool result;
54615 void *argp1 = 0 ;
54616 int res1 = 0 ;
54617 void *argp2 = 0 ;
54618 int res2 = 0 ;
54619 wxGBSpan temp3 ;
54620
54621 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54623 if (!SWIG_IsOK(res1)) {
54624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54625 }
54626 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54627 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54628 if (!SWIG_IsOK(res2)) {
54629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54630 }
54631 arg2 = reinterpret_cast< wxWindow * >(argp2);
54632 {
54633 arg3 = &temp3;
54634 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54635 }
54636 {
54637 PyThreadState* __tstate = wxPyBeginAllowThreads();
54638 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54639 wxPyEndAllowThreads(__tstate);
54640 if (PyErr_Occurred()) SWIG_fail;
54641 }
54642 {
54643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54644 }
54645 return resultobj;
54646 fail:
54647 return NULL;
54648 }
54649
54650
54651 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54652 PyObject *resultobj = 0;
54653 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54654 wxSizer *arg2 = (wxSizer *) 0 ;
54655 wxGBSpan *arg3 = 0 ;
54656 bool result;
54657 void *argp1 = 0 ;
54658 int res1 = 0 ;
54659 void *argp2 = 0 ;
54660 int res2 = 0 ;
54661 wxGBSpan temp3 ;
54662
54663 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54665 if (!SWIG_IsOK(res1)) {
54666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54667 }
54668 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54669 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54670 if (!SWIG_IsOK(res2)) {
54671 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54672 }
54673 arg2 = reinterpret_cast< wxSizer * >(argp2);
54674 {
54675 arg3 = &temp3;
54676 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54677 }
54678 {
54679 PyThreadState* __tstate = wxPyBeginAllowThreads();
54680 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54681 wxPyEndAllowThreads(__tstate);
54682 if (PyErr_Occurred()) SWIG_fail;
54683 }
54684 {
54685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54686 }
54687 return resultobj;
54688 fail:
54689 return NULL;
54690 }
54691
54692
54693 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54694 PyObject *resultobj = 0;
54695 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54696 size_t arg2 ;
54697 wxGBSpan *arg3 = 0 ;
54698 bool result;
54699 void *argp1 = 0 ;
54700 int res1 = 0 ;
54701 size_t val2 ;
54702 int ecode2 = 0 ;
54703 wxGBSpan temp3 ;
54704
54705 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54707 if (!SWIG_IsOK(res1)) {
54708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54709 }
54710 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54711 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54712 if (!SWIG_IsOK(ecode2)) {
54713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54714 }
54715 arg2 = static_cast< size_t >(val2);
54716 {
54717 arg3 = &temp3;
54718 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54719 }
54720 {
54721 PyThreadState* __tstate = wxPyBeginAllowThreads();
54722 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54723 wxPyEndAllowThreads(__tstate);
54724 if (PyErr_Occurred()) SWIG_fail;
54725 }
54726 {
54727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54728 }
54729 return resultobj;
54730 fail:
54731 return NULL;
54732 }
54733
54734
54735 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
54736 int argc;
54737 PyObject *argv[4];
54738
54739 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
54740 --argc;
54741 if (argc == 3) {
54742 int _v = 0;
54743 {
54744 void *vptr = 0;
54745 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54746 _v = SWIG_CheckState(res);
54747 }
54748 if (!_v) goto check_1;
54749 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
54750 }
54751 check_1:
54752
54753 if (argc == 3) {
54754 int _v = 0;
54755 {
54756 void *vptr = 0;
54757 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54758 _v = SWIG_CheckState(res);
54759 }
54760 if (!_v) goto check_2;
54761 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
54762 }
54763 check_2:
54764
54765 if (argc == 3) {
54766 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
54767 }
54768
54769 fail:
54770 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
54771 return NULL;
54772 }
54773
54774
54775 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54776 PyObject *resultobj = 0;
54777 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54778 wxWindow *arg2 = (wxWindow *) 0 ;
54779 wxGBSizerItem *result = 0 ;
54780 void *argp1 = 0 ;
54781 int res1 = 0 ;
54782 void *argp2 = 0 ;
54783 int res2 = 0 ;
54784
54785 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54787 if (!SWIG_IsOK(res1)) {
54788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54789 }
54790 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54791 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54792 if (!SWIG_IsOK(res2)) {
54793 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
54794 }
54795 arg2 = reinterpret_cast< wxWindow * >(argp2);
54796 {
54797 PyThreadState* __tstate = wxPyBeginAllowThreads();
54798 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54799 wxPyEndAllowThreads(__tstate);
54800 if (PyErr_Occurred()) SWIG_fail;
54801 }
54802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54803 return resultobj;
54804 fail:
54805 return NULL;
54806 }
54807
54808
54809 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54810 PyObject *resultobj = 0;
54811 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54812 wxSizer *arg2 = (wxSizer *) 0 ;
54813 wxGBSizerItem *result = 0 ;
54814 void *argp1 = 0 ;
54815 int res1 = 0 ;
54816 void *argp2 = 0 ;
54817 int res2 = 0 ;
54818
54819 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54821 if (!SWIG_IsOK(res1)) {
54822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54823 }
54824 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54825 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54826 if (!SWIG_IsOK(res2)) {
54827 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
54828 }
54829 arg2 = reinterpret_cast< wxSizer * >(argp2);
54830 {
54831 PyThreadState* __tstate = wxPyBeginAllowThreads();
54832 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54833 wxPyEndAllowThreads(__tstate);
54834 if (PyErr_Occurred()) SWIG_fail;
54835 }
54836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54837 return resultobj;
54838 fail:
54839 return NULL;
54840 }
54841
54842
54843 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
54844 int argc;
54845 PyObject *argv[3];
54846
54847 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
54848 --argc;
54849 if (argc == 2) {
54850 int _v = 0;
54851 {
54852 void *vptr = 0;
54853 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54854 _v = SWIG_CheckState(res);
54855 }
54856 if (!_v) goto check_1;
54857 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
54858 }
54859 check_1:
54860
54861 if (argc == 2) {
54862 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
54863 }
54864
54865 fail:
54866 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
54867 return NULL;
54868 }
54869
54870
54871 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54872 PyObject *resultobj = 0;
54873 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54874 wxGBPosition *arg2 = 0 ;
54875 wxGBSizerItem *result = 0 ;
54876 void *argp1 = 0 ;
54877 int res1 = 0 ;
54878 wxGBPosition temp2 ;
54879 PyObject * obj0 = 0 ;
54880 PyObject * obj1 = 0 ;
54881 char * kwnames[] = {
54882 (char *) "self",(char *) "pos", NULL
54883 };
54884
54885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54887 if (!SWIG_IsOK(res1)) {
54888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54889 }
54890 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54891 {
54892 arg2 = &temp2;
54893 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54894 }
54895 {
54896 PyThreadState* __tstate = wxPyBeginAllowThreads();
54897 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
54898 wxPyEndAllowThreads(__tstate);
54899 if (PyErr_Occurred()) SWIG_fail;
54900 }
54901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54902 return resultobj;
54903 fail:
54904 return NULL;
54905 }
54906
54907
54908 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54909 PyObject *resultobj = 0;
54910 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54911 wxPoint *arg2 = 0 ;
54912 wxGBSizerItem *result = 0 ;
54913 void *argp1 = 0 ;
54914 int res1 = 0 ;
54915 wxPoint temp2 ;
54916 PyObject * obj0 = 0 ;
54917 PyObject * obj1 = 0 ;
54918 char * kwnames[] = {
54919 (char *) "self",(char *) "pt", NULL
54920 };
54921
54922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
54923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54924 if (!SWIG_IsOK(res1)) {
54925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54926 }
54927 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54928 {
54929 arg2 = &temp2;
54930 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
54931 }
54932 {
54933 PyThreadState* __tstate = wxPyBeginAllowThreads();
54934 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
54935 wxPyEndAllowThreads(__tstate);
54936 if (PyErr_Occurred()) SWIG_fail;
54937 }
54938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54939 return resultobj;
54940 fail:
54941 return NULL;
54942 }
54943
54944
54945 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54946 PyObject *resultobj = 0;
54947 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54948 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54949 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
54950 bool result;
54951 void *argp1 = 0 ;
54952 int res1 = 0 ;
54953 void *argp2 = 0 ;
54954 int res2 = 0 ;
54955 void *argp3 = 0 ;
54956 int res3 = 0 ;
54957 PyObject * obj0 = 0 ;
54958 PyObject * obj1 = 0 ;
54959 PyObject * obj2 = 0 ;
54960 char * kwnames[] = {
54961 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
54962 };
54963
54964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54966 if (!SWIG_IsOK(res1)) {
54967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54968 }
54969 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54970 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54971 if (!SWIG_IsOK(res2)) {
54972 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54973 }
54974 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
54975 if (obj2) {
54976 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54977 if (!SWIG_IsOK(res3)) {
54978 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
54979 }
54980 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
54981 }
54982 {
54983 PyThreadState* __tstate = wxPyBeginAllowThreads();
54984 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
54985 wxPyEndAllowThreads(__tstate);
54986 if (PyErr_Occurred()) SWIG_fail;
54987 }
54988 {
54989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54990 }
54991 return resultobj;
54992 fail:
54993 return NULL;
54994 }
54995
54996
54997 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54998 PyObject *resultobj = 0;
54999 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55000 wxGBPosition *arg2 = 0 ;
55001 wxGBSpan *arg3 = 0 ;
55002 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
55003 bool result;
55004 void *argp1 = 0 ;
55005 int res1 = 0 ;
55006 wxGBPosition temp2 ;
55007 wxGBSpan temp3 ;
55008 void *argp4 = 0 ;
55009 int res4 = 0 ;
55010 PyObject * obj0 = 0 ;
55011 PyObject * obj1 = 0 ;
55012 PyObject * obj2 = 0 ;
55013 PyObject * obj3 = 0 ;
55014 char * kwnames[] = {
55015 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
55016 };
55017
55018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55020 if (!SWIG_IsOK(res1)) {
55021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55022 }
55023 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55024 {
55025 arg2 = &temp2;
55026 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55027 }
55028 {
55029 arg3 = &temp3;
55030 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55031 }
55032 if (obj3) {
55033 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55034 if (!SWIG_IsOK(res4)) {
55035 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
55036 }
55037 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
55038 }
55039 {
55040 PyThreadState* __tstate = wxPyBeginAllowThreads();
55041 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
55042 wxPyEndAllowThreads(__tstate);
55043 if (PyErr_Occurred()) SWIG_fail;
55044 }
55045 {
55046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55047 }
55048 return resultobj;
55049 fail:
55050 return NULL;
55051 }
55052
55053
55054 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55055 PyObject *obj;
55056 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55057 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
55058 return SWIG_Py_Void();
55059 }
55060
55061 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55062 return SWIG_Python_InitShadowInstance(args);
55063 }
55064
55065 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55066 PyObject *resultobj = 0;
55067 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55068 wxRelationship arg2 ;
55069 wxWindow *arg3 = (wxWindow *) 0 ;
55070 wxEdge arg4 ;
55071 int arg5 = (int) 0 ;
55072 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
55073 void *argp1 = 0 ;
55074 int res1 = 0 ;
55075 int val2 ;
55076 int ecode2 = 0 ;
55077 void *argp3 = 0 ;
55078 int res3 = 0 ;
55079 int val4 ;
55080 int ecode4 = 0 ;
55081 int val5 ;
55082 int ecode5 = 0 ;
55083 int val6 ;
55084 int ecode6 = 0 ;
55085 PyObject * obj0 = 0 ;
55086 PyObject * obj1 = 0 ;
55087 PyObject * obj2 = 0 ;
55088 PyObject * obj3 = 0 ;
55089 PyObject * obj4 = 0 ;
55090 PyObject * obj5 = 0 ;
55091 char * kwnames[] = {
55092 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
55093 };
55094
55095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55097 if (!SWIG_IsOK(res1)) {
55098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55099 }
55100 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55101 ecode2 = SWIG_AsVal_int(obj1, &val2);
55102 if (!SWIG_IsOK(ecode2)) {
55103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
55104 }
55105 arg2 = static_cast< wxRelationship >(val2);
55106 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55107 if (!SWIG_IsOK(res3)) {
55108 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
55109 }
55110 arg3 = reinterpret_cast< wxWindow * >(argp3);
55111 ecode4 = SWIG_AsVal_int(obj3, &val4);
55112 if (!SWIG_IsOK(ecode4)) {
55113 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
55114 }
55115 arg4 = static_cast< wxEdge >(val4);
55116 if (obj4) {
55117 ecode5 = SWIG_AsVal_int(obj4, &val5);
55118 if (!SWIG_IsOK(ecode5)) {
55119 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
55120 }
55121 arg5 = static_cast< int >(val5);
55122 }
55123 if (obj5) {
55124 ecode6 = SWIG_AsVal_int(obj5, &val6);
55125 if (!SWIG_IsOK(ecode6)) {
55126 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
55127 }
55128 arg6 = static_cast< int >(val6);
55129 }
55130 {
55131 PyThreadState* __tstate = wxPyBeginAllowThreads();
55132 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
55133 wxPyEndAllowThreads(__tstate);
55134 if (PyErr_Occurred()) SWIG_fail;
55135 }
55136 resultobj = SWIG_Py_Void();
55137 return resultobj;
55138 fail:
55139 return NULL;
55140 }
55141
55142
55143 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55144 PyObject *resultobj = 0;
55145 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55146 wxWindow *arg2 = (wxWindow *) 0 ;
55147 int arg3 = (int) 0 ;
55148 void *argp1 = 0 ;
55149 int res1 = 0 ;
55150 void *argp2 = 0 ;
55151 int res2 = 0 ;
55152 int val3 ;
55153 int ecode3 = 0 ;
55154 PyObject * obj0 = 0 ;
55155 PyObject * obj1 = 0 ;
55156 PyObject * obj2 = 0 ;
55157 char * kwnames[] = {
55158 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55159 };
55160
55161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55163 if (!SWIG_IsOK(res1)) {
55164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55165 }
55166 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55167 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55168 if (!SWIG_IsOK(res2)) {
55169 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55170 }
55171 arg2 = reinterpret_cast< wxWindow * >(argp2);
55172 if (obj2) {
55173 ecode3 = SWIG_AsVal_int(obj2, &val3);
55174 if (!SWIG_IsOK(ecode3)) {
55175 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
55176 }
55177 arg3 = static_cast< int >(val3);
55178 }
55179 {
55180 PyThreadState* __tstate = wxPyBeginAllowThreads();
55181 (arg1)->LeftOf(arg2,arg3);
55182 wxPyEndAllowThreads(__tstate);
55183 if (PyErr_Occurred()) SWIG_fail;
55184 }
55185 resultobj = SWIG_Py_Void();
55186 return resultobj;
55187 fail:
55188 return NULL;
55189 }
55190
55191
55192 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55193 PyObject *resultobj = 0;
55194 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55195 wxWindow *arg2 = (wxWindow *) 0 ;
55196 int arg3 = (int) 0 ;
55197 void *argp1 = 0 ;
55198 int res1 = 0 ;
55199 void *argp2 = 0 ;
55200 int res2 = 0 ;
55201 int val3 ;
55202 int ecode3 = 0 ;
55203 PyObject * obj0 = 0 ;
55204 PyObject * obj1 = 0 ;
55205 PyObject * obj2 = 0 ;
55206 char * kwnames[] = {
55207 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55208 };
55209
55210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55212 if (!SWIG_IsOK(res1)) {
55213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55214 }
55215 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55216 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55217 if (!SWIG_IsOK(res2)) {
55218 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55219 }
55220 arg2 = reinterpret_cast< wxWindow * >(argp2);
55221 if (obj2) {
55222 ecode3 = SWIG_AsVal_int(obj2, &val3);
55223 if (!SWIG_IsOK(ecode3)) {
55224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
55225 }
55226 arg3 = static_cast< int >(val3);
55227 }
55228 {
55229 PyThreadState* __tstate = wxPyBeginAllowThreads();
55230 (arg1)->RightOf(arg2,arg3);
55231 wxPyEndAllowThreads(__tstate);
55232 if (PyErr_Occurred()) SWIG_fail;
55233 }
55234 resultobj = SWIG_Py_Void();
55235 return resultobj;
55236 fail:
55237 return NULL;
55238 }
55239
55240
55241 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55242 PyObject *resultobj = 0;
55243 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55244 wxWindow *arg2 = (wxWindow *) 0 ;
55245 int arg3 = (int) 0 ;
55246 void *argp1 = 0 ;
55247 int res1 = 0 ;
55248 void *argp2 = 0 ;
55249 int res2 = 0 ;
55250 int val3 ;
55251 int ecode3 = 0 ;
55252 PyObject * obj0 = 0 ;
55253 PyObject * obj1 = 0 ;
55254 PyObject * obj2 = 0 ;
55255 char * kwnames[] = {
55256 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55257 };
55258
55259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55261 if (!SWIG_IsOK(res1)) {
55262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55263 }
55264 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55265 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55266 if (!SWIG_IsOK(res2)) {
55267 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
55268 }
55269 arg2 = reinterpret_cast< wxWindow * >(argp2);
55270 if (obj2) {
55271 ecode3 = SWIG_AsVal_int(obj2, &val3);
55272 if (!SWIG_IsOK(ecode3)) {
55273 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
55274 }
55275 arg3 = static_cast< int >(val3);
55276 }
55277 {
55278 PyThreadState* __tstate = wxPyBeginAllowThreads();
55279 (arg1)->Above(arg2,arg3);
55280 wxPyEndAllowThreads(__tstate);
55281 if (PyErr_Occurred()) SWIG_fail;
55282 }
55283 resultobj = SWIG_Py_Void();
55284 return resultobj;
55285 fail:
55286 return NULL;
55287 }
55288
55289
55290 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55291 PyObject *resultobj = 0;
55292 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55293 wxWindow *arg2 = (wxWindow *) 0 ;
55294 int arg3 = (int) 0 ;
55295 void *argp1 = 0 ;
55296 int res1 = 0 ;
55297 void *argp2 = 0 ;
55298 int res2 = 0 ;
55299 int val3 ;
55300 int ecode3 = 0 ;
55301 PyObject * obj0 = 0 ;
55302 PyObject * obj1 = 0 ;
55303 PyObject * obj2 = 0 ;
55304 char * kwnames[] = {
55305 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55306 };
55307
55308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55310 if (!SWIG_IsOK(res1)) {
55311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55312 }
55313 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55314 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55315 if (!SWIG_IsOK(res2)) {
55316 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
55317 }
55318 arg2 = reinterpret_cast< wxWindow * >(argp2);
55319 if (obj2) {
55320 ecode3 = SWIG_AsVal_int(obj2, &val3);
55321 if (!SWIG_IsOK(ecode3)) {
55322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
55323 }
55324 arg3 = static_cast< int >(val3);
55325 }
55326 {
55327 PyThreadState* __tstate = wxPyBeginAllowThreads();
55328 (arg1)->Below(arg2,arg3);
55329 wxPyEndAllowThreads(__tstate);
55330 if (PyErr_Occurred()) SWIG_fail;
55331 }
55332 resultobj = SWIG_Py_Void();
55333 return resultobj;
55334 fail:
55335 return NULL;
55336 }
55337
55338
55339 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55340 PyObject *resultobj = 0;
55341 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55342 wxWindow *arg2 = (wxWindow *) 0 ;
55343 wxEdge arg3 ;
55344 int arg4 = (int) 0 ;
55345 void *argp1 = 0 ;
55346 int res1 = 0 ;
55347 void *argp2 = 0 ;
55348 int res2 = 0 ;
55349 int val3 ;
55350 int ecode3 = 0 ;
55351 int val4 ;
55352 int ecode4 = 0 ;
55353 PyObject * obj0 = 0 ;
55354 PyObject * obj1 = 0 ;
55355 PyObject * obj2 = 0 ;
55356 PyObject * obj3 = 0 ;
55357 char * kwnames[] = {
55358 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
55359 };
55360
55361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55363 if (!SWIG_IsOK(res1)) {
55364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55365 }
55366 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55367 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55368 if (!SWIG_IsOK(res2)) {
55369 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
55370 }
55371 arg2 = reinterpret_cast< wxWindow * >(argp2);
55372 ecode3 = SWIG_AsVal_int(obj2, &val3);
55373 if (!SWIG_IsOK(ecode3)) {
55374 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
55375 }
55376 arg3 = static_cast< wxEdge >(val3);
55377 if (obj3) {
55378 ecode4 = SWIG_AsVal_int(obj3, &val4);
55379 if (!SWIG_IsOK(ecode4)) {
55380 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
55381 }
55382 arg4 = static_cast< int >(val4);
55383 }
55384 {
55385 PyThreadState* __tstate = wxPyBeginAllowThreads();
55386 (arg1)->SameAs(arg2,arg3,arg4);
55387 wxPyEndAllowThreads(__tstate);
55388 if (PyErr_Occurred()) SWIG_fail;
55389 }
55390 resultobj = SWIG_Py_Void();
55391 return resultobj;
55392 fail:
55393 return NULL;
55394 }
55395
55396
55397 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55398 PyObject *resultobj = 0;
55399 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55400 wxWindow *arg2 = (wxWindow *) 0 ;
55401 wxEdge arg3 ;
55402 int arg4 ;
55403 void *argp1 = 0 ;
55404 int res1 = 0 ;
55405 void *argp2 = 0 ;
55406 int res2 = 0 ;
55407 int val3 ;
55408 int ecode3 = 0 ;
55409 int val4 ;
55410 int ecode4 = 0 ;
55411 PyObject * obj0 = 0 ;
55412 PyObject * obj1 = 0 ;
55413 PyObject * obj2 = 0 ;
55414 PyObject * obj3 = 0 ;
55415 char * kwnames[] = {
55416 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
55417 };
55418
55419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55421 if (!SWIG_IsOK(res1)) {
55422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55423 }
55424 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55425 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55426 if (!SWIG_IsOK(res2)) {
55427 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55428 }
55429 arg2 = reinterpret_cast< wxWindow * >(argp2);
55430 ecode3 = SWIG_AsVal_int(obj2, &val3);
55431 if (!SWIG_IsOK(ecode3)) {
55432 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
55433 }
55434 arg3 = static_cast< wxEdge >(val3);
55435 ecode4 = SWIG_AsVal_int(obj3, &val4);
55436 if (!SWIG_IsOK(ecode4)) {
55437 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
55438 }
55439 arg4 = static_cast< int >(val4);
55440 {
55441 PyThreadState* __tstate = wxPyBeginAllowThreads();
55442 (arg1)->PercentOf(arg2,arg3,arg4);
55443 wxPyEndAllowThreads(__tstate);
55444 if (PyErr_Occurred()) SWIG_fail;
55445 }
55446 resultobj = SWIG_Py_Void();
55447 return resultobj;
55448 fail:
55449 return NULL;
55450 }
55451
55452
55453 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55454 PyObject *resultobj = 0;
55455 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55456 int arg2 ;
55457 void *argp1 = 0 ;
55458 int res1 = 0 ;
55459 int val2 ;
55460 int ecode2 = 0 ;
55461 PyObject * obj0 = 0 ;
55462 PyObject * obj1 = 0 ;
55463 char * kwnames[] = {
55464 (char *) "self",(char *) "val", NULL
55465 };
55466
55467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
55468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55469 if (!SWIG_IsOK(res1)) {
55470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55471 }
55472 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55473 ecode2 = SWIG_AsVal_int(obj1, &val2);
55474 if (!SWIG_IsOK(ecode2)) {
55475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
55476 }
55477 arg2 = static_cast< int >(val2);
55478 {
55479 PyThreadState* __tstate = wxPyBeginAllowThreads();
55480 (arg1)->Absolute(arg2);
55481 wxPyEndAllowThreads(__tstate);
55482 if (PyErr_Occurred()) SWIG_fail;
55483 }
55484 resultobj = SWIG_Py_Void();
55485 return resultobj;
55486 fail:
55487 return NULL;
55488 }
55489
55490
55491 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55492 PyObject *resultobj = 0;
55493 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55494 void *argp1 = 0 ;
55495 int res1 = 0 ;
55496 PyObject *swig_obj[1] ;
55497
55498 if (!args) SWIG_fail;
55499 swig_obj[0] = args;
55500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55501 if (!SWIG_IsOK(res1)) {
55502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55503 }
55504 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55505 {
55506 PyThreadState* __tstate = wxPyBeginAllowThreads();
55507 (arg1)->Unconstrained();
55508 wxPyEndAllowThreads(__tstate);
55509 if (PyErr_Occurred()) SWIG_fail;
55510 }
55511 resultobj = SWIG_Py_Void();
55512 return resultobj;
55513 fail:
55514 return NULL;
55515 }
55516
55517
55518 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55519 PyObject *resultobj = 0;
55520 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55521 void *argp1 = 0 ;
55522 int res1 = 0 ;
55523 PyObject *swig_obj[1] ;
55524
55525 if (!args) SWIG_fail;
55526 swig_obj[0] = args;
55527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55528 if (!SWIG_IsOK(res1)) {
55529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55530 }
55531 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55532 {
55533 PyThreadState* __tstate = wxPyBeginAllowThreads();
55534 (arg1)->AsIs();
55535 wxPyEndAllowThreads(__tstate);
55536 if (PyErr_Occurred()) SWIG_fail;
55537 }
55538 resultobj = SWIG_Py_Void();
55539 return resultobj;
55540 fail:
55541 return NULL;
55542 }
55543
55544
55545 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55546 PyObject *resultobj = 0;
55547 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55548 wxWindow *result = 0 ;
55549 void *argp1 = 0 ;
55550 int res1 = 0 ;
55551 PyObject *swig_obj[1] ;
55552
55553 if (!args) SWIG_fail;
55554 swig_obj[0] = args;
55555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55556 if (!SWIG_IsOK(res1)) {
55557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55558 }
55559 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55560 {
55561 PyThreadState* __tstate = wxPyBeginAllowThreads();
55562 result = (wxWindow *)(arg1)->GetOtherWindow();
55563 wxPyEndAllowThreads(__tstate);
55564 if (PyErr_Occurred()) SWIG_fail;
55565 }
55566 {
55567 resultobj = wxPyMake_wxObject(result, 0);
55568 }
55569 return resultobj;
55570 fail:
55571 return NULL;
55572 }
55573
55574
55575 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55576 PyObject *resultobj = 0;
55577 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55578 wxEdge result;
55579 void *argp1 = 0 ;
55580 int res1 = 0 ;
55581 PyObject *swig_obj[1] ;
55582
55583 if (!args) SWIG_fail;
55584 swig_obj[0] = args;
55585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55586 if (!SWIG_IsOK(res1)) {
55587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55588 }
55589 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55590 {
55591 PyThreadState* __tstate = wxPyBeginAllowThreads();
55592 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
55593 wxPyEndAllowThreads(__tstate);
55594 if (PyErr_Occurred()) SWIG_fail;
55595 }
55596 resultobj = SWIG_From_int(static_cast< int >(result));
55597 return resultobj;
55598 fail:
55599 return NULL;
55600 }
55601
55602
55603 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55604 PyObject *resultobj = 0;
55605 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55606 wxEdge arg2 ;
55607 void *argp1 = 0 ;
55608 int res1 = 0 ;
55609 int val2 ;
55610 int ecode2 = 0 ;
55611 PyObject * obj0 = 0 ;
55612 PyObject * obj1 = 0 ;
55613 char * kwnames[] = {
55614 (char *) "self",(char *) "which", NULL
55615 };
55616
55617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
55618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55619 if (!SWIG_IsOK(res1)) {
55620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55621 }
55622 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55623 ecode2 = SWIG_AsVal_int(obj1, &val2);
55624 if (!SWIG_IsOK(ecode2)) {
55625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55626 }
55627 arg2 = static_cast< wxEdge >(val2);
55628 {
55629 PyThreadState* __tstate = wxPyBeginAllowThreads();
55630 (arg1)->SetEdge(arg2);
55631 wxPyEndAllowThreads(__tstate);
55632 if (PyErr_Occurred()) SWIG_fail;
55633 }
55634 resultobj = SWIG_Py_Void();
55635 return resultobj;
55636 fail:
55637 return NULL;
55638 }
55639
55640
55641 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55642 PyObject *resultobj = 0;
55643 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55644 int arg2 ;
55645 void *argp1 = 0 ;
55646 int res1 = 0 ;
55647 int val2 ;
55648 int ecode2 = 0 ;
55649 PyObject * obj0 = 0 ;
55650 PyObject * obj1 = 0 ;
55651 char * kwnames[] = {
55652 (char *) "self",(char *) "v", NULL
55653 };
55654
55655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
55656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55657 if (!SWIG_IsOK(res1)) {
55658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55659 }
55660 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55661 ecode2 = SWIG_AsVal_int(obj1, &val2);
55662 if (!SWIG_IsOK(ecode2)) {
55663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
55664 }
55665 arg2 = static_cast< int >(val2);
55666 {
55667 PyThreadState* __tstate = wxPyBeginAllowThreads();
55668 (arg1)->SetValue(arg2);
55669 wxPyEndAllowThreads(__tstate);
55670 if (PyErr_Occurred()) SWIG_fail;
55671 }
55672 resultobj = SWIG_Py_Void();
55673 return resultobj;
55674 fail:
55675 return NULL;
55676 }
55677
55678
55679 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55680 PyObject *resultobj = 0;
55681 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55682 int result;
55683 void *argp1 = 0 ;
55684 int res1 = 0 ;
55685 PyObject *swig_obj[1] ;
55686
55687 if (!args) SWIG_fail;
55688 swig_obj[0] = args;
55689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55690 if (!SWIG_IsOK(res1)) {
55691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55692 }
55693 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55694 {
55695 PyThreadState* __tstate = wxPyBeginAllowThreads();
55696 result = (int)(arg1)->GetMargin();
55697 wxPyEndAllowThreads(__tstate);
55698 if (PyErr_Occurred()) SWIG_fail;
55699 }
55700 resultobj = SWIG_From_int(static_cast< int >(result));
55701 return resultobj;
55702 fail:
55703 return NULL;
55704 }
55705
55706
55707 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55708 PyObject *resultobj = 0;
55709 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55710 int arg2 ;
55711 void *argp1 = 0 ;
55712 int res1 = 0 ;
55713 int val2 ;
55714 int ecode2 = 0 ;
55715 PyObject * obj0 = 0 ;
55716 PyObject * obj1 = 0 ;
55717 char * kwnames[] = {
55718 (char *) "self",(char *) "m", NULL
55719 };
55720
55721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
55722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55723 if (!SWIG_IsOK(res1)) {
55724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55725 }
55726 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55727 ecode2 = SWIG_AsVal_int(obj1, &val2);
55728 if (!SWIG_IsOK(ecode2)) {
55729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
55730 }
55731 arg2 = static_cast< int >(val2);
55732 {
55733 PyThreadState* __tstate = wxPyBeginAllowThreads();
55734 (arg1)->SetMargin(arg2);
55735 wxPyEndAllowThreads(__tstate);
55736 if (PyErr_Occurred()) SWIG_fail;
55737 }
55738 resultobj = SWIG_Py_Void();
55739 return resultobj;
55740 fail:
55741 return NULL;
55742 }
55743
55744
55745 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55746 PyObject *resultobj = 0;
55747 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55748 int result;
55749 void *argp1 = 0 ;
55750 int res1 = 0 ;
55751 PyObject *swig_obj[1] ;
55752
55753 if (!args) SWIG_fail;
55754 swig_obj[0] = args;
55755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55756 if (!SWIG_IsOK(res1)) {
55757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55758 }
55759 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55760 {
55761 PyThreadState* __tstate = wxPyBeginAllowThreads();
55762 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
55763 wxPyEndAllowThreads(__tstate);
55764 if (PyErr_Occurred()) SWIG_fail;
55765 }
55766 resultobj = SWIG_From_int(static_cast< int >(result));
55767 return resultobj;
55768 fail:
55769 return NULL;
55770 }
55771
55772
55773 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55774 PyObject *resultobj = 0;
55775 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55776 int result;
55777 void *argp1 = 0 ;
55778 int res1 = 0 ;
55779 PyObject *swig_obj[1] ;
55780
55781 if (!args) SWIG_fail;
55782 swig_obj[0] = args;
55783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55784 if (!SWIG_IsOK(res1)) {
55785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55786 }
55787 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55788 {
55789 PyThreadState* __tstate = wxPyBeginAllowThreads();
55790 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
55791 wxPyEndAllowThreads(__tstate);
55792 if (PyErr_Occurred()) SWIG_fail;
55793 }
55794 resultobj = SWIG_From_int(static_cast< int >(result));
55795 return resultobj;
55796 fail:
55797 return NULL;
55798 }
55799
55800
55801 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55802 PyObject *resultobj = 0;
55803 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55804 int result;
55805 void *argp1 = 0 ;
55806 int res1 = 0 ;
55807 PyObject *swig_obj[1] ;
55808
55809 if (!args) SWIG_fail;
55810 swig_obj[0] = args;
55811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55812 if (!SWIG_IsOK(res1)) {
55813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55814 }
55815 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55816 {
55817 PyThreadState* __tstate = wxPyBeginAllowThreads();
55818 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
55819 wxPyEndAllowThreads(__tstate);
55820 if (PyErr_Occurred()) SWIG_fail;
55821 }
55822 resultobj = SWIG_From_int(static_cast< int >(result));
55823 return resultobj;
55824 fail:
55825 return NULL;
55826 }
55827
55828
55829 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55830 PyObject *resultobj = 0;
55831 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55832 bool result;
55833 void *argp1 = 0 ;
55834 int res1 = 0 ;
55835 PyObject *swig_obj[1] ;
55836
55837 if (!args) SWIG_fail;
55838 swig_obj[0] = args;
55839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55840 if (!SWIG_IsOK(res1)) {
55841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55842 }
55843 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55844 {
55845 PyThreadState* __tstate = wxPyBeginAllowThreads();
55846 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
55847 wxPyEndAllowThreads(__tstate);
55848 if (PyErr_Occurred()) SWIG_fail;
55849 }
55850 {
55851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55852 }
55853 return resultobj;
55854 fail:
55855 return NULL;
55856 }
55857
55858
55859 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55860 PyObject *resultobj = 0;
55861 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55862 bool arg2 ;
55863 void *argp1 = 0 ;
55864 int res1 = 0 ;
55865 bool val2 ;
55866 int ecode2 = 0 ;
55867 PyObject * obj0 = 0 ;
55868 PyObject * obj1 = 0 ;
55869 char * kwnames[] = {
55870 (char *) "self",(char *) "d", NULL
55871 };
55872
55873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
55874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55875 if (!SWIG_IsOK(res1)) {
55876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55877 }
55878 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55879 ecode2 = SWIG_AsVal_bool(obj1, &val2);
55880 if (!SWIG_IsOK(ecode2)) {
55881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
55882 }
55883 arg2 = static_cast< bool >(val2);
55884 {
55885 PyThreadState* __tstate = wxPyBeginAllowThreads();
55886 (arg1)->SetDone(arg2);
55887 wxPyEndAllowThreads(__tstate);
55888 if (PyErr_Occurred()) SWIG_fail;
55889 }
55890 resultobj = SWIG_Py_Void();
55891 return resultobj;
55892 fail:
55893 return NULL;
55894 }
55895
55896
55897 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55898 PyObject *resultobj = 0;
55899 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55900 wxRelationship result;
55901 void *argp1 = 0 ;
55902 int res1 = 0 ;
55903 PyObject *swig_obj[1] ;
55904
55905 if (!args) SWIG_fail;
55906 swig_obj[0] = args;
55907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55908 if (!SWIG_IsOK(res1)) {
55909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55910 }
55911 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55912 {
55913 PyThreadState* __tstate = wxPyBeginAllowThreads();
55914 result = (wxRelationship)(arg1)->GetRelationship();
55915 wxPyEndAllowThreads(__tstate);
55916 if (PyErr_Occurred()) SWIG_fail;
55917 }
55918 resultobj = SWIG_From_int(static_cast< int >(result));
55919 return resultobj;
55920 fail:
55921 return NULL;
55922 }
55923
55924
55925 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55926 PyObject *resultobj = 0;
55927 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55928 wxRelationship arg2 ;
55929 void *argp1 = 0 ;
55930 int res1 = 0 ;
55931 int val2 ;
55932 int ecode2 = 0 ;
55933 PyObject * obj0 = 0 ;
55934 PyObject * obj1 = 0 ;
55935 char * kwnames[] = {
55936 (char *) "self",(char *) "r", NULL
55937 };
55938
55939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
55940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55941 if (!SWIG_IsOK(res1)) {
55942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55943 }
55944 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55945 ecode2 = SWIG_AsVal_int(obj1, &val2);
55946 if (!SWIG_IsOK(ecode2)) {
55947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
55948 }
55949 arg2 = static_cast< wxRelationship >(val2);
55950 {
55951 PyThreadState* __tstate = wxPyBeginAllowThreads();
55952 (arg1)->SetRelationship(arg2);
55953 wxPyEndAllowThreads(__tstate);
55954 if (PyErr_Occurred()) SWIG_fail;
55955 }
55956 resultobj = SWIG_Py_Void();
55957 return resultobj;
55958 fail:
55959 return NULL;
55960 }
55961
55962
55963 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55964 PyObject *resultobj = 0;
55965 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55966 wxWindow *arg2 = (wxWindow *) 0 ;
55967 bool result;
55968 void *argp1 = 0 ;
55969 int res1 = 0 ;
55970 void *argp2 = 0 ;
55971 int res2 = 0 ;
55972 PyObject * obj0 = 0 ;
55973 PyObject * obj1 = 0 ;
55974 char * kwnames[] = {
55975 (char *) "self",(char *) "otherW", NULL
55976 };
55977
55978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
55979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55980 if (!SWIG_IsOK(res1)) {
55981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55982 }
55983 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55984 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55985 if (!SWIG_IsOK(res2)) {
55986 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
55987 }
55988 arg2 = reinterpret_cast< wxWindow * >(argp2);
55989 {
55990 PyThreadState* __tstate = wxPyBeginAllowThreads();
55991 result = (bool)(arg1)->ResetIfWin(arg2);
55992 wxPyEndAllowThreads(__tstate);
55993 if (PyErr_Occurred()) SWIG_fail;
55994 }
55995 {
55996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55997 }
55998 return resultobj;
55999 fail:
56000 return NULL;
56001 }
56002
56003
56004 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56005 PyObject *resultobj = 0;
56006 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56007 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
56008 wxWindow *arg3 = (wxWindow *) 0 ;
56009 bool result;
56010 void *argp1 = 0 ;
56011 int res1 = 0 ;
56012 void *argp2 = 0 ;
56013 int res2 = 0 ;
56014 void *argp3 = 0 ;
56015 int res3 = 0 ;
56016 PyObject * obj0 = 0 ;
56017 PyObject * obj1 = 0 ;
56018 PyObject * obj2 = 0 ;
56019 char * kwnames[] = {
56020 (char *) "self",(char *) "constraints",(char *) "win", NULL
56021 };
56022
56023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56025 if (!SWIG_IsOK(res1)) {
56026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56027 }
56028 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56029 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56030 if (!SWIG_IsOK(res2)) {
56031 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
56032 }
56033 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
56034 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56035 if (!SWIG_IsOK(res3)) {
56036 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
56037 }
56038 arg3 = reinterpret_cast< wxWindow * >(argp3);
56039 {
56040 PyThreadState* __tstate = wxPyBeginAllowThreads();
56041 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
56042 wxPyEndAllowThreads(__tstate);
56043 if (PyErr_Occurred()) SWIG_fail;
56044 }
56045 {
56046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56047 }
56048 return resultobj;
56049 fail:
56050 return NULL;
56051 }
56052
56053
56054 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56055 PyObject *resultobj = 0;
56056 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56057 wxEdge arg2 ;
56058 wxWindow *arg3 = (wxWindow *) 0 ;
56059 wxWindow *arg4 = (wxWindow *) 0 ;
56060 int result;
56061 void *argp1 = 0 ;
56062 int res1 = 0 ;
56063 int val2 ;
56064 int ecode2 = 0 ;
56065 void *argp3 = 0 ;
56066 int res3 = 0 ;
56067 void *argp4 = 0 ;
56068 int res4 = 0 ;
56069 PyObject * obj0 = 0 ;
56070 PyObject * obj1 = 0 ;
56071 PyObject * obj2 = 0 ;
56072 PyObject * obj3 = 0 ;
56073 char * kwnames[] = {
56074 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
56075 };
56076
56077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56079 if (!SWIG_IsOK(res1)) {
56080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56081 }
56082 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56083 ecode2 = SWIG_AsVal_int(obj1, &val2);
56084 if (!SWIG_IsOK(ecode2)) {
56085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
56086 }
56087 arg2 = static_cast< wxEdge >(val2);
56088 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56089 if (!SWIG_IsOK(res3)) {
56090 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
56091 }
56092 arg3 = reinterpret_cast< wxWindow * >(argp3);
56093 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
56094 if (!SWIG_IsOK(res4)) {
56095 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
56096 }
56097 arg4 = reinterpret_cast< wxWindow * >(argp4);
56098 {
56099 PyThreadState* __tstate = wxPyBeginAllowThreads();
56100 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
56101 wxPyEndAllowThreads(__tstate);
56102 if (PyErr_Occurred()) SWIG_fail;
56103 }
56104 resultobj = SWIG_From_int(static_cast< int >(result));
56105 return resultobj;
56106 fail:
56107 return NULL;
56108 }
56109
56110
56111 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56112 PyObject *obj;
56113 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56114 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
56115 return SWIG_Py_Void();
56116 }
56117
56118 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56119 PyObject *resultobj = 0;
56120 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56121 wxIndividualLayoutConstraint *result = 0 ;
56122 void *argp1 = 0 ;
56123 int res1 = 0 ;
56124 PyObject *swig_obj[1] ;
56125
56126 if (!args) SWIG_fail;
56127 swig_obj[0] = args;
56128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56129 if (!SWIG_IsOK(res1)) {
56130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56131 }
56132 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56133 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
56134 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56135 return resultobj;
56136 fail:
56137 return NULL;
56138 }
56139
56140
56141 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56142 PyObject *resultobj = 0;
56143 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56144 wxIndividualLayoutConstraint *result = 0 ;
56145 void *argp1 = 0 ;
56146 int res1 = 0 ;
56147 PyObject *swig_obj[1] ;
56148
56149 if (!args) SWIG_fail;
56150 swig_obj[0] = args;
56151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56152 if (!SWIG_IsOK(res1)) {
56153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56154 }
56155 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56156 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
56157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56158 return resultobj;
56159 fail:
56160 return NULL;
56161 }
56162
56163
56164 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56165 PyObject *resultobj = 0;
56166 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56167 wxIndividualLayoutConstraint *result = 0 ;
56168 void *argp1 = 0 ;
56169 int res1 = 0 ;
56170 PyObject *swig_obj[1] ;
56171
56172 if (!args) SWIG_fail;
56173 swig_obj[0] = args;
56174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56175 if (!SWIG_IsOK(res1)) {
56176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56177 }
56178 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56179 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
56180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56181 return resultobj;
56182 fail:
56183 return NULL;
56184 }
56185
56186
56187 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56188 PyObject *resultobj = 0;
56189 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56190 wxIndividualLayoutConstraint *result = 0 ;
56191 void *argp1 = 0 ;
56192 int res1 = 0 ;
56193 PyObject *swig_obj[1] ;
56194
56195 if (!args) SWIG_fail;
56196 swig_obj[0] = args;
56197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56198 if (!SWIG_IsOK(res1)) {
56199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56200 }
56201 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56202 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
56203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56204 return resultobj;
56205 fail:
56206 return NULL;
56207 }
56208
56209
56210 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56211 PyObject *resultobj = 0;
56212 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56213 wxIndividualLayoutConstraint *result = 0 ;
56214 void *argp1 = 0 ;
56215 int res1 = 0 ;
56216 PyObject *swig_obj[1] ;
56217
56218 if (!args) SWIG_fail;
56219 swig_obj[0] = args;
56220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56221 if (!SWIG_IsOK(res1)) {
56222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56223 }
56224 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56225 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
56226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56227 return resultobj;
56228 fail:
56229 return NULL;
56230 }
56231
56232
56233 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56234 PyObject *resultobj = 0;
56235 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56236 wxIndividualLayoutConstraint *result = 0 ;
56237 void *argp1 = 0 ;
56238 int res1 = 0 ;
56239 PyObject *swig_obj[1] ;
56240
56241 if (!args) SWIG_fail;
56242 swig_obj[0] = args;
56243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56244 if (!SWIG_IsOK(res1)) {
56245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56246 }
56247 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56248 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
56249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56250 return resultobj;
56251 fail:
56252 return NULL;
56253 }
56254
56255
56256 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56257 PyObject *resultobj = 0;
56258 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56259 wxIndividualLayoutConstraint *result = 0 ;
56260 void *argp1 = 0 ;
56261 int res1 = 0 ;
56262 PyObject *swig_obj[1] ;
56263
56264 if (!args) SWIG_fail;
56265 swig_obj[0] = args;
56266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56267 if (!SWIG_IsOK(res1)) {
56268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56269 }
56270 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56271 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
56272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56273 return resultobj;
56274 fail:
56275 return NULL;
56276 }
56277
56278
56279 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56280 PyObject *resultobj = 0;
56281 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56282 wxIndividualLayoutConstraint *result = 0 ;
56283 void *argp1 = 0 ;
56284 int res1 = 0 ;
56285 PyObject *swig_obj[1] ;
56286
56287 if (!args) SWIG_fail;
56288 swig_obj[0] = args;
56289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56290 if (!SWIG_IsOK(res1)) {
56291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56292 }
56293 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56294 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
56295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56296 return resultobj;
56297 fail:
56298 return NULL;
56299 }
56300
56301
56302 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56303 PyObject *resultobj = 0;
56304 wxLayoutConstraints *result = 0 ;
56305
56306 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
56307 {
56308 PyThreadState* __tstate = wxPyBeginAllowThreads();
56309 result = (wxLayoutConstraints *)new wxLayoutConstraints();
56310 wxPyEndAllowThreads(__tstate);
56311 if (PyErr_Occurred()) SWIG_fail;
56312 }
56313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
56314 return resultobj;
56315 fail:
56316 return NULL;
56317 }
56318
56319
56320 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56321 PyObject *resultobj = 0;
56322 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56323 void *argp1 = 0 ;
56324 int res1 = 0 ;
56325 PyObject *swig_obj[1] ;
56326
56327 if (!args) SWIG_fail;
56328 swig_obj[0] = args;
56329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
56330 if (!SWIG_IsOK(res1)) {
56331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56332 }
56333 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56334 {
56335 PyThreadState* __tstate = wxPyBeginAllowThreads();
56336 delete arg1;
56337
56338 wxPyEndAllowThreads(__tstate);
56339 if (PyErr_Occurred()) SWIG_fail;
56340 }
56341 resultobj = SWIG_Py_Void();
56342 return resultobj;
56343 fail:
56344 return NULL;
56345 }
56346
56347
56348 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56349 PyObject *resultobj = 0;
56350 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56351 wxWindow *arg2 = (wxWindow *) 0 ;
56352 int *arg3 = (int *) 0 ;
56353 bool result;
56354 void *argp1 = 0 ;
56355 int res1 = 0 ;
56356 void *argp2 = 0 ;
56357 int res2 = 0 ;
56358 int temp3 ;
56359 int res3 = SWIG_TMPOBJ ;
56360 PyObject * obj0 = 0 ;
56361 PyObject * obj1 = 0 ;
56362 char * kwnames[] = {
56363 (char *) "self",(char *) "win", NULL
56364 };
56365
56366 arg3 = &temp3;
56367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
56368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56369 if (!SWIG_IsOK(res1)) {
56370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56371 }
56372 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56373 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56374 if (!SWIG_IsOK(res2)) {
56375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
56376 }
56377 arg2 = reinterpret_cast< wxWindow * >(argp2);
56378 {
56379 PyThreadState* __tstate = wxPyBeginAllowThreads();
56380 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
56381 wxPyEndAllowThreads(__tstate);
56382 if (PyErr_Occurred()) SWIG_fail;
56383 }
56384 {
56385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56386 }
56387 if (SWIG_IsTmpObj(res3)) {
56388 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
56389 } else {
56390 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
56391 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
56392 }
56393 return resultobj;
56394 fail:
56395 return NULL;
56396 }
56397
56398
56399 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56400 PyObject *resultobj = 0;
56401 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56402 bool result;
56403 void *argp1 = 0 ;
56404 int res1 = 0 ;
56405 PyObject *swig_obj[1] ;
56406
56407 if (!args) SWIG_fail;
56408 swig_obj[0] = args;
56409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56410 if (!SWIG_IsOK(res1)) {
56411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
56412 }
56413 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56414 {
56415 PyThreadState* __tstate = wxPyBeginAllowThreads();
56416 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
56417 wxPyEndAllowThreads(__tstate);
56418 if (PyErr_Occurred()) SWIG_fail;
56419 }
56420 {
56421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56422 }
56423 return resultobj;
56424 fail:
56425 return NULL;
56426 }
56427
56428
56429 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56430 PyObject *obj;
56431 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56432 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
56433 return SWIG_Py_Void();
56434 }
56435
56436 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56437 return SWIG_Python_InitShadowInstance(args);
56438 }
56439
56440 static PyMethodDef SwigMethods[] = {
56441 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
56442 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
56443 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
56444 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
56445 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
56446 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
56447 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
56448 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
56449 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
56450 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56451 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
56452 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56453 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56454 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56455 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56456 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
56457 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
56458 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
56459 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
56460 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56461 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56462 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56463 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56464 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
56465 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
56466 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
56467 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
56468 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
56469 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
56470 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
56471 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
56472 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
56473 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
56474 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
56475 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56476 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
56477 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56478 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56479 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56480 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56481 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56482 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
56483 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
56484 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
56485 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
56486 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
56487 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
56488 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
56489 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
56490 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
56491 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56492 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56493 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56494 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56495 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56496 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56497 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56498 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
56499 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
56500 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
56501 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
56502 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
56503 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
56504 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
56505 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
56506 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
56507 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
56508 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
56509 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
56510 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
56511 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56512 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
56513 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56514 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
56515 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56516 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
56517 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
56518 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
56519 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
56520 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56521 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
56522 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
56523 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
56524 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
56525 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
56526 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56527 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
56528 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
56529 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
56530 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
56531 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56532 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56533 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56534 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56535 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
56536 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
56537 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
56538 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56539 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56540 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56541 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56542 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56543 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56544 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56545 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
56546 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56547 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56548 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56549 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
56550 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
56551 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
56552 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
56553 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
56554 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
56555 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
56556 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
56557 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
56558 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56559 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
56560 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
56561 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
56562 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
56563 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
56564 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
56565 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56566 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
56567 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
56568 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
56569 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
56570 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
56571 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
56572 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
56573 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
56574 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
56575 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56576 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56577 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
56578 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56579 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56580 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
56581 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
56582 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56583 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56584 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
56585 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
56586 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
56587 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
56588 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56589 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
56590 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
56591 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
56592 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
56593 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
56594 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
56595 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
56596 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
56597 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56598 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
56599 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
56600 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56601 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56602 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
56603 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56604 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56605 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
56606 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56607 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
56608 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
56609 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
56610 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56611 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
56612 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56613 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56614 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
56615 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
56616 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56617 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
56618 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56619 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56620 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
56621 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
56622 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
56623 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
56624 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56625 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56626 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
56627 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
56628 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
56629 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56630 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
56631 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
56632 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56633 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
56634 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56635 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56636 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
56637 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
56638 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56639 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56640 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
56641 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
56642 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
56643 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
56644 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
56645 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
56646 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
56647 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
56648 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56649 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
56650 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
56651 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
56652 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
56653 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
56654 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
56655 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
56656 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
56657 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
56658 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
56659 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
56660 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
56661 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
56662 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
56663 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
56664 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
56665 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
56666 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
56667 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
56668 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
56669 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
56670 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
56671 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
56672 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
56673 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
56674 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
56675 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
56676 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
56677 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
56678 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
56679 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
56680 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
56681 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
56682 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
56683 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
56684 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
56685 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
56686 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
56687 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
56688 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56689 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56690 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56691 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56692 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
56693 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
56694 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56695 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
56696 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56697 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
56698 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
56699 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
56700 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
56701 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
56702 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
56703 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
56704 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56705 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56706 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
56707 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56708 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56709 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
56710 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
56711 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
56712 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
56713 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
56714 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
56715 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56716 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56717 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
56718 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
56719 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
56720 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56721 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56722 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56723 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
56724 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
56725 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
56726 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
56727 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56728 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
56729 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
56730 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56731 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56732 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56733 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56734 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
56735 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
56736 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
56737 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
56738 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
56739 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
56740 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
56741 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56742 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56743 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
56744 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
56745 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
56746 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
56747 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
56748 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
56749 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
56750 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
56751 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
56752 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
56753 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56754 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56755 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
56756 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56757 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
56758 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
56759 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
56760 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
56761 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
56762 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
56763 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
56764 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
56765 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
56766 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
56767 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
56768 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
56769 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
56770 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
56771 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
56772 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
56773 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
56774 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
56775 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
56776 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
56777 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
56778 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
56779 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
56780 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
56781 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
56782 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
56783 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
56784 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56785 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
56786 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56787 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
56788 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
56789 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56790 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
56791 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
56792 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
56793 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
56794 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
56795 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
56796 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
56797 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
56798 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56799 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
56800 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
56801 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
56802 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
56803 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56804 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56805 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
56806 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
56807 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
56808 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56809 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
56810 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56811 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
56812 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56813 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
56814 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
56815 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56816 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56817 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56818 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56819 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56820 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
56821 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
56822 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
56823 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
56824 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
56825 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
56826 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56827 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
56828 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
56829 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
56830 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
56831 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
56832 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56833 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
56834 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
56835 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
56836 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56837 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
56838 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
56839 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
56840 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
56841 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
56842 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
56843 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
56844 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
56845 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
56846 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
56847 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
56848 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
56849 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
56850 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56851 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56852 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56853 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56854 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
56855 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
56856 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
56857 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56858 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56859 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56860 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
56861 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
56862 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56863 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56864 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
56865 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
56866 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56867 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
56868 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
56869 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56870 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
56871 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
56872 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
56873 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
56874 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
56875 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
56876 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
56877 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
56878 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
56879 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
56880 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
56881 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
56882 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
56883 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
56884 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
56885 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
56886 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
56887 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
56888 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
56889 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
56890 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
56891 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
56892 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
56893 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
56894 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
56895 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
56896 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
56897 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
56898 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
56899 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
56900 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
56901 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
56902 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
56903 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
56904 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
56905 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
56906 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
56907 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
56908 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
56909 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
56910 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
56911 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56912 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56913 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
56914 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
56915 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56916 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56917 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
56918 { (char *)"EvtHandler_AllowReentrance", (PyCFunction) _wrap_EvtHandler_AllowReentrance, METH_VARARGS | METH_KEYWORDS, NULL},
56919 { (char *)"EvtHandler_IsReentranceAllowed", (PyCFunction)_wrap_EvtHandler_IsReentranceAllowed, METH_O, NULL},
56920 { (char *)"EvtHandler_IsEventHandlingInProgress", (PyCFunction)_wrap_EvtHandler_IsEventHandlingInProgress, METH_O, NULL},
56921 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
56922 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
56923 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56924 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
56925 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
56926 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
56927 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
56928 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
56929 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
56930 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
56931 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
56932 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
56933 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
56934 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
56935 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
56936 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
56937 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
56938 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
56939 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
56940 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
56941 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
56942 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
56943 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
56944 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
56945 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
56946 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
56947 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
56948 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
56949 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
56950 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
56951 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
56952 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56953 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
56954 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
56955 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
56956 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
56957 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
56958 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
56959 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
56960 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
56961 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
56962 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
56963 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
56964 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
56965 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
56966 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
56967 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56968 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
56969 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
56970 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
56971 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
56972 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
56973 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56974 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
56975 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
56976 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56977 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56978 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
56979 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
56980 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56981 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
56982 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
56983 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56984 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56985 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
56986 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
56987 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56988 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
56989 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
56990 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
56991 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
56992 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
56993 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
56994 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
56995 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
56996 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
56997 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
56998 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
56999 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
57000 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
57001 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
57002 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
57003 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
57004 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
57005 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
57006 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
57007 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
57008 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
57009 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
57010 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
57011 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
57012 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
57013 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
57014 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
57015 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
57016 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
57017 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
57018 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57019 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
57020 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
57021 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
57022 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
57023 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
57024 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
57025 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
57026 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
57027 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
57028 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
57029 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
57030 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
57031 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
57032 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
57033 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
57034 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
57035 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
57036 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
57037 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
57038 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
57039 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
57040 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
57041 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
57042 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
57043 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
57044 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
57045 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
57046 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
57047 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
57048 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
57049 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
57050 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
57051 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57052 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
57053 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
57054 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57055 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
57056 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
57057 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
57058 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
57059 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57060 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
57061 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
57062 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
57063 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
57064 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
57065 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
57066 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
57067 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
57068 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
57069 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
57070 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
57071 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
57072 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
57073 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
57074 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
57075 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
57076 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
57077 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
57078 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
57079 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
57080 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
57081 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
57082 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
57083 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
57084 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
57085 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
57086 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
57087 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
57088 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
57089 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
57090 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
57091 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
57092 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
57093 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
57094 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
57095 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
57096 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
57097 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
57098 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57099 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
57100 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
57101 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57102 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57103 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
57104 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
57105 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
57106 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
57107 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
57108 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
57109 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57110 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
57111 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
57112 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57113 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57114 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
57115 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
57116 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57117 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
57118 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
57119 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57120 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
57121 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
57122 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57123 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
57124 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
57125 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
57126 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57127 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
57128 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57129 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
57130 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
57131 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57132 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
57133 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
57134 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
57135 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57136 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
57137 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
57138 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
57139 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57140 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
57141 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
57142 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57143 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
57144 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
57145 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
57146 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
57147 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
57148 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57149 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
57150 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
57151 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
57152 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
57153 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
57154 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
57155 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
57156 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
57157 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57158 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
57159 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
57160 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
57161 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
57162 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57163 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
57164 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
57165 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
57166 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57167 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
57168 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
57169 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
57170 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
57171 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
57172 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
57173 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57174 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
57175 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
57176 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
57177 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
57178 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
57179 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
57180 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
57181 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
57182 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57183 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57184 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57185 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57186 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
57187 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
57188 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
57189 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
57190 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57191 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
57192 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
57193 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
57194 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
57195 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
57196 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
57197 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57198 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
57199 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
57200 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
57201 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57202 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
57203 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
57204 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
57205 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
57206 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
57207 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57208 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57209 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
57210 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
57211 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
57212 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57213 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
57214 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
57215 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
57216 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
57217 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
57218 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
57219 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57220 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
57221 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
57222 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
57223 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
57224 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
57225 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
57226 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
57227 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
57228 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
57229 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57230 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
57231 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
57232 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
57233 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57234 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
57235 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
57236 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
57237 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57238 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
57239 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57240 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
57241 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
57242 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
57243 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
57244 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
57245 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57246 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
57247 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
57248 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
57249 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
57250 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57251 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
57252 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
57253 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57254 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
57255 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57256 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
57257 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
57258 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
57259 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57260 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
57261 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57262 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
57263 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
57264 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
57265 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57266 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
57267 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
57268 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
57269 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
57270 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
57271 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
57272 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57273 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
57274 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
57275 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
57276 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
57277 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
57278 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
57279 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
57280 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
57281 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
57282 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
57283 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
57284 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
57285 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
57286 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
57287 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
57288 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
57289 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
57290 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
57291 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
57292 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
57293 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57294 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
57295 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
57296 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
57297 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
57298 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
57299 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
57300 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
57301 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
57302 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
57303 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
57304 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
57305 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
57306 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
57307 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
57308 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
57309 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57310 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57311 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57312 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
57313 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
57314 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
57315 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
57316 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
57317 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
57318 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
57319 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
57320 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
57321 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
57322 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
57323 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57324 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
57325 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
57326 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
57327 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
57328 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
57329 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
57330 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
57331 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
57332 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
57333 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
57334 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
57335 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
57336 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
57337 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
57338 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
57339 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
57340 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
57341 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
57342 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
57343 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
57344 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
57345 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57346 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57347 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
57348 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
57349 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
57350 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
57351 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
57352 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
57353 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
57354 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
57355 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57356 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
57357 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
57358 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
57359 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
57360 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
57361 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
57362 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
57363 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
57364 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
57365 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
57366 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
57367 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
57368 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
57369 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
57370 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
57371 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
57372 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
57373 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57374 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
57375 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
57376 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
57377 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
57378 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57379 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
57380 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57381 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
57382 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
57383 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
57384 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57385 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
57386 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
57387 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57388 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57389 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
57390 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57391 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57392 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57393 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
57394 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57395 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57396 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
57397 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
57398 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
57399 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
57400 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
57401 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
57402 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57403 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
57404 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
57405 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
57406 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
57407 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
57408 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
57409 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
57410 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
57411 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
57412 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
57413 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
57414 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
57415 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
57416 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
57417 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
57418 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
57419 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
57420 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
57421 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
57422 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
57423 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
57424 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
57425 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57426 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57427 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57428 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57429 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
57430 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
57431 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57432 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
57433 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
57434 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
57435 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
57436 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
57437 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57438 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57439 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
57440 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
57441 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
57442 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57443 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
57444 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57445 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
57446 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
57447 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
57448 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
57449 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57450 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
57451 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57452 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
57453 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57454 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
57455 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
57456 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57457 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
57458 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
57459 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
57460 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
57461 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
57462 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
57463 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
57464 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57465 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57466 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
57467 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
57468 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
57469 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
57470 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
57471 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
57472 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
57473 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
57474 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57475 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57476 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
57477 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57478 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57479 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57480 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57481 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
57482 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
57483 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
57484 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
57485 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
57486 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
57487 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57488 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
57489 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57490 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57491 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57492 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57493 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
57494 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
57495 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57496 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57497 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
57498 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
57499 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
57500 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
57501 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
57502 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
57503 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
57504 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
57505 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
57506 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
57507 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
57508 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
57509 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
57510 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
57511 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
57512 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
57513 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
57514 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57515 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
57516 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
57517 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57518 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57519 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57520 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57521 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57522 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
57523 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
57524 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
57525 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
57526 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57527 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
57528 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
57529 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57530 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
57531 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57532 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
57533 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
57534 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
57535 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
57536 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
57537 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
57538 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57539 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57540 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
57541 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
57542 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
57543 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
57544 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
57545 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
57546 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
57547 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
57548 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
57549 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57550 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
57551 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
57552 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
57553 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
57554 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57555 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57556 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57557 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57558 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
57559 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
57560 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57561 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
57562 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
57563 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
57564 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
57565 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
57566 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
57567 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
57568 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
57569 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57570 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
57571 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
57572 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
57573 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
57574 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
57575 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
57576 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
57577 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57578 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
57579 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
57580 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
57581 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
57582 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57583 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
57584 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
57585 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57586 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
57587 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
57588 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
57589 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
57590 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
57591 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
57592 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
57593 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57594 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57595 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57596 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
57597 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
57598 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
57599 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
57600 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
57601 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
57602 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
57603 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
57604 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57605 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
57606 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
57607 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
57608 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
57609 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
57610 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57611 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
57612 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
57613 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
57614 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57615 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
57616 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57617 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57618 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57619 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57620 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
57621 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57622 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57623 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
57624 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57625 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
57626 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57627 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57628 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57629 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57630 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
57631 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57632 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57633 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57634 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57635 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
57636 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57637 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
57638 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
57639 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
57640 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
57641 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
57642 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
57643 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
57644 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57645 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57646 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57647 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57648 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57649 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57650 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57651 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57652 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57653 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57654 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
57655 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
57656 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57657 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
57658 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57659 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
57660 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
57661 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
57662 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
57663 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57664 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
57665 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
57666 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
57667 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
57668 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
57669 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
57670 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
57671 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57672 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57673 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
57674 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57675 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57676 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57677 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
57678 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
57679 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57680 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57681 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57682 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57683 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57684 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57685 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57686 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57687 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57688 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57689 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57690 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57691 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57692 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
57693 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
57694 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57695 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
57696 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
57697 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57698 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
57699 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
57700 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
57701 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57702 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
57703 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
57704 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57705 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57706 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
57707 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
57708 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57709 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
57710 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
57711 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
57712 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
57713 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
57714 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
57715 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
57716 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
57717 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57718 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
57719 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57720 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
57721 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57722 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
57723 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
57724 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
57725 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
57726 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
57727 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
57728 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57729 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
57730 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57731 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
57732 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
57733 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
57734 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57735 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
57736 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
57737 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57738 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
57739 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57740 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
57741 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
57742 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
57743 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
57744 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
57745 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
57746 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
57747 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
57748 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
57749 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57750 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
57751 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
57752 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
57753 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57754 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
57755 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
57756 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57757 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
57758 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57759 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
57760 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57761 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57762 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57763 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
57764 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
57765 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
57766 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
57767 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57768 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
57769 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57770 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
57771 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57772 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
57773 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
57774 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
57775 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
57776 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
57777 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
57778 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57779 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57780 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57781 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
57782 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
57783 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
57784 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
57785 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57786 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
57787 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
57788 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
57789 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
57790 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
57791 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
57792 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
57793 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
57794 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
57795 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
57796 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
57797 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
57798 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
57799 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57800 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
57801 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
57802 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
57803 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
57804 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57805 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
57806 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57807 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
57808 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57809 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57810 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
57811 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
57812 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
57813 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
57814 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
57815 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
57816 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
57817 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57818 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57819 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57820 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57821 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57822 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
57823 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
57824 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57825 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
57826 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57827 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
57828 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57829 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
57830 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57831 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57832 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57833 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57834 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57835 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
57836 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
57837 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
57838 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
57839 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
57840 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
57841 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
57842 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
57843 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57844 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57845 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
57846 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
57847 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
57848 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57849 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
57850 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
57851 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
57852 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
57853 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57854 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
57855 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
57856 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57857 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
57858 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57859 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
57860 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
57861 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57862 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
57863 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
57864 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
57865 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57866 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
57867 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
57868 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
57869 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
57870 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
57871 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
57872 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
57873 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
57874 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
57875 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
57876 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57877 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57878 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57879 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57880 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57881 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57882 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
57883 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
57884 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
57885 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
57886 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
57887 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
57888 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
57889 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
57890 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
57891 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
57892 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57893 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57894 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
57895 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
57896 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
57897 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
57898 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
57899 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
57900 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
57901 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
57902 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57903 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
57904 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
57905 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
57906 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
57907 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
57908 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57909 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57910 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57911 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
57912 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
57913 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
57914 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57915 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
57916 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
57917 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
57918 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
57919 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
57920 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57921 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57922 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57923 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
57924 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
57925 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
57926 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
57927 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
57928 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57929 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57930 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57931 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
57932 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
57933 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
57934 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57935 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57936 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
57937 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
57938 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
57939 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57940 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
57941 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
57942 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57943 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57944 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57945 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57946 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
57947 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57948 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
57949 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
57950 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
57951 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
57952 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
57953 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57954 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57955 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
57956 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
57957 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
57958 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
57959 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57960 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
57961 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
57962 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
57963 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
57964 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57965 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
57966 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
57967 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
57968 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
57969 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
57970 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
57971 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57972 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
57973 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
57974 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
57975 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
57976 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
57977 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
57978 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
57979 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
57980 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
57981 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
57982 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
57983 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
57984 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57985 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
57986 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
57987 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
57988 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
57989 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
57990 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
57991 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
57992 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
57993 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
57994 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
57995 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
57996 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57997 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
57998 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
57999 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
58000 { NULL, NULL, 0, NULL }
58001 };
58002
58003
58004 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
58005
58006 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
58007 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
58008 }
58009 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
58010 return (void *)((wxSizer *) ((wxBoxSizer *) x));
58011 }
58012 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
58013 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
58014 }
58015 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
58016 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58017 }
58018 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
58019 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58020 }
58021 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
58022 return (void *)((wxSizer *) ((wxGridSizer *) x));
58023 }
58024 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
58025 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
58026 }
58027 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
58028 return (void *)((wxSizer *) ((wxPySizer *) x));
58029 }
58030 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
58031 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
58032 }
58033 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
58034 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58035 }
58036 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
58037 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
58038 }
58039 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
58040 return (void *)((wxEvent *) ((wxMenuEvent *) x));
58041 }
58042 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
58043 return (void *)((wxEvent *) ((wxCloseEvent *) x));
58044 }
58045 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
58046 return (void *)((wxEvent *) ((wxMouseEvent *) x));
58047 }
58048 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
58049 return (void *)((wxEvent *) ((wxEraseEvent *) x));
58050 }
58051 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
58052 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
58053 }
58054 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
58055 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
58056 }
58057 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
58058 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
58059 }
58060 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
58061 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
58062 }
58063 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
58064 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
58065 }
58066 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
58067 return (void *)((wxEvent *) ((wxPyEvent *) x));
58068 }
58069 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
58070 return (void *)((wxEvent *) ((wxIdleEvent *) x));
58071 }
58072 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
58073 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
58074 }
58075 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
58076 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
58077 }
58078 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
58079 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
58080 }
58081 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
58082 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
58083 }
58084 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
58085 return (void *)((wxEvent *) ((wxActivateEvent *) x));
58086 }
58087 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
58088 return (void *)((wxEvent *) ((wxSizeEvent *) x));
58089 }
58090 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
58091 return (void *)((wxEvent *) ((wxMoveEvent *) x));
58092 }
58093 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
58094 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
58095 }
58096 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
58097 return (void *)((wxEvent *) ((wxPaintEvent *) x));
58098 }
58099 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
58100 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
58101 }
58102 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
58103 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
58104 }
58105 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
58106 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
58107 }
58108 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
58109 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
58110 }
58111 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
58112 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
58113 }
58114 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
58115 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58116 }
58117 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
58118 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
58119 }
58120 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
58121 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
58122 }
58123 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
58124 return (void *)((wxEvent *) ((wxFocusEvent *) x));
58125 }
58126 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
58127 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
58128 }
58129 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
58130 return (void *)((wxEvent *) ((wxShowEvent *) x));
58131 }
58132 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
58133 return (void *)((wxEvent *) ((wxCommandEvent *) x));
58134 }
58135 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
58136 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
58137 }
58138 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
58139 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58140 }
58141 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
58142 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
58143 }
58144 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
58145 return (void *)((wxEvent *) ((wxKeyEvent *) x));
58146 }
58147 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
58148 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
58149 }
58150 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
58151 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
58152 }
58153 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
58154 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
58155 }
58156 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
58157 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
58158 }
58159 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
58160 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
58161 }
58162 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
58163 return (void *)((wxControl *) ((wxControlWithItems *) x));
58164 }
58165 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
58166 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
58167 }
58168 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
58169 return (void *)((wxEvtHandler *) ((wxWindow *) x));
58170 }
58171 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
58172 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58173 }
58174 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
58175 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
58176 }
58177 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
58178 return (void *)((wxEvtHandler *) ((wxValidator *) x));
58179 }
58180 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
58181 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
58182 }
58183 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
58184 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
58185 }
58186 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
58187 return (void *)((wxEvtHandler *) ((wxMenu *) x));
58188 }
58189 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
58190 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
58191 }
58192 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
58193 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
58194 }
58195 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
58196 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
58197 }
58198 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
58199 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
58200 }
58201 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
58202 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
58203 }
58204 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
58205 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58206 }
58207 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
58208 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
58209 }
58210 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
58211 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
58212 }
58213 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
58214 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
58215 }
58216 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
58217 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58218 }
58219 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
58220 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58221 }
58222 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
58223 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
58224 }
58225 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
58226 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
58227 }
58228 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
58229 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
58230 }
58231 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
58232 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
58233 }
58234 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
58235 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
58236 }
58237 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
58238 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
58239 }
58240 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
58241 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
58242 }
58243 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
58244 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
58245 }
58246 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
58247 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
58248 }
58249 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
58250 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
58251 }
58252 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
58253 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
58254 }
58255 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
58256 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
58257 }
58258 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
58259 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
58260 }
58261 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
58262 return (void *)((wxObject *) ((wxSizerItem *) x));
58263 }
58264 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
58265 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
58266 }
58267 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
58268 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
58269 }
58270 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
58271 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
58272 }
58273 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
58274 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
58275 }
58276 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
58277 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
58278 }
58279 static void *_p_wxSizerTo_p_wxObject(void *x) {
58280 return (void *)((wxObject *) ((wxSizer *) x));
58281 }
58282 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
58283 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58284 }
58285 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
58286 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
58287 }
58288 static void *_p_wxEventTo_p_wxObject(void *x) {
58289 return (void *)((wxObject *) ((wxEvent *) x));
58290 }
58291 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
58292 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
58293 }
58294 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
58295 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
58296 }
58297 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
58298 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
58299 }
58300 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
58301 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
58302 }
58303 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
58304 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
58305 }
58306 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
58307 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
58308 }
58309 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
58310 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
58311 }
58312 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
58313 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
58314 }
58315 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
58316 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58317 }
58318 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
58319 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
58320 }
58321 static void *_p_wxControlTo_p_wxObject(void *x) {
58322 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
58323 }
58324 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
58325 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
58326 }
58327 static void *_p_wxFSFileTo_p_wxObject(void *x) {
58328 return (void *)((wxObject *) ((wxFSFile *) x));
58329 }
58330 static void *_p_wxPySizerTo_p_wxObject(void *x) {
58331 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
58332 }
58333 static void *_p_wxPyEventTo_p_wxObject(void *x) {
58334 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
58335 }
58336 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
58337 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
58338 }
58339 static void *_p_wxShowEventTo_p_wxObject(void *x) {
58340 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
58341 }
58342 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
58343 return (void *)((wxObject *) ((wxMenuItem *) x));
58344 }
58345 static void *_p_wxDateEventTo_p_wxObject(void *x) {
58346 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
58347 }
58348 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
58349 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
58350 }
58351 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
58352 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
58353 }
58354 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
58355 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
58356 }
58357 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
58358 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
58359 }
58360 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
58361 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
58362 }
58363 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
58364 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
58365 }
58366 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
58367 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
58368 }
58369 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
58370 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
58371 }
58372 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
58373 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
58374 }
58375 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
58376 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
58377 }
58378 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
58379 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
58380 }
58381 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
58382 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
58383 }
58384 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
58385 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
58386 }
58387 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
58388 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58389 }
58390 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
58391 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58392 }
58393 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
58394 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
58395 }
58396 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
58397 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
58398 }
58399 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
58400 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
58401 }
58402 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
58403 return (void *)((wxObject *) ((wxImageHandler *) x));
58404 }
58405 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
58406 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
58407 }
58408 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
58409 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
58410 }
58411 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
58412 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
58413 }
58414 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
58415 return (void *)((wxObject *) ((wxEvtHandler *) x));
58416 }
58417 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
58418 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
58419 }
58420 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
58421 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
58422 }
58423 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
58424 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58425 }
58426 static void *_p_wxImageTo_p_wxObject(void *x) {
58427 return (void *)((wxObject *) ((wxImage *) x));
58428 }
58429 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
58430 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
58431 }
58432 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
58433 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58434 }
58435 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
58436 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
58437 }
58438 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
58439 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
58440 }
58441 static void *_p_wxWindowTo_p_wxObject(void *x) {
58442 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
58443 }
58444 static void *_p_wxMenuTo_p_wxObject(void *x) {
58445 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
58446 }
58447 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
58448 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
58449 }
58450 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
58451 return (void *)((wxObject *) ((wxFileSystem *) x));
58452 }
58453 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
58454 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
58455 }
58456 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
58457 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
58458 }
58459 static void *_p_wxPyAppTo_p_wxObject(void *x) {
58460 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
58461 }
58462 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
58463 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
58464 }
58465 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
58466 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
58467 }
58468 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
58469 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
58470 }
58471 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
58472 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
58473 }
58474 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
58475 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
58476 }
58477 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
58478 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
58479 }
58480 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
58481 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
58482 }
58483 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
58484 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
58485 }
58486 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
58487 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58488 }
58489 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
58490 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
58491 }
58492 static void *_p_wxValidatorTo_p_wxObject(void *x) {
58493 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
58494 }
58495 static void *_p_wxControlTo_p_wxWindow(void *x) {
58496 return (void *)((wxWindow *) ((wxControl *) x));
58497 }
58498 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
58499 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
58500 }
58501 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
58502 return (void *)((wxWindow *) ((wxMenuBar *) x));
58503 }
58504 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
58505 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
58506 }
58507 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
58508 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
58509 }
58510 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
58511 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
58512 }
58513 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
58514 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
58515 }
58516 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
58517 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
58518 }
58519 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
58520 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
58521 }
58522 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
58523 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58524 }
58525 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
58526 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
58527 }
58528 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
58529 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
58530 }
58531 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
58532 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
58533 }
58534 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
58535 return (void *)((wxValidator *) ((wxPyValidator *) x));
58536 }
58537 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
58538 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
58539 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};
58540 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
58541 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
58542 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
58543 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
58544 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
58545 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
58546 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
58547 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
58548 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
58549 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
58550 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
58551 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
58552 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
58553 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
58554 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
58555 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
58556 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
58557 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
58558 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
58559 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
58560 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
58561 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
58562 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
58563 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
58564 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
58565 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
58566 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
58567 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
58568 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
58569 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
58570 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
58571 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
58572 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
58573 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
58574 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
58575 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
58576 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
58577 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
58578 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
58579 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
58580 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
58581 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
58582 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
58583 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
58584 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
58585 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
58586 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
58587 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
58588 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
58589 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
58590 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
58591 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
58592 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
58593 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
58594 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
58595 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
58596 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
58597 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
58598 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
58599 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
58600 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
58601 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
58602 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
58603 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
58604 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
58605 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
58606 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
58607 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
58608 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
58609 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
58610 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
58611 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
58612 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
58613 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
58614 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
58615 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
58616 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
58617 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
58618 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
58619 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
58620 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
58621 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
58622 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
58623 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
58624 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
58625 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
58626 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
58627 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
58628 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
58629 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
58630 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
58631 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
58632 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
58633 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
58634 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
58635 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
58636 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
58637 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
58638 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
58639 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
58640 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
58641 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
58642 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
58643 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
58644 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
58645 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
58646 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
58647 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
58648 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
58649 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
58650 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
58651 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
58652 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
58653 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
58654 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
58655 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
58656 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
58657 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
58658 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
58659 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
58660 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
58661 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
58662 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
58663 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
58664 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
58665 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
58666 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
58667 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
58668 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
58669 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
58670 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
58671 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
58672
58673 static swig_type_info *swig_type_initial[] = {
58674 &_swigt__p_buffer,
58675 &_swigt__p_char,
58676 &_swigt__p_form_ops_t,
58677 &_swigt__p_int,
58678 &_swigt__p_long,
58679 &_swigt__p_unsigned_char,
58680 &_swigt__p_unsigned_int,
58681 &_swigt__p_unsigned_long,
58682 &_swigt__p_wxANIHandler,
58683 &_swigt__p_wxAcceleratorEntry,
58684 &_swigt__p_wxAcceleratorTable,
58685 &_swigt__p_wxActivateEvent,
58686 &_swigt__p_wxAppTraits,
58687 &_swigt__p_wxArrayString,
58688 &_swigt__p_wxBMPHandler,
58689 &_swigt__p_wxBitmap,
58690 &_swigt__p_wxBoxSizer,
58691 &_swigt__p_wxButton,
58692 &_swigt__p_wxCURHandler,
58693 &_swigt__p_wxCaret,
58694 &_swigt__p_wxChildFocusEvent,
58695 &_swigt__p_wxClipboardTextEvent,
58696 &_swigt__p_wxCloseEvent,
58697 &_swigt__p_wxColour,
58698 &_swigt__p_wxCommandEvent,
58699 &_swigt__p_wxContextMenuEvent,
58700 &_swigt__p_wxControl,
58701 &_swigt__p_wxControlWithItems,
58702 &_swigt__p_wxCursor,
58703 &_swigt__p_wxDC,
58704 &_swigt__p_wxDateEvent,
58705 &_swigt__p_wxDateTime,
58706 &_swigt__p_wxDisplayChangedEvent,
58707 &_swigt__p_wxDouble,
58708 &_swigt__p_wxDropFilesEvent,
58709 &_swigt__p_wxDuplexMode,
58710 &_swigt__p_wxEraseEvent,
58711 &_swigt__p_wxEvent,
58712 &_swigt__p_wxEventLoop,
58713 &_swigt__p_wxEventLoopActivator,
58714 &_swigt__p_wxEvtHandler,
58715 &_swigt__p_wxFSFile,
58716 &_swigt__p_wxFileSystem,
58717 &_swigt__p_wxFileSystemHandler,
58718 &_swigt__p_wxFlexGridSizer,
58719 &_swigt__p_wxFocusEvent,
58720 &_swigt__p_wxFont,
58721 &_swigt__p_wxFrame,
58722 &_swigt__p_wxGBPosition,
58723 &_swigt__p_wxGBSizerItem,
58724 &_swigt__p_wxGBSpan,
58725 &_swigt__p_wxGIFHandler,
58726 &_swigt__p_wxGridBagSizer,
58727 &_swigt__p_wxGridSizer,
58728 &_swigt__p_wxHelpEvent__Origin,
58729 &_swigt__p_wxICOHandler,
58730 &_swigt__p_wxIconizeEvent,
58731 &_swigt__p_wxIdleEvent,
58732 &_swigt__p_wxImage,
58733 &_swigt__p_wxImageHandler,
58734 &_swigt__p_wxImageHistogram,
58735 &_swigt__p_wxImage_HSVValue,
58736 &_swigt__p_wxImage_RGBValue,
58737 &_swigt__p_wxIndividualLayoutConstraint,
58738 &_swigt__p_wxInitDialogEvent,
58739 &_swigt__p_wxInputStream,
58740 &_swigt__p_wxInternetFSHandler,
58741 &_swigt__p_wxItemContainer,
58742 &_swigt__p_wxJPEGHandler,
58743 &_swigt__p_wxKeyEvent,
58744 &_swigt__p_wxLayoutConstraints,
58745 &_swigt__p_wxMaximizeEvent,
58746 &_swigt__p_wxMemoryFSHandler,
58747 &_swigt__p_wxMenu,
58748 &_swigt__p_wxMenuBar,
58749 &_swigt__p_wxMenuBarBase,
58750 &_swigt__p_wxMenuEvent,
58751 &_swigt__p_wxMenuItem,
58752 &_swigt__p_wxMouseCaptureChangedEvent,
58753 &_swigt__p_wxMouseCaptureLostEvent,
58754 &_swigt__p_wxMouseEvent,
58755 &_swigt__p_wxMoveEvent,
58756 &_swigt__p_wxNavigationKeyEvent,
58757 &_swigt__p_wxNcPaintEvent,
58758 &_swigt__p_wxNotifyEvent,
58759 &_swigt__p_wxObject,
58760 &_swigt__p_wxOutputStream,
58761 &_swigt__p_wxPCXHandler,
58762 &_swigt__p_wxPNGHandler,
58763 &_swigt__p_wxPNMHandler,
58764 &_swigt__p_wxPaintEvent,
58765 &_swigt__p_wxPaletteChangedEvent,
58766 &_swigt__p_wxPaperSize,
58767 &_swigt__p_wxPoint,
58768 &_swigt__p_wxPoint2D,
58769 &_swigt__p_wxPropagateOnce,
58770 &_swigt__p_wxPropagationDisabler,
58771 &_swigt__p_wxPyApp,
58772 &_swigt__p_wxPyCommandEvent,
58773 &_swigt__p_wxPyDropTarget,
58774 &_swigt__p_wxPyEvent,
58775 &_swigt__p_wxPyFileSystemHandler,
58776 &_swigt__p_wxPyImageHandler,
58777 &_swigt__p_wxPyInputStream,
58778 &_swigt__p_wxPySizer,
58779 &_swigt__p_wxPyValidator,
58780 &_swigt__p_wxQuantize,
58781 &_swigt__p_wxQueryNewPaletteEvent,
58782 &_swigt__p_wxRealPoint,
58783 &_swigt__p_wxRect,
58784 &_swigt__p_wxRect2D,
58785 &_swigt__p_wxRegion,
58786 &_swigt__p_wxScrollEvent,
58787 &_swigt__p_wxScrollWinEvent,
58788 &_swigt__p_wxSetCursorEvent,
58789 &_swigt__p_wxShowEvent,
58790 &_swigt__p_wxSize,
58791 &_swigt__p_wxSizeEvent,
58792 &_swigt__p_wxSizer,
58793 &_swigt__p_wxSizerItem,
58794 &_swigt__p_wxStaticBox,
58795 &_swigt__p_wxStaticBoxSizer,
58796 &_swigt__p_wxStdDialogButtonSizer,
58797 &_swigt__p_wxSysColourChangedEvent,
58798 &_swigt__p_wxTGAHandler,
58799 &_swigt__p_wxTIFFHandler,
58800 &_swigt__p_wxToolTip,
58801 &_swigt__p_wxUpdateUIEvent,
58802 &_swigt__p_wxValidator,
58803 &_swigt__p_wxVisualAttributes,
58804 &_swigt__p_wxWindow,
58805 &_swigt__p_wxWindowCreateEvent,
58806 &_swigt__p_wxWindowDestroyEvent,
58807 &_swigt__p_wxXPMHandler,
58808 &_swigt__p_wxZipFSHandler,
58809 };
58810
58811 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
58812 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
58813 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
58814 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
58815 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
58816 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
58817 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
58818 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
58819 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
58820 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
58821 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
58822 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
58823 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
58824 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
58825 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}};
58826 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
58827 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}};
58828 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
58829 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}};
58830 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
58831 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58832 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
58833 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
58834 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
58835 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}};
58836 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58837 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}};
58838 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
58839 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
58840 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
58841 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
58842 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
58843 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58844 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
58845 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
58846 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
58847 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
58848 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}};
58849 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
58850 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
58851 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}};
58852 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
58853 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
58854 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}};
58855 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}};
58856 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58857 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
58858 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
58859 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
58860 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
58861 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
58862 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
58863 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
58864 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}};
58865 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
58866 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}};
58867 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58868 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
58869 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
58870 static swig_cast_info _swigc__p_wxImageHandler[] = { {&_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}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58871 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
58872 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
58873 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
58874 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
58875 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
58876 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
58877 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58878 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}};
58879 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
58880 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58881 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
58882 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58883 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58884 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
58885 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
58886 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
58887 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58888 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
58889 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58890 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
58891 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
58892 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
58893 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58894 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58895 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
58896 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_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_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_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_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_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}};
58897 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
58898 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
58899 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
58900 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
58901 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58902 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58903 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
58904 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
58905 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
58906 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
58907 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
58908 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
58909 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
58910 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
58911 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
58912 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
58913 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58914 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
58915 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
58916 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
58917 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
58918 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
58919 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
58920 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
58921 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
58922 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
58923 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
58924 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
58925 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
58926 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
58927 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
58928 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58929 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}};
58930 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}};
58931 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
58932 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
58933 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
58934 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58935 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
58936 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
58937 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
58938 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
58939 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}};
58940 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
58941 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}};
58942 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
58943 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
58944 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
58945 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58946
58947 static swig_cast_info *swig_cast_initial[] = {
58948 _swigc__p_buffer,
58949 _swigc__p_char,
58950 _swigc__p_form_ops_t,
58951 _swigc__p_int,
58952 _swigc__p_long,
58953 _swigc__p_unsigned_char,
58954 _swigc__p_unsigned_int,
58955 _swigc__p_unsigned_long,
58956 _swigc__p_wxANIHandler,
58957 _swigc__p_wxAcceleratorEntry,
58958 _swigc__p_wxAcceleratorTable,
58959 _swigc__p_wxActivateEvent,
58960 _swigc__p_wxAppTraits,
58961 _swigc__p_wxArrayString,
58962 _swigc__p_wxBMPHandler,
58963 _swigc__p_wxBitmap,
58964 _swigc__p_wxBoxSizer,
58965 _swigc__p_wxButton,
58966 _swigc__p_wxCURHandler,
58967 _swigc__p_wxCaret,
58968 _swigc__p_wxChildFocusEvent,
58969 _swigc__p_wxClipboardTextEvent,
58970 _swigc__p_wxCloseEvent,
58971 _swigc__p_wxColour,
58972 _swigc__p_wxCommandEvent,
58973 _swigc__p_wxContextMenuEvent,
58974 _swigc__p_wxControl,
58975 _swigc__p_wxControlWithItems,
58976 _swigc__p_wxCursor,
58977 _swigc__p_wxDC,
58978 _swigc__p_wxDateEvent,
58979 _swigc__p_wxDateTime,
58980 _swigc__p_wxDisplayChangedEvent,
58981 _swigc__p_wxDouble,
58982 _swigc__p_wxDropFilesEvent,
58983 _swigc__p_wxDuplexMode,
58984 _swigc__p_wxEraseEvent,
58985 _swigc__p_wxEvent,
58986 _swigc__p_wxEventLoop,
58987 _swigc__p_wxEventLoopActivator,
58988 _swigc__p_wxEvtHandler,
58989 _swigc__p_wxFSFile,
58990 _swigc__p_wxFileSystem,
58991 _swigc__p_wxFileSystemHandler,
58992 _swigc__p_wxFlexGridSizer,
58993 _swigc__p_wxFocusEvent,
58994 _swigc__p_wxFont,
58995 _swigc__p_wxFrame,
58996 _swigc__p_wxGBPosition,
58997 _swigc__p_wxGBSizerItem,
58998 _swigc__p_wxGBSpan,
58999 _swigc__p_wxGIFHandler,
59000 _swigc__p_wxGridBagSizer,
59001 _swigc__p_wxGridSizer,
59002 _swigc__p_wxHelpEvent__Origin,
59003 _swigc__p_wxICOHandler,
59004 _swigc__p_wxIconizeEvent,
59005 _swigc__p_wxIdleEvent,
59006 _swigc__p_wxImage,
59007 _swigc__p_wxImageHandler,
59008 _swigc__p_wxImageHistogram,
59009 _swigc__p_wxImage_HSVValue,
59010 _swigc__p_wxImage_RGBValue,
59011 _swigc__p_wxIndividualLayoutConstraint,
59012 _swigc__p_wxInitDialogEvent,
59013 _swigc__p_wxInputStream,
59014 _swigc__p_wxInternetFSHandler,
59015 _swigc__p_wxItemContainer,
59016 _swigc__p_wxJPEGHandler,
59017 _swigc__p_wxKeyEvent,
59018 _swigc__p_wxLayoutConstraints,
59019 _swigc__p_wxMaximizeEvent,
59020 _swigc__p_wxMemoryFSHandler,
59021 _swigc__p_wxMenu,
59022 _swigc__p_wxMenuBar,
59023 _swigc__p_wxMenuBarBase,
59024 _swigc__p_wxMenuEvent,
59025 _swigc__p_wxMenuItem,
59026 _swigc__p_wxMouseCaptureChangedEvent,
59027 _swigc__p_wxMouseCaptureLostEvent,
59028 _swigc__p_wxMouseEvent,
59029 _swigc__p_wxMoveEvent,
59030 _swigc__p_wxNavigationKeyEvent,
59031 _swigc__p_wxNcPaintEvent,
59032 _swigc__p_wxNotifyEvent,
59033 _swigc__p_wxObject,
59034 _swigc__p_wxOutputStream,
59035 _swigc__p_wxPCXHandler,
59036 _swigc__p_wxPNGHandler,
59037 _swigc__p_wxPNMHandler,
59038 _swigc__p_wxPaintEvent,
59039 _swigc__p_wxPaletteChangedEvent,
59040 _swigc__p_wxPaperSize,
59041 _swigc__p_wxPoint,
59042 _swigc__p_wxPoint2D,
59043 _swigc__p_wxPropagateOnce,
59044 _swigc__p_wxPropagationDisabler,
59045 _swigc__p_wxPyApp,
59046 _swigc__p_wxPyCommandEvent,
59047 _swigc__p_wxPyDropTarget,
59048 _swigc__p_wxPyEvent,
59049 _swigc__p_wxPyFileSystemHandler,
59050 _swigc__p_wxPyImageHandler,
59051 _swigc__p_wxPyInputStream,
59052 _swigc__p_wxPySizer,
59053 _swigc__p_wxPyValidator,
59054 _swigc__p_wxQuantize,
59055 _swigc__p_wxQueryNewPaletteEvent,
59056 _swigc__p_wxRealPoint,
59057 _swigc__p_wxRect,
59058 _swigc__p_wxRect2D,
59059 _swigc__p_wxRegion,
59060 _swigc__p_wxScrollEvent,
59061 _swigc__p_wxScrollWinEvent,
59062 _swigc__p_wxSetCursorEvent,
59063 _swigc__p_wxShowEvent,
59064 _swigc__p_wxSize,
59065 _swigc__p_wxSizeEvent,
59066 _swigc__p_wxSizer,
59067 _swigc__p_wxSizerItem,
59068 _swigc__p_wxStaticBox,
59069 _swigc__p_wxStaticBoxSizer,
59070 _swigc__p_wxStdDialogButtonSizer,
59071 _swigc__p_wxSysColourChangedEvent,
59072 _swigc__p_wxTGAHandler,
59073 _swigc__p_wxTIFFHandler,
59074 _swigc__p_wxToolTip,
59075 _swigc__p_wxUpdateUIEvent,
59076 _swigc__p_wxValidator,
59077 _swigc__p_wxVisualAttributes,
59078 _swigc__p_wxWindow,
59079 _swigc__p_wxWindowCreateEvent,
59080 _swigc__p_wxWindowDestroyEvent,
59081 _swigc__p_wxXPMHandler,
59082 _swigc__p_wxZipFSHandler,
59083 };
59084
59085
59086 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
59087
59088 static swig_const_info swig_const_table[] = {
59089 {0, 0, 0, 0.0, 0, 0}};
59090
59091 #ifdef __cplusplus
59092 }
59093 #endif
59094 /* -----------------------------------------------------------------------------
59095 * Type initialization:
59096 * This problem is tough by the requirement that no dynamic
59097 * memory is used. Also, since swig_type_info structures store pointers to
59098 * swig_cast_info structures and swig_cast_info structures store pointers back
59099 * to swig_type_info structures, we need some lookup code at initialization.
59100 * The idea is that swig generates all the structures that are needed.
59101 * The runtime then collects these partially filled structures.
59102 * The SWIG_InitializeModule function takes these initial arrays out of
59103 * swig_module, and does all the lookup, filling in the swig_module.types
59104 * array with the correct data and linking the correct swig_cast_info
59105 * structures together.
59106 *
59107 * The generated swig_type_info structures are assigned staticly to an initial
59108 * array. We just loop though that array, and handle each type individually.
59109 * First we lookup if this type has been already loaded, and if so, use the
59110 * loaded structure instead of the generated one. Then we have to fill in the
59111 * cast linked list. The cast data is initially stored in something like a
59112 * two-dimensional array. Each row corresponds to a type (there are the same
59113 * number of rows as there are in the swig_type_initial array). Each entry in
59114 * a column is one of the swig_cast_info structures for that type.
59115 * The cast_initial array is actually an array of arrays, because each row has
59116 * a variable number of columns. So to actually build the cast linked list,
59117 * we find the array of casts associated with the type, and loop through it
59118 * adding the casts to the list. The one last trick we need to do is making
59119 * sure the type pointer in the swig_cast_info struct is correct.
59120 *
59121 * First off, we lookup the cast->type name to see if it is already loaded.
59122 * There are three cases to handle:
59123 * 1) If the cast->type has already been loaded AND the type we are adding
59124 * casting info to has not been loaded (it is in this module), THEN we
59125 * replace the cast->type pointer with the type pointer that has already
59126 * been loaded.
59127 * 2) If BOTH types (the one we are adding casting info to, and the
59128 * cast->type) are loaded, THEN the cast info has already been loaded by
59129 * the previous module so we just ignore it.
59130 * 3) Finally, if cast->type has not already been loaded, then we add that
59131 * swig_cast_info to the linked list (because the cast->type) pointer will
59132 * be correct.
59133 * ----------------------------------------------------------------------------- */
59134
59135 #ifdef __cplusplus
59136 extern "C" {
59137 #if 0
59138 } /* c-mode */
59139 #endif
59140 #endif
59141
59142 #if 0
59143 #define SWIGRUNTIME_DEBUG
59144 #endif
59145
59146 SWIGRUNTIME void
59147 SWIG_InitializeModule(void *clientdata) {
59148 size_t i;
59149 swig_module_info *module_head;
59150 static int init_run = 0;
59151
59152 clientdata = clientdata;
59153
59154 if (init_run) return;
59155 init_run = 1;
59156
59157 /* Initialize the swig_module */
59158 swig_module.type_initial = swig_type_initial;
59159 swig_module.cast_initial = swig_cast_initial;
59160
59161 /* Try and load any already created modules */
59162 module_head = SWIG_GetModule(clientdata);
59163 if (module_head) {
59164 swig_module.next = module_head->next;
59165 module_head->next = &swig_module;
59166 } else {
59167 /* This is the first module loaded */
59168 swig_module.next = &swig_module;
59169 SWIG_SetModule(clientdata, &swig_module);
59170 }
59171
59172 /* Now work on filling in swig_module.types */
59173 #ifdef SWIGRUNTIME_DEBUG
59174 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
59175 #endif
59176 for (i = 0; i < swig_module.size; ++i) {
59177 swig_type_info *type = 0;
59178 swig_type_info *ret;
59179 swig_cast_info *cast;
59180
59181 #ifdef SWIGRUNTIME_DEBUG
59182 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59183 #endif
59184
59185 /* if there is another module already loaded */
59186 if (swig_module.next != &swig_module) {
59187 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
59188 }
59189 if (type) {
59190 /* Overwrite clientdata field */
59191 #ifdef SWIGRUNTIME_DEBUG
59192 printf("SWIG_InitializeModule: found type %s\n", type->name);
59193 #endif
59194 if (swig_module.type_initial[i]->clientdata) {
59195 type->clientdata = swig_module.type_initial[i]->clientdata;
59196 #ifdef SWIGRUNTIME_DEBUG
59197 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
59198 #endif
59199 }
59200 } else {
59201 type = swig_module.type_initial[i];
59202 }
59203
59204 /* Insert casting types */
59205 cast = swig_module.cast_initial[i];
59206 while (cast->type) {
59207 /* Don't need to add information already in the list */
59208 ret = 0;
59209 #ifdef SWIGRUNTIME_DEBUG
59210 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
59211 #endif
59212 if (swig_module.next != &swig_module) {
59213 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
59214 #ifdef SWIGRUNTIME_DEBUG
59215 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
59216 #endif
59217 }
59218 if (ret) {
59219 if (type == swig_module.type_initial[i]) {
59220 #ifdef SWIGRUNTIME_DEBUG
59221 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
59222 #endif
59223 cast->type = ret;
59224 ret = 0;
59225 } else {
59226 /* Check for casting already in the list */
59227 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
59228 #ifdef SWIGRUNTIME_DEBUG
59229 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
59230 #endif
59231 if (!ocast) ret = 0;
59232 }
59233 }
59234
59235 if (!ret) {
59236 #ifdef SWIGRUNTIME_DEBUG
59237 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
59238 #endif
59239 if (type->cast) {
59240 type->cast->prev = cast;
59241 cast->next = type->cast;
59242 }
59243 type->cast = cast;
59244 }
59245 cast++;
59246 }
59247 /* Set entry in modules->types array equal to the type */
59248 swig_module.types[i] = type;
59249 }
59250 swig_module.types[i] = 0;
59251
59252 #ifdef SWIGRUNTIME_DEBUG
59253 printf("**** SWIG_InitializeModule: Cast List ******\n");
59254 for (i = 0; i < swig_module.size; ++i) {
59255 int j = 0;
59256 swig_cast_info *cast = swig_module.cast_initial[i];
59257 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59258 while (cast->type) {
59259 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
59260 cast++;
59261 ++j;
59262 }
59263 printf("---- Total casts: %d\n",j);
59264 }
59265 printf("**** SWIG_InitializeModule: Cast List ******\n");
59266 #endif
59267 }
59268
59269 /* This function will propagate the clientdata field of type to
59270 * any new swig_type_info structures that have been added into the list
59271 * of equivalent types. It is like calling
59272 * SWIG_TypeClientData(type, clientdata) a second time.
59273 */
59274 SWIGRUNTIME void
59275 SWIG_PropagateClientData(void) {
59276 size_t i;
59277 swig_cast_info *equiv;
59278 static int init_run = 0;
59279
59280 if (init_run) return;
59281 init_run = 1;
59282
59283 for (i = 0; i < swig_module.size; i++) {
59284 if (swig_module.types[i]->clientdata) {
59285 equiv = swig_module.types[i]->cast;
59286 while (equiv) {
59287 if (!equiv->converter) {
59288 if (equiv->type && !equiv->type->clientdata)
59289 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
59290 }
59291 equiv = equiv->next;
59292 }
59293 }
59294 }
59295 }
59296
59297 #ifdef __cplusplus
59298 #if 0
59299 {
59300 /* c-mode */
59301 #endif
59302 }
59303 #endif
59304
59305
59306
59307 #ifdef __cplusplus
59308 extern "C" {
59309 #endif
59310
59311 /* Python-specific SWIG API */
59312 #define SWIG_newvarlink() SWIG_Python_newvarlink()
59313 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
59314 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
59315
59316 /* -----------------------------------------------------------------------------
59317 * global variable support code.
59318 * ----------------------------------------------------------------------------- */
59319
59320 typedef struct swig_globalvar {
59321 char *name; /* Name of global variable */
59322 PyObject *(*get_attr)(void); /* Return the current value */
59323 int (*set_attr)(PyObject *); /* Set the value */
59324 struct swig_globalvar *next;
59325 } swig_globalvar;
59326
59327 typedef struct swig_varlinkobject {
59328 PyObject_HEAD
59329 swig_globalvar *vars;
59330 } swig_varlinkobject;
59331
59332 SWIGINTERN PyObject *
59333 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
59334 return PyString_FromString("<Swig global variables>");
59335 }
59336
59337 SWIGINTERN PyObject *
59338 swig_varlink_str(swig_varlinkobject *v) {
59339 PyObject *str = PyString_FromString("(");
59340 swig_globalvar *var;
59341 for (var = v->vars; var; var=var->next) {
59342 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
59343 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
59344 }
59345 PyString_ConcatAndDel(&str,PyString_FromString(")"));
59346 return str;
59347 }
59348
59349 SWIGINTERN int
59350 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
59351 PyObject *str = swig_varlink_str(v);
59352 fprintf(fp,"Swig global variables ");
59353 fprintf(fp,"%s\n", PyString_AsString(str));
59354 Py_DECREF(str);
59355 return 0;
59356 }
59357
59358 SWIGINTERN void
59359 swig_varlink_dealloc(swig_varlinkobject *v) {
59360 swig_globalvar *var = v->vars;
59361 while (var) {
59362 swig_globalvar *n = var->next;
59363 free(var->name);
59364 free(var);
59365 var = n;
59366 }
59367 }
59368
59369 SWIGINTERN PyObject *
59370 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
59371 PyObject *res = NULL;
59372 swig_globalvar *var = v->vars;
59373 while (var) {
59374 if (strcmp(var->name,n) == 0) {
59375 res = (*var->get_attr)();
59376 break;
59377 }
59378 var = var->next;
59379 }
59380 if (res == NULL && !PyErr_Occurred()) {
59381 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59382 }
59383 return res;
59384 }
59385
59386 SWIGINTERN int
59387 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
59388 int res = 1;
59389 swig_globalvar *var = v->vars;
59390 while (var) {
59391 if (strcmp(var->name,n) == 0) {
59392 res = (*var->set_attr)(p);
59393 break;
59394 }
59395 var = var->next;
59396 }
59397 if (res == 1 && !PyErr_Occurred()) {
59398 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59399 }
59400 return res;
59401 }
59402
59403 SWIGINTERN PyTypeObject*
59404 swig_varlink_type(void) {
59405 static char varlink__doc__[] = "Swig var link object";
59406 static PyTypeObject varlink_type;
59407 static int type_init = 0;
59408 if (!type_init) {
59409 const PyTypeObject tmp
59410 = {
59411 PyObject_HEAD_INIT(NULL)
59412 0, /* Number of items in variable part (ob_size) */
59413 (char *)"swigvarlink", /* Type name (tp_name) */
59414 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
59415 0, /* Itemsize (tp_itemsize) */
59416 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
59417 (printfunc) swig_varlink_print, /* Print (tp_print) */
59418 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
59419 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
59420 0, /* tp_compare */
59421 (reprfunc) swig_varlink_repr, /* tp_repr */
59422 0, /* tp_as_number */
59423 0, /* tp_as_sequence */
59424 0, /* tp_as_mapping */
59425 0, /* tp_hash */
59426 0, /* tp_call */
59427 (reprfunc)swig_varlink_str, /* tp_str */
59428 0, /* tp_getattro */
59429 0, /* tp_setattro */
59430 0, /* tp_as_buffer */
59431 0, /* tp_flags */
59432 varlink__doc__, /* tp_doc */
59433 0, /* tp_traverse */
59434 0, /* tp_clear */
59435 0, /* tp_richcompare */
59436 0, /* tp_weaklistoffset */
59437 #if PY_VERSION_HEX >= 0x02020000
59438 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
59439 #endif
59440 #if PY_VERSION_HEX >= 0x02030000
59441 0, /* tp_del */
59442 #endif
59443 #ifdef COUNT_ALLOCS
59444 0,0,0,0 /* tp_alloc -> tp_next */
59445 #endif
59446 };
59447 varlink_type = tmp;
59448 varlink_type.ob_type = &PyType_Type;
59449 type_init = 1;
59450 }
59451 return &varlink_type;
59452 }
59453
59454 /* Create a variable linking object for use later */
59455 SWIGINTERN PyObject *
59456 SWIG_Python_newvarlink(void) {
59457 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
59458 if (result) {
59459 result->vars = 0;
59460 }
59461 return ((PyObject*) result);
59462 }
59463
59464 SWIGINTERN void
59465 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
59466 swig_varlinkobject *v = (swig_varlinkobject *) p;
59467 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
59468 if (gv) {
59469 size_t size = strlen(name)+1;
59470 gv->name = (char *)malloc(size);
59471 if (gv->name) {
59472 strncpy(gv->name,name,size);
59473 gv->get_attr = get_attr;
59474 gv->set_attr = set_attr;
59475 gv->next = v->vars;
59476 }
59477 }
59478 v->vars = gv;
59479 }
59480
59481 SWIGINTERN PyObject *
59482 SWIG_globals() {
59483 static PyObject *_SWIG_globals = 0;
59484 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
59485 return _SWIG_globals;
59486 }
59487
59488 /* -----------------------------------------------------------------------------
59489 * constants/methods manipulation
59490 * ----------------------------------------------------------------------------- */
59491
59492 /* Install Constants */
59493 SWIGINTERN void
59494 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
59495 PyObject *obj = 0;
59496 size_t i;
59497 for (i = 0; constants[i].type; ++i) {
59498 switch(constants[i].type) {
59499 case SWIG_PY_POINTER:
59500 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
59501 break;
59502 case SWIG_PY_BINARY:
59503 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
59504 break;
59505 default:
59506 obj = 0;
59507 break;
59508 }
59509 if (obj) {
59510 PyDict_SetItemString(d, constants[i].name, obj);
59511 Py_DECREF(obj);
59512 }
59513 }
59514 }
59515
59516 /* -----------------------------------------------------------------------------*/
59517 /* Fix SwigMethods to carry the callback ptrs when needed */
59518 /* -----------------------------------------------------------------------------*/
59519
59520 SWIGINTERN void
59521 SWIG_Python_FixMethods(PyMethodDef *methods,
59522 swig_const_info *const_table,
59523 swig_type_info **types,
59524 swig_type_info **types_initial) {
59525 size_t i;
59526 for (i = 0; methods[i].ml_name; ++i) {
59527 const char *c = methods[i].ml_doc;
59528 if (c && (c = strstr(c, "swig_ptr: "))) {
59529 int j;
59530 swig_const_info *ci = 0;
59531 const char *name = c + 10;
59532 for (j = 0; const_table[j].type; ++j) {
59533 if (strncmp(const_table[j].name, name,
59534 strlen(const_table[j].name)) == 0) {
59535 ci = &(const_table[j]);
59536 break;
59537 }
59538 }
59539 if (ci) {
59540 size_t shift = (ci->ptype) - types;
59541 swig_type_info *ty = types_initial[shift];
59542 size_t ldoc = (c - methods[i].ml_doc);
59543 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
59544 char *ndoc = (char*)malloc(ldoc + lptr + 10);
59545 if (ndoc) {
59546 char *buff = ndoc;
59547 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
59548 if (ptr) {
59549 strncpy(buff, methods[i].ml_doc, ldoc);
59550 buff += ldoc;
59551 strncpy(buff, "swig_ptr: ", 10);
59552 buff += 10;
59553 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
59554 methods[i].ml_doc = ndoc;
59555 }
59556 }
59557 }
59558 }
59559 }
59560 }
59561
59562 #ifdef __cplusplus
59563 }
59564 #endif
59565
59566 /* -----------------------------------------------------------------------------*
59567 * Partial Init method
59568 * -----------------------------------------------------------------------------*/
59569
59570 #ifdef __cplusplus
59571 extern "C"
59572 #endif
59573 SWIGEXPORT void SWIG_init(void) {
59574 PyObject *m, *d;
59575
59576 /* Fix SwigMethods to carry the callback ptrs when needed */
59577 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
59578
59579 m = Py_InitModule((char *) SWIG_name, SwigMethods);
59580 d = PyModule_GetDict(m);
59581
59582 SWIG_InitializeModule(0);
59583 SWIG_InstallConstants(d,swig_const_table);
59584
59585
59586
59587 #ifndef wxPyUSE_EXPORT
59588 // Make our API structure a CObject so other modules can import it
59589 // from this module.
59590 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
59591 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
59592 Py_XDECREF(cobj);
59593 #endif
59594
59595 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
59596 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
59597 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
59598 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
59599 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
59600 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
59601 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
59602 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
59603 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
59604 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
59605 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
59606 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
59607 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
59608 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
59609 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
59610 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
59611 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
59612 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
59613 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
59614 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
59615 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
59616 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
59617 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
59618 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
59619 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
59620 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
59621 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
59622 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
59623 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
59624 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
59625 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
59626 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
59627 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
59628 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
59629 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
59630 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
59631 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
59632 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
59633 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
59634 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
59635 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
59636 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
59637 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
59638 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
59639 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
59640 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
59641 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
59642 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
59643 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
59644 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
59645 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
59646 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
59647 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
59648 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
59649 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
59650 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
59651 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
59652 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
59653 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
59654 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
59655 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
59656 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
59657 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
59658 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
59659 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
59660 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
59661 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
59662 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
59663 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
59664 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
59665 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
59666 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
59667 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
59668 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
59669 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
59670 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
59671 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
59672 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
59673 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
59674 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
59675 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
59676 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
59677 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
59678 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
59679 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
59680 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
59681 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
59682 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
59683 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
59684 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
59685 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
59686 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
59687 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
59688 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
59689 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
59690 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
59691 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
59692 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
59693 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
59694 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
59695 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
59696 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
59697 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
59698 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
59699 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
59700 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
59701 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
59702 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
59703 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
59704 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
59705 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
59706 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
59707 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
59708 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
59709 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
59710 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
59711 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
59712 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
59713 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
59714 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
59715 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
59716 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
59717 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
59718 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
59719 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
59720 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
59721 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
59722 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
59723 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
59724 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
59725 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
59726 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
59727 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
59728 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
59729 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
59730 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
59731 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
59732 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
59733 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
59734 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
59735 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
59736 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
59737 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
59738 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
59739 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
59740 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
59741 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
59742 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
59743 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
59744 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
59745 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
59746 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
59747 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
59748 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
59749 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
59750 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
59751 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
59752 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
59753 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
59754 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
59755 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
59756 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
59757 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
59758 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
59759 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
59760 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
59761 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
59762 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
59763 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
59764 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
59765 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
59766 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
59767 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
59768 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
59769 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
59770 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
59771 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
59772 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
59773 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
59774 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
59775 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
59776 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
59777 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
59778 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
59779 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
59780 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
59781 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
59782 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
59783 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
59784 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
59785 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
59786 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
59787 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
59788 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
59789 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
59790 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
59791 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
59792 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
59793 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
59794 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
59795 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
59796 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
59797 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
59798 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
59799 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
59800 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
59801 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
59802 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
59803 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
59804 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
59805 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
59806 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
59807 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
59808 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
59809 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
59810 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
59811 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
59812 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
59813 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
59814 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
59815 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
59816 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
59817 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
59818 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
59819 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
59820 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
59821 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
59822 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
59823 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
59824 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
59825 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
59826 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
59827 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
59828 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
59829 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
59830 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
59831 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
59832 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
59833 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
59834 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
59835 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
59836 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
59837 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
59838 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
59839 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
59840 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
59841 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
59842 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
59843 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
59844 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
59845 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
59846 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
59847 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
59848 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
59849 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
59850 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
59851 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
59852 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
59853 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
59854 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
59855 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
59856 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
59857 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
59858 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
59859 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
59860 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
59861 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
59862 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
59863 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
59864 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
59865 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
59866 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
59867 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
59868 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
59869 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
59870 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
59871 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
59872 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
59873 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
59874 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
59875 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
59876 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
59877 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
59878 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
59879 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
59880 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
59881 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
59882 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
59883 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
59884 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
59885 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
59886 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
59887 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
59888 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
59889 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
59890 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
59891 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
59892 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
59893 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
59894 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
59895 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
59896 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
59897 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
59898 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
59899 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
59900 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
59901 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
59902 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
59903 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
59904 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
59905 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
59906 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
59907 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
59908 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
59909 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
59910 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
59911 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
59912 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
59913 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
59914 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
59915 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
59916 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
59917 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
59918 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
59919 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
59920 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
59921 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
59922 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
59923 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
59924 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
59925 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
59926 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
59927 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
59928 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
59929 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
59930 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
59931 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
59932 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
59933 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
59934 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
59935 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
59936 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
59937 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
59938 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
59939 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
59940 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
59941 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
59942 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
59943 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
59944 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
59945 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
59946 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
59947 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
59948 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
59949 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
59950 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
59951 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
59952 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
59953 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
59954 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
59955 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
59956 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
59957 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
59958 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
59959 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
59960 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
59961 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
59962 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
59963 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
59964 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
59965 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
59966 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
59967 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
59968 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
59969 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
59970 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
59971 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
59972 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
59973 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
59974 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
59975 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
59976 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
59977 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
59978 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
59979 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
59980 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
59981 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
59982 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
59983 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
59984 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
59985 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
59986 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
59987 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
59988 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
59989 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
59990 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
59991 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
59992 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
59993 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
59994 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
59995 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
59996 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
59997 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
59998 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
59999 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
60000 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
60001 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
60002 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
60003 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
60004 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
60005 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
60006 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
60007 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
60008 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
60009 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
60010 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
60011 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
60012 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
60013 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
60014 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
60015 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
60016 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
60017 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
60018 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
60019 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
60020 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
60021 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
60022 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
60023 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
60024 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
60025 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
60026 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
60027 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
60028 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
60029 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
60030 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
60031 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
60032 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
60033 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
60034 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
60035 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
60036 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
60037 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
60038 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
60039 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
60040 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
60041 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
60042 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
60043 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
60044 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
60045 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
60046 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
60047 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
60048 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
60049 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
60050 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
60051 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
60052 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
60053 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
60054 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
60055 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
60056 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
60057 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
60058 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
60059 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
60060 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
60061 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
60062 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
60063 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
60064 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
60065 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
60066 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
60067 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
60068 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
60069 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
60070 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
60071 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
60072 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
60073 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
60074 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
60075 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
60076 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
60077 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
60078 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
60079 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
60080 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
60081 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
60082 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
60083 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
60084 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
60085 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
60086 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
60087 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
60088 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
60089 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
60090 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
60091 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
60092 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
60093 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
60094 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
60095 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
60096 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
60097 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
60098 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
60099 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
60100 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
60101 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
60102 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
60103 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
60104 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
60105 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
60106 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
60107 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
60108 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
60109 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
60110 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
60111 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
60112 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
60113 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
60114 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
60115 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
60116 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
60117 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
60118 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
60119 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
60120 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
60121 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
60122 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
60123 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
60124 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
60125 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
60126 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
60127 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
60128 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
60129 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
60130 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
60131 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
60132 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
60133 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
60134 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
60135 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
60136 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
60137 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
60138 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
60139 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
60140 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
60141 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
60142 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
60143 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
60144 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
60145 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
60146 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
60147 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
60148 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
60149 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
60150 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
60151 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
60152 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
60153 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
60154 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
60155 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
60156 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
60157 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
60158 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
60159 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
60160 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
60161 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
60162 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
60163 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
60164 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
60165 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
60166 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
60167 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
60168 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
60169 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
60170 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
60171 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
60172 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
60173 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
60174 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
60175 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
60176 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
60177 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
60178 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
60179 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
60180 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
60181 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
60182 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
60183 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
60184 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
60185 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
60186 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
60187 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
60188 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
60189 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
60190 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
60191 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
60192 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
60193 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
60194 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
60195 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
60196 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
60197 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
60198 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
60199 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
60200 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
60201 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
60202 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
60203 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
60204 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
60205 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
60206 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
60207 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
60208 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
60209 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
60210 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
60211 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
60212 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
60213 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
60214 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
60215 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
60216 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
60217 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
60218 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
60219 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
60220 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
60221 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
60222 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
60223 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
60224 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
60225 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
60226 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
60227 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
60228 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
60229 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
60230 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
60231 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
60232 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
60233 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
60234 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
60235 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
60236 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
60237 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
60238 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
60239 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
60240 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
60241 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
60242 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
60243 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
60244 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
60245 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
60246 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
60247 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
60248 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
60249 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
60250 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
60251 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
60252 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
60253 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
60254 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
60255 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
60256 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
60257 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
60258 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
60259 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
60260
60261 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
60262
60263
60264 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
60265
60266 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
60267 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
60268 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
60269 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
60270 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
60271 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
60272 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
60273 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
60274 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
60275 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
60276 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
60277 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
60278 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
60279 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
60280 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
60281 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
60282 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
60283 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
60284 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
60285 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
60286 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
60287 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
60288 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
60289 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
60290 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
60291 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
60292 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
60293 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
60294 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
60295 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
60296 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
60297 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
60298 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
60299 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
60300 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
60301 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
60302 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
60303 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
60304 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
60305 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
60306 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
60307 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
60308 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
60309 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
60310 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
60311 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
60312 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
60313 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
60314 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
60315 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
60316 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
60317 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
60318 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
60319 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
60320 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
60321 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
60322 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
60323 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
60324 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
60325 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
60326 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
60327 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
60328 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
60329 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
60330 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
60331 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
60332 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
60333 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
60334 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
60335 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
60336 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
60337 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
60338 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
60339 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
60340 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
60341 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
60342 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
60343 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
60344 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
60345 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
60346 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
60347 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
60348 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
60349 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
60350 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
60351 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
60352 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
60353 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
60354 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
60355 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
60356 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
60357 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
60358 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
60359 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
60360 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
60361 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
60362 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
60363 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
60364 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
60365 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
60366 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
60367 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
60368 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
60369 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
60370 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
60371 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
60372 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
60373 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
60374 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
60375 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
60376 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
60377 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
60378 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
60379 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
60380 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
60381 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
60382 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
60383 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
60384 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
60385 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
60386 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
60387 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
60388 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
60389 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
60390 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
60391 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
60392 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
60393 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
60394 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
60395 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
60396 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
60397 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
60398 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
60399 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
60400 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
60401 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
60402 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
60403 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
60404 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
60405 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
60406 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
60407 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
60408 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
60409 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
60410 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
60411 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
60412 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
60413 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
60414 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
60415 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
60416 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
60417 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
60418 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
60419 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
60420 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
60421 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
60422 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
60423 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
60424 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
60425 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
60426 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
60427 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
60428 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
60429 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
60430 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
60431 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
60432 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
60433 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
60434 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
60435 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
60436 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
60437 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
60438 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
60439 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
60440 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
60441 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
60442 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
60443 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
60444 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
60445 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
60446 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
60447 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
60448 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
60449 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
60450 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
60451 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
60452 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
60453 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
60454 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
60455 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
60456 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
60457 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
60458 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
60459 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
60460 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
60461 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
60462 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
60463 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
60464 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
60465 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
60466 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
60467 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
60468 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
60469 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
60470 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
60471 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
60472 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
60473 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
60474 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
60475 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
60476 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
60477 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
60478 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
60479 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
60480
60481 // Initialize threading, some globals and such
60482 __wxPyPreStart(d);
60483
60484
60485 // Although these are defined in __version__ they need to be here too so
60486 // that an assert can be done to ensure that the wxPython and the wxWindows
60487 // versions match.
60488 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
60489 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
60490 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
60491
60492 }
60493
wxWidgets (Impactor)