]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
added --enable-tga (on by default)
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_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_wxTIFFHandler swig_types[124]
2591 #define SWIGTYPE_p_wxToolTip swig_types[125]
2592 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[126]
2593 #define SWIGTYPE_p_wxValidator swig_types[127]
2594 #define SWIGTYPE_p_wxVisualAttributes swig_types[128]
2595 #define SWIGTYPE_p_wxWindow swig_types[129]
2596 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[130]
2597 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[131]
2598 #define SWIGTYPE_p_wxXPMHandler swig_types[132]
2599 #define SWIGTYPE_p_wxZipFSHandler swig_types[133]
2600 static swig_type_info *swig_types[135];
2601 static swig_module_info swig_module = {swig_types, 134, 0, 0, 0, 0};
2602 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2603 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2604
2605 /* -------- TYPES TABLE (END) -------- */
2606
2607 #if (PY_VERSION_HEX <= 0x02000000)
2608 # if !defined(SWIG_PYTHON_CLASSIC)
2609 # error "This python version requires to use swig with the '-classic' option"
2610 # endif
2611 #endif
2612 #if (PY_VERSION_HEX <= 0x02020000)
2613 # error "This python version requires to use swig with the '-nomodern' option"
2614 #endif
2615 #if (PY_VERSION_HEX <= 0x02020000)
2616 # error "This python version requires to use swig with the '-nomodernargs' option"
2617 #endif
2618 #ifndef METH_O
2619 # error "This python version requires to use swig with the '-nofastunpack' option"
2620 #endif
2621
2622 /*-----------------------------------------------
2623 @(target):= _core_.so
2624 ------------------------------------------------*/
2625 #define SWIG_init init_core_
2626
2627 #define SWIG_name "_core_"
2628
2629 #define SWIGVERSION 0x010329
2630
2631
2632 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2633 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2634
2635
2636 #include <stdexcept>
2637
2638
2639 namespace swig {
2640 class PyObject_ptr {
2641 protected:
2642 PyObject *_obj;
2643
2644 public:
2645 PyObject_ptr() :_obj(0)
2646 {
2647 }
2648
2649 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2650 {
2651 Py_XINCREF(_obj);
2652 }
2653
2654 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2655 {
2656 if (initial_ref) Py_XINCREF(_obj);
2657 }
2658
2659 PyObject_ptr & operator=(const PyObject_ptr& item)
2660 {
2661 Py_XINCREF(item._obj);
2662 Py_XDECREF(_obj);
2663 _obj = item._obj;
2664 return *this;
2665 }
2666
2667 ~PyObject_ptr()
2668 {
2669 Py_XDECREF(_obj);
2670 }
2671
2672 operator PyObject *() const
2673 {
2674 return _obj;
2675 }
2676
2677 PyObject *operator->() const
2678 {
2679 return _obj;
2680 }
2681 };
2682 }
2683
2684
2685 namespace swig {
2686 struct PyObject_var : PyObject_ptr {
2687 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2688
2689 PyObject_var & operator = (PyObject* obj)
2690 {
2691 Py_XDECREF(_obj);
2692 _obj = obj;
2693 return *this;
2694 }
2695 };
2696 }
2697
2698
2699 #include "wx/wxPython/wxPython_int.h"
2700 #include "wx/wxPython/pyclasses.h"
2701 #include "wx/wxPython/twoitem.h"
2702
2703
2704 #ifndef wxPyUSE_EXPORT
2705 // Helper functions for dealing with SWIG objects and such. These are
2706 // located here so they know about the SWIG types and functions declared
2707 // in the wrapper code.
2708
2709 #include <wx/hashmap.h>
2710 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2711
2712
2713 // Maintains a hashmap of className to swig_type_info pointers. Given the
2714 // name of a class either looks up the type info in the cache, or scans the
2715 // SWIG tables for it.
2716 extern PyObject* wxPyPtrTypeMap;
2717 static
2718 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2719
2720 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2721
2722 if (typeInfoCache == NULL)
2723 typeInfoCache = new wxPyTypeInfoHashMap;
2724
2725 wxString name(className);
2726 swig_type_info* swigType = (*typeInfoCache)[name];
2727
2728 if (! swigType) {
2729 // it wasn't in the cache, so look it up from SWIG
2730 name.Append(wxT(" *"));
2731 swigType = SWIG_TypeQuery(name.mb_str());
2732
2733 // if it still wasn't found, try looking for a mapped name
2734 if (!swigType) {
2735 PyObject* item;
2736 name = className;
2737
2738 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2739 (char*)(const char*)name.mbc_str())) != NULL) {
2740 name = wxString(PyString_AsString(item), *wxConvCurrent);
2741 name.Append(wxT(" *"));
2742 swigType = SWIG_TypeQuery(name.mb_str());
2743 }
2744 }
2745 if (swigType) {
2746 // and add it to the map if found
2747 (*typeInfoCache)[className] = swigType;
2748 }
2749 }
2750 return swigType;
2751 }
2752
2753
2754 // Check if a class name is a type known to SWIG
2755 bool wxPyCheckSwigType(const wxChar* className) {
2756
2757 swig_type_info* swigType = wxPyFindSwigType(className);
2758 return swigType != NULL;
2759 }
2760
2761
2762 // Given a pointer to a C++ object and a class name, construct a Python proxy
2763 // object for it.
2764 PyObject* wxPyConstructObject(void* ptr,
2765 const wxChar* className,
2766 int setThisOwn) {
2767
2768 swig_type_info* swigType = wxPyFindSwigType(className);
2769 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2770
2771 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2772 }
2773
2774
2775 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2776 // Ensures that the proxy object is of the specified (or derived) type. If
2777 // not able to perform the conversion then a Python exception is set and the
2778 // error should be handled properly in the caller. Returns True on success.
2779 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2780 const wxChar* className) {
2781
2782 swig_type_info* swigType = wxPyFindSwigType(className);
2783 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2784
2785 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2786 }
2787
2788
2789
2790 // Make a SWIGified pointer object suitable for a .this attribute
2791 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2792
2793 PyObject* robj = NULL;
2794
2795 swig_type_info* swigType = wxPyFindSwigType(className);
2796 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2797
2798 robj = PySwigObject_New(ptr, swigType, 0);
2799 return robj;
2800 }
2801
2802
2803 // Python's PyInstance_Check does not return True for instances of new-style
2804 // classes. This should get close enough for both new and old classes but I
2805 // should re-evaluate the need for doing instance checks...
2806 bool wxPyInstance_Check(PyObject* obj) {
2807 return PyObject_HasAttrString(obj, "__class__") != 0;
2808 }
2809
2810
2811 // This one checks if the object is an instance of a SWIG proxy class (it has
2812 // a .this attribute, and the .this attribute is a PySwigObject.)
2813 bool wxPySwigInstance_Check(PyObject* obj) {
2814 static PyObject* this_str = NULL;
2815 if (this_str == NULL)
2816 this_str = PyString_FromString("this");
2817
2818 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2819 if (this_attr) {
2820 bool retval = (PySwigObject_Check(this_attr) != 0);
2821 Py_DECREF(this_attr);
2822 return retval;
2823 }
2824
2825 PyErr_Clear();
2826 return false;
2827 }
2828
2829
2830 // Export a C API in a struct. Other modules will be able to load this from
2831 // the wx._core_ module and will then have safe access to these functions,
2832 // even if they are located in another shared library.
2833 static wxPyCoreAPI API = {
2834
2835 wxPyCheckSwigType,
2836 wxPyConstructObject,
2837 wxPyConvertSwigPtr,
2838 wxPyMakeSwigPtr,
2839
2840 wxPyBeginAllowThreads,
2841 wxPyEndAllowThreads,
2842 wxPyBeginBlockThreads,
2843 wxPyEndBlockThreads,
2844
2845 wxPy_ConvertList,
2846
2847 wxString_in_helper,
2848 Py2wxString,
2849 wx2PyString,
2850
2851 byte_LIST_helper,
2852 int_LIST_helper,
2853 long_LIST_helper,
2854 string_LIST_helper,
2855 wxPoint_LIST_helper,
2856 wxBitmap_LIST_helper,
2857 wxString_LIST_helper,
2858 wxAcceleratorEntry_LIST_helper,
2859
2860 wxSize_helper,
2861 wxPoint_helper,
2862 wxRealPoint_helper,
2863 wxRect_helper,
2864 wxColour_helper,
2865 wxPoint2D_helper,
2866
2867 wxPySimple_typecheck,
2868 wxColour_typecheck,
2869
2870 wxPyCBH_setCallbackInfo,
2871 wxPyCBH_findCallback,
2872 wxPyCBH_callCallback,
2873 wxPyCBH_callCallbackObj,
2874 wxPyCBH_delete,
2875
2876 wxPyMake_wxObject,
2877 wxPyMake_wxSizer,
2878 wxPyPtrTypeMap_Add,
2879 wxPy2int_seq_helper,
2880 wxPy4int_seq_helper,
2881 wxArrayString2PyList_helper,
2882 wxArrayInt2PyList_helper,
2883
2884 wxPyClientData_dtor,
2885 wxPyUserData_dtor,
2886 wxPyOORClientData_dtor,
2887
2888 wxPyCBInputStream_create,
2889 wxPyCBInputStream_copy,
2890
2891 wxPyInstance_Check,
2892 wxPySwigInstance_Check,
2893
2894 wxPyCheckForApp,
2895
2896 wxArrayDouble2PyList_helper,
2897 wxPoint2D_LIST_helper,
2898 wxRect2D_helper,
2899
2900 };
2901
2902 #endif
2903
2904
2905 #if !WXWIN_COMPATIBILITY_2_4
2906 #define wxHIDE_READONLY 0
2907 #endif
2908
2909
2910 #define SWIG_From_long PyInt_FromLong
2911
2912
2913 SWIGINTERNINLINE PyObject *
2914 SWIG_From_int (int value)
2915 {
2916 return SWIG_From_long (value);
2917 }
2918
2919 static const wxString wxPyEmptyString(wxEmptyString);
2920 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2921 return self->GetClassInfo()->GetClassName();
2922 }
2923 SWIGINTERN void wxObject_Destroy(wxObject *self){
2924 delete self;
2925 }
2926
2927 #ifndef __WXMAC__
2928 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2929 #endif
2930
2931
2932 #include <limits.h>
2933 #ifndef LLONG_MIN
2934 # define LLONG_MIN LONG_LONG_MIN
2935 #endif
2936 #ifndef LLONG_MAX
2937 # define LLONG_MAX LONG_LONG_MAX
2938 #endif
2939 #ifndef ULLONG_MAX
2940 # define ULLONG_MAX ULONG_LONG_MAX
2941 #endif
2942
2943
2944 SWIGINTERN int
2945 SWIG_AsVal_long (PyObject* obj, long* val)
2946 {
2947 if (PyNumber_Check(obj)) {
2948 if (val) *val = PyInt_AsLong(obj);
2949 return SWIG_OK;
2950 }
2951 return SWIG_TypeError;
2952 }
2953
2954
2955 SWIGINTERN int
2956 SWIG_AsVal_int (PyObject * obj, int *val)
2957 {
2958 long v;
2959 int res = SWIG_AsVal_long (obj, &v);
2960 if (SWIG_IsOK(res)) {
2961 if ((v < INT_MIN || v > INT_MAX)) {
2962 return SWIG_OverflowError;
2963 } else {
2964 if (val) *val = static_cast< int >(v);
2965 }
2966 }
2967 return res;
2968 }
2969
2970 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2971 wxSize temp, *obj = &temp;
2972 if ( other == Py_None ) return false;
2973 if ( ! wxSize_helper(other, &obj) ) {
2974 PyErr_Clear();
2975 return false;
2976 }
2977 return self->operator==(*obj);
2978 }
2979 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2980 wxSize temp, *obj = &temp;
2981 if ( other == Py_None ) return true;
2982 if ( ! wxSize_helper(other, &obj)) {
2983 PyErr_Clear();
2984 return true;
2985 }
2986 return self->operator!=(*obj);
2987 }
2988
2989 #include <float.h>
2990
2991
2992 SWIGINTERN int
2993 SWIG_AsVal_double (PyObject *obj, double* val)
2994 {
2995 if (PyNumber_Check(obj)) {
2996 if (val) *val = PyFloat_AsDouble(obj);
2997 return SWIG_OK;
2998 }
2999 return SWIG_TypeError;
3000 }
3001
3002
3003 SWIGINTERN int
3004 SWIG_AsVal_float (PyObject * obj, float *val)
3005 {
3006 double v;
3007 int res = SWIG_AsVal_double (obj, &v);
3008 if (SWIG_IsOK(res)) {
3009 if ((v < -FLT_MAX || v > FLT_MAX)) {
3010 return SWIG_OverflowError;
3011 } else {
3012 if (val) *val = static_cast< float >(v);
3013 }
3014 }
3015 return res;
3016 }
3017
3018 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3019 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3020 PyObject* tup = PyTuple_New(2);
3021 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3022 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3023 //wxPyEndBlockThreads(blocked);
3024 return tup;
3025 }
3026
3027 #define SWIG_From_double PyFloat_FromDouble
3028
3029 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3030 wxRealPoint temp, *obj = &temp;
3031 if ( other == Py_None ) return false;
3032 if ( ! wxRealPoint_helper(other, &obj) ) {
3033 PyErr_Clear();
3034 return false;
3035 }
3036 return self->operator==(*obj);
3037 }
3038 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3039 wxRealPoint temp, *obj = &temp;
3040 if ( other == Py_None ) return true;
3041 if ( ! wxRealPoint_helper(other, &obj)) {
3042 PyErr_Clear();
3043 return true;
3044 }
3045 return self->operator!=(*obj);
3046 }
3047 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3048 self->x = x;
3049 self->y = y;
3050 }
3051 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3052 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3053 PyObject* tup = PyTuple_New(2);
3054 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3055 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3056 //PyEndBlockThreads(blocked);
3057 return tup;
3058 }
3059 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3060 wxPoint temp, *obj = &temp;
3061 if ( other == Py_None ) return false;
3062 if ( ! wxPoint_helper(other, &obj) ) {
3063 PyErr_Clear();
3064 return false;
3065 }
3066 return self->operator==(*obj);
3067 }
3068 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3069 wxPoint temp, *obj = &temp;
3070 if ( other == Py_None ) return true;
3071 if ( ! wxPoint_helper(other, &obj)) {
3072 PyErr_Clear();
3073 return true;
3074 }
3075 return self->operator!=(*obj);
3076 }
3077 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3078 self->x = x;
3079 self->y = y;
3080 }
3081 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3082 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3083 PyObject* tup = PyTuple_New(2);
3084 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3085 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3086 //wxPyEndBlockThreads(blocked);
3087 return tup;
3088 }
3089 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3090 wxRect temp, *obj = &temp;
3091 if ( other == Py_None ) return false;
3092 if ( ! wxRect_helper(other, &obj) ) {
3093 PyErr_Clear();
3094 return false;
3095 }
3096 return self->operator==(*obj);
3097 }
3098 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3099 wxRect temp, *obj = &temp;
3100 if ( other == Py_None ) return true;
3101 if ( ! wxRect_helper(other, &obj)) {
3102 PyErr_Clear();
3103 return true;
3104 }
3105 return self->operator!=(*obj);
3106 }
3107 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3108 self->x = x;
3109 self->y = y;
3110 self->width = width;
3111 self->height = height;
3112 }
3113 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3114 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3115 PyObject* tup = PyTuple_New(4);
3116 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3117 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3118 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3119 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3120 //wxPyEndBlockThreads(blocked);
3121 return tup;
3122 }
3123
3124 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3125 wxRegion reg1(*r1);
3126 wxRegion reg2(*r2);
3127 wxRect dest(0,0,0,0);
3128 PyObject* obj;
3129
3130 reg1.Intersect(reg2);
3131 dest = reg1.GetBox();
3132
3133 if (dest != wxRect(0,0,0,0)) {
3134 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3135 wxRect* newRect = new wxRect(dest);
3136 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3137 //wxPyEndBlockThreads(blocked);
3138 return obj;
3139 }
3140 Py_INCREF(Py_None);
3141 return Py_None;
3142 }
3143
3144 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3145 wxPoint2D temp, *obj = &temp;
3146 if ( other == Py_None ) return false;
3147 if ( ! wxPoint2D_helper(other, &obj) ) {
3148 PyErr_Clear();
3149 return false;
3150 }
3151 return self->operator==(*obj);
3152 }
3153 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3154 wxPoint2D temp, *obj = &temp;
3155 if ( other == Py_None ) return true;
3156 if ( ! wxPoint2D_helper(other, &obj)) {
3157 PyErr_Clear();
3158 return true;
3159 }
3160 return self->operator!=(*obj);
3161 }
3162 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3163 self->m_x = x;
3164 self->m_y = y;
3165 }
3166 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3167 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3168 PyObject* tup = PyTuple_New(2);
3169 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3170 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3171 //wxPyEndBlockThreads(blocked);
3172 return tup;
3173 }
3174 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3175 wxRect2D temp, *obj = &temp;
3176 if ( other == Py_None ) return false;
3177 if ( ! wxRect2D_helper(other, &obj) ) {
3178 PyErr_Clear();
3179 return false;
3180 }
3181 return self->operator==(*obj);
3182 }
3183 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3184 wxRect2D temp, *obj = &temp;
3185 if ( other == Py_None ) return true;
3186 if ( ! wxRect2D_helper(other, &obj)) {
3187 PyErr_Clear();
3188 return true;
3189 }
3190 return self->operator!=(*obj);
3191 }
3192 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3193 self->m_x = x;
3194 self->m_y = y;
3195 self->m_width = width;
3196 self->m_height = height;
3197 }
3198 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3199 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3200 PyObject* tup = PyTuple_New(4);
3201 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3202 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3203 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3204 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3205 //wxPyEndBlockThreads(blocked);
3206 return tup;
3207 }
3208
3209 #include "wx/wxPython/pyistream.h"
3210
3211 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3212 wxInputStream* wxis = wxPyCBInputStream::create(p);
3213 if (wxis)
3214 return new wxPyInputStream(wxis);
3215 else
3216 return NULL;
3217 }
3218
3219 SWIGINTERN swig_type_info*
3220 SWIG_pchar_descriptor()
3221 {
3222 static int init = 0;
3223 static swig_type_info* info = 0;
3224 if (!init) {
3225 info = SWIG_TypeQuery("_p_char");
3226 init = 1;
3227 }
3228 return info;
3229 }
3230
3231
3232 SWIGINTERNINLINE PyObject *
3233 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3234 {
3235 if (carray) {
3236 if (size > INT_MAX) {
3237 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3238 return pchar_descriptor ?
3239 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3240 } else {
3241 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3242 }
3243 } else {
3244 return SWIG_Py_Void();
3245 }
3246 }
3247
3248
3249 SWIGINTERNINLINE PyObject *
3250 SWIG_From_char (char c)
3251 {
3252 return SWIG_FromCharPtrAndSize(&c,1);
3253 }
3254
3255
3256 SWIGINTERNINLINE PyObject*
3257 SWIG_From_unsigned_SS_long (unsigned long value)
3258 {
3259 return (value > LONG_MAX) ?
3260 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3261 }
3262
3263
3264 SWIGINTERNINLINE PyObject *
3265 SWIG_From_size_t (size_t value)
3266 {
3267 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3268 }
3269
3270
3271 SWIGINTERN int
3272 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3273 {
3274 if (PyString_Check(obj)) {
3275 char *cstr; Py_ssize_t len;
3276 PyString_AsStringAndSize(obj, &cstr, &len);
3277 if (cptr) {
3278 if (alloc) {
3279 /*
3280 In python the user should not be able to modify the inner
3281 string representation. To warranty that, if you define
3282 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3283 buffer is always returned.
3284
3285 The default behavior is just to return the pointer value,
3286 so, be careful.
3287 */
3288 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3289 if (*alloc != SWIG_OLDOBJ)
3290 #else
3291 if (*alloc == SWIG_NEWOBJ)
3292 #endif
3293 {
3294 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3295 *alloc = SWIG_NEWOBJ;
3296 }
3297 else {
3298 *cptr = cstr;
3299 *alloc = SWIG_OLDOBJ;
3300 }
3301 } else {
3302 *cptr = PyString_AsString(obj);
3303 }
3304 }
3305 if (psize) *psize = len + 1;
3306 return SWIG_OK;
3307 } else {
3308 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3309 if (pchar_descriptor) {
3310 void* vptr = 0;
3311 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3312 if (cptr) *cptr = (char *) vptr;
3313 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3314 if (alloc) *alloc = SWIG_OLDOBJ;
3315 return SWIG_OK;
3316 }
3317 }
3318 }
3319 return SWIG_TypeError;
3320 }
3321
3322
3323 SWIGINTERN int
3324 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3325 {
3326 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3327 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3328 if (SWIG_IsOK(res)) {
3329 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3330 if (csize <= size) {
3331 if (val) {
3332 if (csize) memcpy(val, cptr, csize*sizeof(char));
3333 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3334 }
3335 if (alloc == SWIG_NEWOBJ) {
3336 delete[] cptr;
3337 res = SWIG_DelNewMask(res);
3338 }
3339 return res;
3340 }
3341 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3342 }
3343 return SWIG_TypeError;
3344 }
3345
3346
3347 SWIGINTERN int
3348 SWIG_AsVal_char (PyObject * obj, char *val)
3349 {
3350 int res = SWIG_AsCharArray(obj, val, 1);
3351 if (!SWIG_IsOK(res)) {
3352 long v;
3353 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3354 if (SWIG_IsOK(res)) {
3355 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3356 if (val) *val = static_cast< char >(v);
3357 } else {
3358 res = SWIG_OverflowError;
3359 }
3360 }
3361 }
3362 return res;
3363 }
3364
3365 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3366 // We use only strings for the streams, not unicode
3367 PyObject* str = PyObject_Str(obj);
3368 if (! str) {
3369 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3370 return;
3371 }
3372 self->Write(PyString_AS_STRING(str),
3373 PyString_GET_SIZE(str));
3374 Py_DECREF(str);
3375 }
3376
3377 #include "wx/wxPython/pyistream.h"
3378
3379
3380 class wxPyFileSystemHandler : public wxFileSystemHandler
3381 {
3382 public:
3383 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3384
3385 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3386 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3387 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3388 DEC_PYCALLBACK_STRING__pure(FindNext);
3389
3390 wxString GetProtocol(const wxString& location) {
3391 return wxFileSystemHandler::GetProtocol(location);
3392 }
3393
3394 wxString GetLeftLocation(const wxString& location) {
3395 return wxFileSystemHandler::GetLeftLocation(location);
3396 }
3397
3398 wxString GetAnchor(const wxString& location) {
3399 return wxFileSystemHandler::GetAnchor(location);
3400 }
3401
3402 wxString GetRightLocation(const wxString& location) {
3403 return wxFileSystemHandler::GetRightLocation(location);
3404 }
3405
3406 wxString GetMimeTypeFromExt(const wxString& location) {
3407 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3408 }
3409
3410 PYPRIVATE;
3411 };
3412
3413
3414 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3415 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3416 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3417 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3418
3419
3420 SWIGINTERN int
3421 SWIG_AsVal_bool (PyObject *obj, bool *val)
3422 {
3423 if (obj == Py_True) {
3424 if (val) *val = true;
3425 return SWIG_OK;
3426 } else if (obj == Py_False) {
3427 if (val) *val = false;
3428 return SWIG_OK;
3429 } else {
3430 long v = 0;
3431 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3432 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3433 return res;
3434 }
3435 }
3436
3437 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3438 wxFileName fname = wxFileSystem::URLToFileName(url);
3439 return fname.GetFullPath();
3440 }
3441
3442 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3443 wxImage& image,
3444 long type) {
3445 wxMemoryFSHandler::AddFile(filename, image, type);
3446 }
3447
3448 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3449 const wxBitmap& bitmap,
3450 long type) {
3451 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3452 }
3453
3454 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3455 PyObject* data) {
3456 if (! PyString_Check(data)) {
3457 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3458 "Expected string object"));
3459 return;
3460 }
3461
3462 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3463 void* ptr = (void*)PyString_AsString(data);
3464 size_t size = PyString_Size(data);
3465 wxPyEndBlockThreads(blocked);
3466
3467 wxMemoryFSHandler::AddFile(filename, ptr, size);
3468 }
3469
3470
3471 #include "wx/wxPython/pyistream.h"
3472
3473
3474 SWIGINTERN int
3475 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3476 {
3477 long v = 0;
3478 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3479 return SWIG_TypeError;
3480 }
3481 else if (val)
3482 *val = (unsigned long)v;
3483 return SWIG_OK;
3484 }
3485
3486
3487 SWIGINTERN int
3488 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3489 {
3490 unsigned long v;
3491 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3492 if (SWIG_IsOK(res)) {
3493 if ((v > UCHAR_MAX)) {
3494 return SWIG_OverflowError;
3495 } else {
3496 if (val) *val = static_cast< unsigned char >(v);
3497 }
3498 }
3499 return res;
3500 }
3501
3502
3503 SWIGINTERNINLINE PyObject *
3504 SWIG_From_unsigned_SS_char (unsigned char value)
3505 {
3506 return SWIG_From_unsigned_SS_long (value);
3507 }
3508
3509 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3510 wxImageHistogramEntry e = (*self)[key];
3511 return e.value;
3512 }
3513 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3514 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3515 wxImageHistogramEntry e = (*self)[key];
3516 return e.value;
3517 }
3518 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3519 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3520 colour.Green(),
3521 colour.Blue());
3522 wxImageHistogramEntry e = (*self)[key];
3523 return e.value;
3524 }
3525
3526 // Pull the nested class out to the top level for SWIG's sake
3527 #define wxImage_RGBValue wxImage::RGBValue
3528 #define wxImage_HSVValue wxImage::HSVValue
3529
3530 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3531 if (width > 0 && height > 0)
3532 return new wxImage(width, height, clear);
3533 else
3534 return new wxImage;
3535 }
3536 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3537 return new wxImage(bitmap.ConvertToImage());
3538 }
3539 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3540 if (DATASIZE != width*height*3) {
3541 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3542 return NULL;
3543 }
3544
3545 // Copy the source data so the wxImage can clean it up later
3546 buffer copy = (buffer)malloc(DATASIZE);
3547 if (copy == NULL) {
3548 wxPyBLOCK_THREADS(PyErr_NoMemory());
3549 return NULL;
3550 }
3551 memcpy(copy, data, DATASIZE);
3552 return new wxImage(width, height, copy, false);
3553 }
3554 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3555 if (DATASIZE != width*height*3) {
3556 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3557 return NULL;
3558 }
3559 if (ALPHASIZE != width*height) {
3560 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3561 return NULL;
3562 }
3563
3564 // Copy the source data so the wxImage can clean it up later
3565 buffer dcopy = (buffer)malloc(DATASIZE);
3566 if (dcopy == NULL) {
3567 wxPyBLOCK_THREADS(PyErr_NoMemory());
3568 return NULL;
3569 }
3570 memcpy(dcopy, data, DATASIZE);
3571
3572 buffer acopy = (buffer)malloc(ALPHASIZE);
3573 if (acopy == NULL) {
3574 wxPyBLOCK_THREADS(PyErr_NoMemory());
3575 return NULL;
3576 }
3577 memcpy(acopy, alpha, ALPHASIZE);
3578
3579 return new wxImage(width, height, dcopy, acopy, false);
3580 }
3581 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3582 wxSize size(self->GetWidth(), self->GetHeight());
3583 return size;
3584 }
3585 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3586 buffer data = self->GetData();
3587 int len = self->GetWidth() * self->GetHeight() * 3;
3588 PyObject* rv;
3589 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3590 return rv;
3591 }
3592 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3593 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3594 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3595 return;
3596 }
3597 buffer copy = (buffer)malloc(DATASIZE);
3598 if (copy == NULL) {
3599 wxPyBLOCK_THREADS(PyErr_NoMemory());
3600 return;
3601 }
3602 memcpy(copy, data, DATASIZE);
3603 self->SetData(copy, false);
3604 // wxImage takes ownership of copy...
3605 }
3606 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3607 buffer data = self->GetData();
3608 int len = self->GetWidth() * self->GetHeight() * 3;
3609 PyObject* rv;
3610 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3611 return rv;
3612 }
3613 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3614 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3615 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3616 return;
3617 }
3618 self->SetData(data, true);
3619 }
3620 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3621 buffer data = self->GetAlpha();
3622 if (! data) {
3623 RETURN_NONE();
3624 } else {
3625 int len = self->GetWidth() * self->GetHeight();
3626 PyObject* rv;
3627 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3628 return rv;
3629 }
3630 }
3631 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3632 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3633 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3634 return;
3635 }
3636 buffer acopy = (buffer)malloc(ALPHASIZE);
3637 if (acopy == NULL) {
3638 wxPyBLOCK_THREADS(PyErr_NoMemory());
3639 return;
3640 }
3641 memcpy(acopy, alpha, ALPHASIZE);
3642 self->SetAlpha(acopy, false);
3643 // wxImage takes ownership of acopy...
3644 }
3645 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3646 buffer data = self->GetAlpha();
3647 int len = self->GetWidth() * self->GetHeight();
3648 PyObject* rv;
3649 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3650 return rv;
3651 }
3652 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3653 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3654 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3655 return;
3656 }
3657 self->SetAlpha(alpha, true);
3658 }
3659 SWIGINTERN PyObject *wxImage_GetHandlers(){
3660 wxList& list = wxImage::GetHandlers();
3661 return wxPy_ConvertList(&list);
3662 }
3663 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3664 wxBitmap bitmap(*self, depth);
3665 return bitmap;
3666 }
3667 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3668 wxImage mono = self->ConvertToMono( red, green, blue );
3669 wxBitmap bitmap( mono, 1 );
3670 return bitmap;
3671 }
3672
3673 wxImage* _ImageFromBuffer(int width, int height,
3674 buffer data, int DATASIZE,
3675 buffer alpha=NULL, int ALPHASIZE=0)
3676 {
3677 if (DATASIZE != width*height*3) {
3678 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3679 return NULL;
3680 }
3681 if (alpha != NULL) {
3682 if (ALPHASIZE != width*height) {
3683 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3684 return NULL;
3685 }
3686 return new wxImage(width, height, data, alpha, true);
3687 }
3688 return new wxImage(width, height, data, true);
3689 }
3690
3691 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3692 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3693 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3694 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3695 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3696 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3697 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3698 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3699 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3700 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3701 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3702 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3703 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3704 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3705 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3706
3707 #include <wx/quantize.h>
3708
3709 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3710 return wxQuantize::Quantize(src, dest,
3711 //NULL, // palette
3712 desiredNoColours,
3713 NULL, // eightBitData
3714 flags);
3715 }
3716 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3717 if (PyCallable_Check(func)) {
3718 self->Connect(id, lastId, eventType,
3719 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3720 new wxPyCallback(func));
3721 }
3722 else if (func == Py_None) {
3723 self->Disconnect(id, lastId, eventType,
3724 (wxObjectEventFunction)
3725 &wxPyCallback::EventThunker);
3726 }
3727 else {
3728 wxPyBLOCK_THREADS(
3729 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3730 }
3731 }
3732 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3733 return self->Disconnect(id, lastId, eventType,
3734 (wxObjectEventFunction)
3735 &wxPyCallback::EventThunker);
3736 }
3737 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3738 if (_self && _self != Py_None) {
3739 self->SetClientObject(new wxPyOORClientData(_self, incref));
3740 }
3741 else {
3742 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3743 if (data) {
3744 self->SetClientObject(NULL); // This will delete it too
3745 }
3746 }
3747 }
3748
3749 #if ! wxUSE_HOTKEY
3750 #define wxEVT_HOTKEY -9999
3751 #endif
3752
3753 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3754 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3755 if (data) {
3756 Py_INCREF(data->m_obj);
3757 return data->m_obj;
3758 } else {
3759 Py_INCREF(Py_None);
3760 return Py_None;
3761 }
3762 }
3763 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3764 wxPyClientData* data = new wxPyClientData(clientData);
3765 self->SetClientObject(data);
3766 }
3767 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3768 #if wxUSE_UNICODE
3769 return self->GetUnicodeKey();
3770 #else
3771 return 0;
3772 #endif
3773 }
3774 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3775 #if wxUSE_UNICODE
3776 self->m_uniChar = uniChar;
3777 #endif
3778 }
3779
3780 SWIGINTERNINLINE PyObject *
3781 SWIG_From_unsigned_SS_int (unsigned int value)
3782 {
3783 return SWIG_From_unsigned_SS_long (value);
3784 }
3785
3786
3787 SWIGINTERN int
3788 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3789 {
3790 unsigned long v;
3791 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3792 if (SWIG_IsOK(res)) {
3793 if ((v > UINT_MAX)) {
3794 return SWIG_OverflowError;
3795 } else {
3796 if (val) *val = static_cast< unsigned int >(v);
3797 }
3798 }
3799 return res;
3800 }
3801
3802 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3803 self->m_size = size;
3804 }
3805 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3806 int count = self->GetNumberOfFiles();
3807 wxString* files = self->GetFiles();
3808 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3809 PyObject* list = PyList_New(count);
3810
3811 if (!list) {
3812 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3813 wxPyEndBlockThreads(blocked);
3814 return NULL;
3815 }
3816
3817 for (int i=0; i<count; i++) {
3818 PyList_SetItem(list, i, wx2PyString(files[i]));
3819 }
3820 wxPyEndBlockThreads(blocked);
3821 return list;
3822 }
3823
3824
3825 SWIGINTERN wxPyApp *new_wxPyApp(){
3826 wxPythonApp = new wxPyApp();
3827 return wxPythonApp;
3828 }
3829 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3830 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3831 return wxPyTestDisplayAvailable();
3832 }
3833
3834 void wxApp_CleanUp() {
3835 __wxPyCleanup();
3836 }
3837
3838
3839 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3840
3841
3842
3843
3844
3845 SWIGINTERNINLINE PyObject *
3846 SWIG_FromCharPtr(const char *cptr)
3847 {
3848 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3849 }
3850
3851
3852 #if 0 // #ifdef __WXMAC__
3853
3854 // A dummy class that raises an exception if used...
3855 class wxEventLoop
3856 {
3857 public:
3858 wxEventLoop() { wxPyRaiseNotImplemented(); }
3859 int Run() { return 0; }
3860 void Exit(int rc = 0) {}
3861 bool Pending() const { return false; }
3862 bool Dispatch() { return false; }
3863 bool IsRunning() const { return false; }
3864 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3865 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3866 };
3867
3868 #else
3869
3870 #include <wx/evtloop.h>
3871
3872 #endif
3873
3874
3875
3876 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3877 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3878 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3879 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3880 wxWindowList& list = self->GetChildren();
3881 return wxPy_ConvertList(&list);
3882 }
3883 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3884 #if wxUSE_HOTKEY
3885 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3886 #else
3887 return false;
3888 #endif
3889 }
3890 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3891
3892
3893
3894 return false;
3895
3896 }
3897 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3898 return wxPyGetWinHandle(self);
3899 }
3900 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3901 self->AssociateHandle((WXWidget)handle);
3902 }
3903 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3904
3905 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3906 return wxWindow::FindWindowById(id, parent);
3907 }
3908
3909 wxWindow* wxFindWindowByName( const wxString& name,
3910 const wxWindow *parent = NULL ) {
3911 return wxWindow::FindWindowByName(name, parent);
3912 }
3913
3914 wxWindow* wxFindWindowByLabel( const wxString& label,
3915 const wxWindow *parent = NULL ) {
3916 return wxWindow::FindWindowByLabel(label, parent);
3917 }
3918
3919
3920 #ifdef __WXMSW__
3921 #include <wx/msw/private.h> // to get wxGetWindowId
3922 #endif
3923
3924
3925 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3926 #ifdef __WXMSW__
3927 WXHWND hWnd = (WXHWND)_hWnd;
3928 long id = wxGetWindowId(hWnd);
3929 wxWindow* win = new wxWindow;
3930 if (parent)
3931 parent->AddChild(win);
3932 win->SetEventHandler(win);
3933 win->SetHWND(hWnd);
3934 win->SetId(id);
3935 win->SubclassWin(hWnd);
3936 win->AdoptAttributesFromHWND();
3937 win->SetupColours();
3938 return win;
3939 #else
3940 wxPyRaiseNotImplemented();
3941 return NULL;
3942 #endif
3943 }
3944
3945
3946 PyObject* GetTopLevelWindows() {
3947 return wxPy_ConvertList(&wxTopLevelWindows);
3948 }
3949
3950
3951 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3952 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3953 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3954
3955 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3956
3957
3958 SWIGINTERNINLINE int
3959 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3960 {
3961 unsigned long v;
3962 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3963 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3964 return res;
3965 }
3966
3967 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3968 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3969 wxMenuItemList& list = self->GetMenuItems();
3970 return wxPy_ConvertList(&list);
3971 }
3972 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3973 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3974 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3975 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3976 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3977 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3978 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3979 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3980 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3981 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3982 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3983 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3984 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3985 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3986 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3987 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3988 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3989 static const wxString wxPyControlNameStr(wxControlNameStr);
3990 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3991 if (clientData) {
3992 wxPyClientData* data = new wxPyClientData(clientData);
3993 return self->Append(item, data);
3994 } else
3995 return self->Append(item);
3996 }
3997 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3998 if (clientData) {
3999 wxPyClientData* data = new wxPyClientData(clientData);
4000 return self->Insert(item, pos, data);
4001 } else
4002 return self->Insert(item, pos);
4003 }
4004 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
4005 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
4006 if (data) {
4007 Py_INCREF(data->m_obj);
4008 return data->m_obj;
4009 } else {
4010 Py_INCREF(Py_None);
4011 return Py_None;
4012 }
4013 }
4014 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
4015 wxPyClientData* data = new wxPyClientData(clientData);
4016 self->SetClientObject(n, data);
4017 }
4018
4019
4020 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4021 wxPyUserData* data = NULL;
4022 if ( userData ) {
4023 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4024 data = new wxPyUserData(userData);
4025 wxPyEndBlockThreads(blocked);
4026 }
4027 return new wxSizerItem(window, proportion, flag, border, data);
4028 }
4029 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4030 wxPyUserData* data = NULL;
4031 if ( userData ) {
4032 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4033 data = new wxPyUserData(userData);
4034 wxPyEndBlockThreads(blocked);
4035 }
4036 return new wxSizerItem(width, height, proportion, flag, border, data);
4037 }
4038 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4039 wxPyUserData* data = NULL;
4040 if ( userData ) {
4041 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4042 data = new wxPyUserData(userData);
4043 wxPyEndBlockThreads(blocked);
4044 }
4045 return new wxSizerItem(sizer, proportion, flag, border, data);
4046 }
4047
4048 SWIGINTERNINLINE PyObject *
4049 SWIG_From_float (float value)
4050 {
4051 return SWIG_From_double (value);
4052 }
4053
4054 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4055 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4056 if (data) {
4057 Py_INCREF(data->m_obj);
4058 return data->m_obj;
4059 } else {
4060 Py_INCREF(Py_None);
4061 return Py_None;
4062 }
4063 }
4064 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4065 wxPyUserData* data = NULL;
4066 if ( userData ) {
4067 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4068 data = new wxPyUserData(userData);
4069 wxPyEndBlockThreads(blocked);
4070 }
4071 self->SetUserData(data);
4072 }
4073
4074 // Figure out the type of the sizer item
4075
4076 struct wxPySizerItemInfo {
4077 wxPySizerItemInfo()
4078 : window(NULL), sizer(NULL), gotSize(false),
4079 size(wxDefaultSize), gotPos(false), pos(-1)
4080 {}
4081
4082 wxWindow* window;
4083 wxSizer* sizer;
4084 bool gotSize;
4085 wxSize size;
4086 bool gotPos;
4087 int pos;
4088 };
4089
4090 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4091
4092 wxPySizerItemInfo info;
4093 wxSize size;
4094 wxSize* sizePtr = &size;
4095
4096 // Find out what the type of the item is
4097 // try wxWindow
4098 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4099 PyErr_Clear();
4100 info.window = NULL;
4101
4102 // try wxSizer
4103 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4104 PyErr_Clear();
4105 info.sizer = NULL;
4106
4107 // try wxSize or (w,h)
4108 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4109 info.size = *sizePtr;
4110 info.gotSize = true;
4111 }
4112
4113 // or a single int
4114 if (checkIdx && PyInt_Check(item)) {
4115 info.pos = PyInt_AsLong(item);
4116 info.gotPos = true;
4117 }
4118 }
4119 }
4120
4121 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4122 // no expected type, figure out what kind of error message to generate
4123 if ( !checkSize && !checkIdx )
4124 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4125 else if ( checkSize && !checkIdx )
4126 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4127 else if ( !checkSize && checkIdx)
4128 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4129 else
4130 // can this one happen?
4131 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4132 }
4133
4134 return info;
4135 }
4136
4137 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4138 if (!self->GetClientObject())
4139 self->SetClientObject(new wxPyOORClientData(_self));
4140 }
4141 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4142
4143 wxPyUserData* data = NULL;
4144 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4145 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4146 if ( userData && (info.window || info.sizer || info.gotSize) )
4147 data = new wxPyUserData(userData);
4148 if ( info.sizer )
4149 PyObject_SetAttrString(item,"thisown",Py_False);
4150 wxPyEndBlockThreads(blocked);
4151
4152 // Now call the real Add method if a valid item type was found
4153 if ( info.window )
4154 return self->Add(info.window, proportion, flag, border, data);
4155 else if ( info.sizer )
4156 return self->Add(info.sizer, proportion, flag, border, data);
4157 else if (info.gotSize)
4158 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4159 proportion, flag, border, data);
4160 else
4161 return NULL;
4162 }
4163 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4164
4165 wxPyUserData* data = NULL;
4166 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4167 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4168 if ( userData && (info.window || info.sizer || info.gotSize) )
4169 data = new wxPyUserData(userData);
4170 if ( info.sizer )
4171 PyObject_SetAttrString(item,"thisown",Py_False);
4172 wxPyEndBlockThreads(blocked);
4173
4174 // Now call the real Insert method if a valid item type was found
4175 if ( info.window )
4176 return self->Insert(before, info.window, proportion, flag, border, data);
4177 else if ( info.sizer )
4178 return self->Insert(before, info.sizer, proportion, flag, border, data);
4179 else if (info.gotSize)
4180 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4181 proportion, flag, border, data);
4182 else
4183 return NULL;
4184 }
4185 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4186
4187 wxPyUserData* data = NULL;
4188 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4189 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4190 if ( userData && (info.window || info.sizer || info.gotSize) )
4191 data = new wxPyUserData(userData);
4192 if ( info.sizer )
4193 PyObject_SetAttrString(item,"thisown",Py_False);
4194 wxPyEndBlockThreads(blocked);
4195
4196 // Now call the real Prepend method if a valid item type was found
4197 if ( info.window )
4198 return self->Prepend(info.window, proportion, flag, border, data);
4199 else if ( info.sizer )
4200 return self->Prepend(info.sizer, proportion, flag, border, data);
4201 else if (info.gotSize)
4202 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4203 proportion, flag, border, data);
4204 else
4205 return NULL;
4206 }
4207 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4208 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4209 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4210 wxPyEndBlockThreads(blocked);
4211 if ( info.window )
4212 return self->Remove(info.window);
4213 else if ( info.sizer )
4214 return self->Remove(info.sizer);
4215 else if ( info.gotPos )
4216 return self->Remove(info.pos);
4217 else
4218 return false;
4219 }
4220 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4221 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4222 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4223 wxPyEndBlockThreads(blocked);
4224 if ( info.window )
4225 return self->Detach(info.window);
4226 else if ( info.sizer )
4227 return self->Detach(info.sizer);
4228 else if ( info.gotPos )
4229 return self->Detach(info.pos);
4230 else
4231 return false;
4232 }
4233 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4234 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4235 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4236 wxPyEndBlockThreads(blocked);
4237 if ( info.window )
4238 return self->GetItem(info.window);
4239 else if ( info.sizer )
4240 return self->GetItem(info.sizer);
4241 else if ( info.gotPos )
4242 return self->GetItem(info.pos);
4243 else
4244 return NULL;
4245 }
4246 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4247 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4248 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4249 wxPyEndBlockThreads(blocked);
4250 if ( info.window )
4251 self->SetItemMinSize(info.window, size);
4252 else if ( info.sizer )
4253 self->SetItemMinSize(info.sizer, size);
4254 else if ( info.gotPos )
4255 self->SetItemMinSize(info.pos, size);
4256 }
4257 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4258 wxSizerItemList& list = self->GetChildren();
4259 return wxPy_ConvertList(&list);
4260 }
4261 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4262 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4263 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4264 wxPyEndBlockThreads(blocked);
4265 if ( info.window )
4266 return self->Show(info.window, show, recursive);
4267 else if ( info.sizer )
4268 return self->Show(info.sizer, show, recursive);
4269 else if ( info.gotPos )
4270 return self->Show(info.pos, show);
4271 else
4272 return false;
4273 }
4274 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4275 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4276 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4277 wxPyEndBlockThreads(blocked);
4278 if ( info.window )
4279 return self->IsShown(info.window);
4280 else if ( info.sizer )
4281 return self->IsShown(info.sizer);
4282 else if ( info.gotPos )
4283 return self->IsShown(info.pos);
4284 else
4285 return false;
4286 }
4287
4288 // See pyclasses.h
4289 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4290 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4291 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4292
4293
4294
4295
4296 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4297 {
4298 if (source == Py_None) {
4299 **obj = wxGBPosition(-1,-1);
4300 return true;
4301 }
4302 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4303 }
4304
4305 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4306 {
4307 if (source == Py_None) {
4308 **obj = wxGBSpan(-1,-1);
4309 return true;
4310 }
4311 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4312 }
4313
4314
4315 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4316 wxGBPosition temp, *obj = &temp;
4317 if ( other == Py_None ) return false;
4318 if ( ! wxGBPosition_helper(other, &obj) ) {
4319 PyErr_Clear();
4320 return false;
4321 }
4322 return self->operator==(*obj);
4323 }
4324 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4325 wxGBPosition temp, *obj = &temp;
4326 if ( other == Py_None ) return true;
4327 if ( ! wxGBPosition_helper(other, &obj)) {
4328 PyErr_Clear();
4329 return true;
4330 }
4331 return self->operator!=(*obj);
4332 }
4333 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4334 self->SetRow(row);
4335 self->SetCol(col);
4336 }
4337 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4338 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4339 PyObject* tup = PyTuple_New(2);
4340 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4341 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4342 wxPyEndBlockThreads(blocked);
4343 return tup;
4344 }
4345 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4346 wxGBSpan temp, *obj = &temp;
4347 if ( other == Py_None ) return false;
4348 if ( ! wxGBSpan_helper(other, &obj) ) {
4349 PyErr_Clear();
4350 return false;
4351 }
4352 return self->operator==(*obj);
4353 }
4354 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4355 wxGBSpan temp, *obj = &temp;
4356 if ( other == Py_None ) return true;
4357 if ( ! wxGBSpan_helper(other, &obj)) {
4358 PyErr_Clear();
4359 return true;
4360 }
4361 return self->operator!=(*obj);
4362 }
4363 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4364 self->SetRowspan(rowspan);
4365 self->SetColspan(colspan);
4366 }
4367 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4368 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4369 PyObject* tup = PyTuple_New(2);
4370 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4371 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4372 wxPyEndBlockThreads(blocked);
4373 return tup;
4374 }
4375 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4376 wxPyUserData* data = NULL;
4377 if ( userData ) {
4378 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4379 data = new wxPyUserData(userData);
4380 wxPyEndBlockThreads(blocked);
4381 }
4382 return new wxGBSizerItem(window, pos, span, flag, border, data);
4383 }
4384 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4385 wxPyUserData* data = NULL;
4386 if ( userData ) {
4387 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4388 data = new wxPyUserData(userData);
4389 wxPyEndBlockThreads(blocked);
4390 }
4391 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4392 }
4393 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4394 wxPyUserData* data = NULL;
4395 if ( userData ) {
4396 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4397 data = new wxPyUserData(userData);
4398 wxPyEndBlockThreads(blocked);
4399 }
4400 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4401 }
4402 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4403 int row, col;
4404 self->GetEndPos(row, col);
4405 return wxGBPosition(row, col);
4406 }
4407 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4408
4409 wxPyUserData* data = NULL;
4410 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4411 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4412 if ( userData && (info.window || info.sizer || info.gotSize) )
4413 data = new wxPyUserData(userData);
4414 if ( info.sizer )
4415 PyObject_SetAttrString(item,"thisown",Py_False);
4416 wxPyEndBlockThreads(blocked);
4417
4418 // Now call the real Add method if a valid item type was found
4419 if ( info.window )
4420 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4421 else if ( info.sizer )
4422 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4423 else if (info.gotSize)
4424 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4425 pos, span, flag, border, data);
4426 return NULL;
4427 }
4428
4429
4430 #ifdef __cplusplus
4431 extern "C" {
4432 #endif
4433 SWIGINTERN int EmptyString_set(PyObject *) {
4434 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4435 return 1;
4436 }
4437
4438
4439 SWIGINTERN PyObject *EmptyString_get(void) {
4440 PyObject *pyobj = 0;
4441
4442 {
4443 #if wxUSE_UNICODE
4444 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4445 #else
4446 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4447 #endif
4448 }
4449 return pyobj;
4450 }
4451
4452
4453 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4454 PyObject *resultobj = 0;
4455 wxObject *arg1 = (wxObject *) 0 ;
4456 wxString result;
4457 void *argp1 = 0 ;
4458 int res1 = 0 ;
4459 PyObject *swig_obj[1] ;
4460
4461 if (!args) SWIG_fail;
4462 swig_obj[0] = args;
4463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4464 if (!SWIG_IsOK(res1)) {
4465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4466 }
4467 arg1 = reinterpret_cast< wxObject * >(argp1);
4468 {
4469 PyThreadState* __tstate = wxPyBeginAllowThreads();
4470 result = wxObject_GetClassName(arg1);
4471 wxPyEndAllowThreads(__tstate);
4472 if (PyErr_Occurred()) SWIG_fail;
4473 }
4474 {
4475 #if wxUSE_UNICODE
4476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4477 #else
4478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4479 #endif
4480 }
4481 return resultobj;
4482 fail:
4483 return NULL;
4484 }
4485
4486
4487 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4488 PyObject *resultobj = 0;
4489 wxObject *arg1 = (wxObject *) 0 ;
4490 void *argp1 = 0 ;
4491 int res1 = 0 ;
4492 PyObject *swig_obj[1] ;
4493
4494 if (!args) SWIG_fail;
4495 swig_obj[0] = args;
4496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4497 if (!SWIG_IsOK(res1)) {
4498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4499 }
4500 arg1 = reinterpret_cast< wxObject * >(argp1);
4501 {
4502 PyThreadState* __tstate = wxPyBeginAllowThreads();
4503 wxObject_Destroy(arg1);
4504 wxPyEndAllowThreads(__tstate);
4505 if (PyErr_Occurred()) SWIG_fail;
4506 }
4507 resultobj = SWIG_Py_Void();
4508 return resultobj;
4509 fail:
4510 return NULL;
4511 }
4512
4513
4514 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4515 PyObject *obj;
4516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4517 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4518 return SWIG_Py_Void();
4519 }
4520
4521 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4522 PyObject *resultobj = 0;
4523 wxSize *arg1 = (wxSize *) 0 ;
4524 int arg2 ;
4525 void *argp1 = 0 ;
4526 int res1 = 0 ;
4527 int val2 ;
4528 int ecode2 = 0 ;
4529 PyObject *swig_obj[2] ;
4530
4531 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4533 if (!SWIG_IsOK(res1)) {
4534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4535 }
4536 arg1 = reinterpret_cast< wxSize * >(argp1);
4537 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4538 if (!SWIG_IsOK(ecode2)) {
4539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4540 }
4541 arg2 = static_cast< int >(val2);
4542 if (arg1) (arg1)->x = arg2;
4543
4544 resultobj = SWIG_Py_Void();
4545 return resultobj;
4546 fail:
4547 return NULL;
4548 }
4549
4550
4551 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4552 PyObject *resultobj = 0;
4553 wxSize *arg1 = (wxSize *) 0 ;
4554 int result;
4555 void *argp1 = 0 ;
4556 int res1 = 0 ;
4557 PyObject *swig_obj[1] ;
4558
4559 if (!args) SWIG_fail;
4560 swig_obj[0] = args;
4561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4562 if (!SWIG_IsOK(res1)) {
4563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4564 }
4565 arg1 = reinterpret_cast< wxSize * >(argp1);
4566 result = (int) ((arg1)->x);
4567 resultobj = SWIG_From_int(static_cast< int >(result));
4568 return resultobj;
4569 fail:
4570 return NULL;
4571 }
4572
4573
4574 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4575 PyObject *resultobj = 0;
4576 wxSize *arg1 = (wxSize *) 0 ;
4577 int arg2 ;
4578 void *argp1 = 0 ;
4579 int res1 = 0 ;
4580 int val2 ;
4581 int ecode2 = 0 ;
4582 PyObject *swig_obj[2] ;
4583
4584 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4586 if (!SWIG_IsOK(res1)) {
4587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4588 }
4589 arg1 = reinterpret_cast< wxSize * >(argp1);
4590 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4591 if (!SWIG_IsOK(ecode2)) {
4592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4593 }
4594 arg2 = static_cast< int >(val2);
4595 if (arg1) (arg1)->y = arg2;
4596
4597 resultobj = SWIG_Py_Void();
4598 return resultobj;
4599 fail:
4600 return NULL;
4601 }
4602
4603
4604 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4605 PyObject *resultobj = 0;
4606 wxSize *arg1 = (wxSize *) 0 ;
4607 int result;
4608 void *argp1 = 0 ;
4609 int res1 = 0 ;
4610 PyObject *swig_obj[1] ;
4611
4612 if (!args) SWIG_fail;
4613 swig_obj[0] = args;
4614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4615 if (!SWIG_IsOK(res1)) {
4616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4617 }
4618 arg1 = reinterpret_cast< wxSize * >(argp1);
4619 result = (int) ((arg1)->y);
4620 resultobj = SWIG_From_int(static_cast< int >(result));
4621 return resultobj;
4622 fail:
4623 return NULL;
4624 }
4625
4626
4627 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4628 PyObject *resultobj = 0;
4629 int arg1 = (int) 0 ;
4630 int arg2 = (int) 0 ;
4631 wxSize *result = 0 ;
4632 int val1 ;
4633 int ecode1 = 0 ;
4634 int val2 ;
4635 int ecode2 = 0 ;
4636 PyObject * obj0 = 0 ;
4637 PyObject * obj1 = 0 ;
4638 char * kwnames[] = {
4639 (char *) "w",(char *) "h", NULL
4640 };
4641
4642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4643 if (obj0) {
4644 ecode1 = SWIG_AsVal_int(obj0, &val1);
4645 if (!SWIG_IsOK(ecode1)) {
4646 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4647 }
4648 arg1 = static_cast< int >(val1);
4649 }
4650 if (obj1) {
4651 ecode2 = SWIG_AsVal_int(obj1, &val2);
4652 if (!SWIG_IsOK(ecode2)) {
4653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4654 }
4655 arg2 = static_cast< int >(val2);
4656 }
4657 {
4658 result = (wxSize *)new wxSize(arg1,arg2);
4659 if (PyErr_Occurred()) SWIG_fail;
4660 }
4661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4662 return resultobj;
4663 fail:
4664 return NULL;
4665 }
4666
4667
4668 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4669 PyObject *resultobj = 0;
4670 wxSize *arg1 = (wxSize *) 0 ;
4671 void *argp1 = 0 ;
4672 int res1 = 0 ;
4673 PyObject *swig_obj[1] ;
4674
4675 if (!args) SWIG_fail;
4676 swig_obj[0] = args;
4677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4678 if (!SWIG_IsOK(res1)) {
4679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4680 }
4681 arg1 = reinterpret_cast< wxSize * >(argp1);
4682 {
4683 delete arg1;
4684
4685 if (PyErr_Occurred()) SWIG_fail;
4686 }
4687 resultobj = SWIG_Py_Void();
4688 return resultobj;
4689 fail:
4690 return NULL;
4691 }
4692
4693
4694 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4695 PyObject *resultobj = 0;
4696 wxSize *arg1 = (wxSize *) 0 ;
4697 PyObject *arg2 = (PyObject *) 0 ;
4698 bool result;
4699 void *argp1 = 0 ;
4700 int res1 = 0 ;
4701 PyObject * obj0 = 0 ;
4702 PyObject * obj1 = 0 ;
4703 char * kwnames[] = {
4704 (char *) "self",(char *) "other", NULL
4705 };
4706
4707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4709 if (!SWIG_IsOK(res1)) {
4710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4711 }
4712 arg1 = reinterpret_cast< wxSize * >(argp1);
4713 arg2 = obj1;
4714 {
4715 result = (bool)wxSize___eq__(arg1,arg2);
4716 if (PyErr_Occurred()) SWIG_fail;
4717 }
4718 {
4719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4720 }
4721 return resultobj;
4722 fail:
4723 return NULL;
4724 }
4725
4726
4727 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4728 PyObject *resultobj = 0;
4729 wxSize *arg1 = (wxSize *) 0 ;
4730 PyObject *arg2 = (PyObject *) 0 ;
4731 bool result;
4732 void *argp1 = 0 ;
4733 int res1 = 0 ;
4734 PyObject * obj0 = 0 ;
4735 PyObject * obj1 = 0 ;
4736 char * kwnames[] = {
4737 (char *) "self",(char *) "other", NULL
4738 };
4739
4740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4742 if (!SWIG_IsOK(res1)) {
4743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4744 }
4745 arg1 = reinterpret_cast< wxSize * >(argp1);
4746 arg2 = obj1;
4747 {
4748 result = (bool)wxSize___ne__(arg1,arg2);
4749 if (PyErr_Occurred()) SWIG_fail;
4750 }
4751 {
4752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4753 }
4754 return resultobj;
4755 fail:
4756 return NULL;
4757 }
4758
4759
4760 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4761 PyObject *resultobj = 0;
4762 wxSize *arg1 = (wxSize *) 0 ;
4763 wxSize *arg2 = 0 ;
4764 wxSize result;
4765 void *argp1 = 0 ;
4766 int res1 = 0 ;
4767 wxSize temp2 ;
4768 PyObject * obj0 = 0 ;
4769 PyObject * obj1 = 0 ;
4770 char * kwnames[] = {
4771 (char *) "self",(char *) "sz", NULL
4772 };
4773
4774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4776 if (!SWIG_IsOK(res1)) {
4777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4778 }
4779 arg1 = reinterpret_cast< wxSize * >(argp1);
4780 {
4781 arg2 = &temp2;
4782 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4783 }
4784 {
4785 result = (arg1)->operator +((wxSize const &)*arg2);
4786 if (PyErr_Occurred()) SWIG_fail;
4787 }
4788 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4789 return resultobj;
4790 fail:
4791 return NULL;
4792 }
4793
4794
4795 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4796 PyObject *resultobj = 0;
4797 wxSize *arg1 = (wxSize *) 0 ;
4798 wxSize *arg2 = 0 ;
4799 wxSize result;
4800 void *argp1 = 0 ;
4801 int res1 = 0 ;
4802 wxSize temp2 ;
4803 PyObject * obj0 = 0 ;
4804 PyObject * obj1 = 0 ;
4805 char * kwnames[] = {
4806 (char *) "self",(char *) "sz", NULL
4807 };
4808
4809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4811 if (!SWIG_IsOK(res1)) {
4812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4813 }
4814 arg1 = reinterpret_cast< wxSize * >(argp1);
4815 {
4816 arg2 = &temp2;
4817 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4818 }
4819 {
4820 result = (arg1)->operator -((wxSize const &)*arg2);
4821 if (PyErr_Occurred()) SWIG_fail;
4822 }
4823 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4824 return resultobj;
4825 fail:
4826 return NULL;
4827 }
4828
4829
4830 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4831 PyObject *resultobj = 0;
4832 wxSize *arg1 = (wxSize *) 0 ;
4833 wxSize *arg2 = 0 ;
4834 void *argp1 = 0 ;
4835 int res1 = 0 ;
4836 wxSize temp2 ;
4837 PyObject * obj0 = 0 ;
4838 PyObject * obj1 = 0 ;
4839 char * kwnames[] = {
4840 (char *) "self",(char *) "sz", NULL
4841 };
4842
4843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4845 if (!SWIG_IsOK(res1)) {
4846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4847 }
4848 arg1 = reinterpret_cast< wxSize * >(argp1);
4849 {
4850 arg2 = &temp2;
4851 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4852 }
4853 {
4854 (arg1)->IncTo((wxSize const &)*arg2);
4855 if (PyErr_Occurred()) SWIG_fail;
4856 }
4857 resultobj = SWIG_Py_Void();
4858 return resultobj;
4859 fail:
4860 return NULL;
4861 }
4862
4863
4864 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4865 PyObject *resultobj = 0;
4866 wxSize *arg1 = (wxSize *) 0 ;
4867 wxSize *arg2 = 0 ;
4868 void *argp1 = 0 ;
4869 int res1 = 0 ;
4870 wxSize temp2 ;
4871 PyObject * obj0 = 0 ;
4872 PyObject * obj1 = 0 ;
4873 char * kwnames[] = {
4874 (char *) "self",(char *) "sz", NULL
4875 };
4876
4877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4879 if (!SWIG_IsOK(res1)) {
4880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4881 }
4882 arg1 = reinterpret_cast< wxSize * >(argp1);
4883 {
4884 arg2 = &temp2;
4885 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4886 }
4887 {
4888 (arg1)->DecTo((wxSize const &)*arg2);
4889 if (PyErr_Occurred()) SWIG_fail;
4890 }
4891 resultobj = SWIG_Py_Void();
4892 return resultobj;
4893 fail:
4894 return NULL;
4895 }
4896
4897
4898 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4899 PyObject *resultobj = 0;
4900 wxSize *arg1 = (wxSize *) 0 ;
4901 int arg2 ;
4902 int arg3 ;
4903 void *argp1 = 0 ;
4904 int res1 = 0 ;
4905 int val2 ;
4906 int ecode2 = 0 ;
4907 int val3 ;
4908 int ecode3 = 0 ;
4909 PyObject * obj0 = 0 ;
4910 PyObject * obj1 = 0 ;
4911 PyObject * obj2 = 0 ;
4912 char * kwnames[] = {
4913 (char *) "self",(char *) "dx",(char *) "dy", NULL
4914 };
4915
4916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4918 if (!SWIG_IsOK(res1)) {
4919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4920 }
4921 arg1 = reinterpret_cast< wxSize * >(argp1);
4922 ecode2 = SWIG_AsVal_int(obj1, &val2);
4923 if (!SWIG_IsOK(ecode2)) {
4924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4925 }
4926 arg2 = static_cast< int >(val2);
4927 ecode3 = SWIG_AsVal_int(obj2, &val3);
4928 if (!SWIG_IsOK(ecode3)) {
4929 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4930 }
4931 arg3 = static_cast< int >(val3);
4932 {
4933 (arg1)->IncBy(arg2,arg3);
4934 if (PyErr_Occurred()) SWIG_fail;
4935 }
4936 resultobj = SWIG_Py_Void();
4937 return resultobj;
4938 fail:
4939 return NULL;
4940 }
4941
4942
4943 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4944 PyObject *resultobj = 0;
4945 wxSize *arg1 = (wxSize *) 0 ;
4946 int arg2 ;
4947 int arg3 ;
4948 void *argp1 = 0 ;
4949 int res1 = 0 ;
4950 int val2 ;
4951 int ecode2 = 0 ;
4952 int val3 ;
4953 int ecode3 = 0 ;
4954 PyObject * obj0 = 0 ;
4955 PyObject * obj1 = 0 ;
4956 PyObject * obj2 = 0 ;
4957 char * kwnames[] = {
4958 (char *) "self",(char *) "dx",(char *) "dy", NULL
4959 };
4960
4961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4963 if (!SWIG_IsOK(res1)) {
4964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
4965 }
4966 arg1 = reinterpret_cast< wxSize * >(argp1);
4967 ecode2 = SWIG_AsVal_int(obj1, &val2);
4968 if (!SWIG_IsOK(ecode2)) {
4969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
4970 }
4971 arg2 = static_cast< int >(val2);
4972 ecode3 = SWIG_AsVal_int(obj2, &val3);
4973 if (!SWIG_IsOK(ecode3)) {
4974 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
4975 }
4976 arg3 = static_cast< int >(val3);
4977 {
4978 (arg1)->DecBy(arg2,arg3);
4979 if (PyErr_Occurred()) SWIG_fail;
4980 }
4981 resultobj = SWIG_Py_Void();
4982 return resultobj;
4983 fail:
4984 return NULL;
4985 }
4986
4987
4988 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4989 PyObject *resultobj = 0;
4990 wxSize *arg1 = (wxSize *) 0 ;
4991 float arg2 ;
4992 float arg3 ;
4993 void *argp1 = 0 ;
4994 int res1 = 0 ;
4995 float val2 ;
4996 int ecode2 = 0 ;
4997 float val3 ;
4998 int ecode3 = 0 ;
4999 PyObject * obj0 = 0 ;
5000 PyObject * obj1 = 0 ;
5001 PyObject * obj2 = 0 ;
5002 char * kwnames[] = {
5003 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5004 };
5005
5006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5008 if (!SWIG_IsOK(res1)) {
5009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5010 }
5011 arg1 = reinterpret_cast< wxSize * >(argp1);
5012 ecode2 = SWIG_AsVal_float(obj1, &val2);
5013 if (!SWIG_IsOK(ecode2)) {
5014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5015 }
5016 arg2 = static_cast< float >(val2);
5017 ecode3 = SWIG_AsVal_float(obj2, &val3);
5018 if (!SWIG_IsOK(ecode3)) {
5019 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5020 }
5021 arg3 = static_cast< float >(val3);
5022 {
5023 (arg1)->Scale(arg2,arg3);
5024 if (PyErr_Occurred()) SWIG_fail;
5025 }
5026 resultobj = SWIG_Py_Void();
5027 return resultobj;
5028 fail:
5029 return NULL;
5030 }
5031
5032
5033 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5034 PyObject *resultobj = 0;
5035 wxSize *arg1 = (wxSize *) 0 ;
5036 int arg2 ;
5037 int arg3 ;
5038 void *argp1 = 0 ;
5039 int res1 = 0 ;
5040 int val2 ;
5041 int ecode2 = 0 ;
5042 int val3 ;
5043 int ecode3 = 0 ;
5044 PyObject * obj0 = 0 ;
5045 PyObject * obj1 = 0 ;
5046 PyObject * obj2 = 0 ;
5047 char * kwnames[] = {
5048 (char *) "self",(char *) "w",(char *) "h", NULL
5049 };
5050
5051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5053 if (!SWIG_IsOK(res1)) {
5054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5055 }
5056 arg1 = reinterpret_cast< wxSize * >(argp1);
5057 ecode2 = SWIG_AsVal_int(obj1, &val2);
5058 if (!SWIG_IsOK(ecode2)) {
5059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5060 }
5061 arg2 = static_cast< int >(val2);
5062 ecode3 = SWIG_AsVal_int(obj2, &val3);
5063 if (!SWIG_IsOK(ecode3)) {
5064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5065 }
5066 arg3 = static_cast< int >(val3);
5067 {
5068 (arg1)->Set(arg2,arg3);
5069 if (PyErr_Occurred()) SWIG_fail;
5070 }
5071 resultobj = SWIG_Py_Void();
5072 return resultobj;
5073 fail:
5074 return NULL;
5075 }
5076
5077
5078 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5079 PyObject *resultobj = 0;
5080 wxSize *arg1 = (wxSize *) 0 ;
5081 int arg2 ;
5082 void *argp1 = 0 ;
5083 int res1 = 0 ;
5084 int val2 ;
5085 int ecode2 = 0 ;
5086 PyObject * obj0 = 0 ;
5087 PyObject * obj1 = 0 ;
5088 char * kwnames[] = {
5089 (char *) "self",(char *) "w", NULL
5090 };
5091
5092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5094 if (!SWIG_IsOK(res1)) {
5095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5096 }
5097 arg1 = reinterpret_cast< wxSize * >(argp1);
5098 ecode2 = SWIG_AsVal_int(obj1, &val2);
5099 if (!SWIG_IsOK(ecode2)) {
5100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5101 }
5102 arg2 = static_cast< int >(val2);
5103 {
5104 (arg1)->SetWidth(arg2);
5105 if (PyErr_Occurred()) SWIG_fail;
5106 }
5107 resultobj = SWIG_Py_Void();
5108 return resultobj;
5109 fail:
5110 return NULL;
5111 }
5112
5113
5114 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5115 PyObject *resultobj = 0;
5116 wxSize *arg1 = (wxSize *) 0 ;
5117 int arg2 ;
5118 void *argp1 = 0 ;
5119 int res1 = 0 ;
5120 int val2 ;
5121 int ecode2 = 0 ;
5122 PyObject * obj0 = 0 ;
5123 PyObject * obj1 = 0 ;
5124 char * kwnames[] = {
5125 (char *) "self",(char *) "h", NULL
5126 };
5127
5128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5130 if (!SWIG_IsOK(res1)) {
5131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5132 }
5133 arg1 = reinterpret_cast< wxSize * >(argp1);
5134 ecode2 = SWIG_AsVal_int(obj1, &val2);
5135 if (!SWIG_IsOK(ecode2)) {
5136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5137 }
5138 arg2 = static_cast< int >(val2);
5139 {
5140 (arg1)->SetHeight(arg2);
5141 if (PyErr_Occurred()) SWIG_fail;
5142 }
5143 resultobj = SWIG_Py_Void();
5144 return resultobj;
5145 fail:
5146 return NULL;
5147 }
5148
5149
5150 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5151 PyObject *resultobj = 0;
5152 wxSize *arg1 = (wxSize *) 0 ;
5153 int result;
5154 void *argp1 = 0 ;
5155 int res1 = 0 ;
5156 PyObject *swig_obj[1] ;
5157
5158 if (!args) SWIG_fail;
5159 swig_obj[0] = args;
5160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5161 if (!SWIG_IsOK(res1)) {
5162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5163 }
5164 arg1 = reinterpret_cast< wxSize * >(argp1);
5165 {
5166 result = (int)((wxSize const *)arg1)->GetWidth();
5167 if (PyErr_Occurred()) SWIG_fail;
5168 }
5169 resultobj = SWIG_From_int(static_cast< int >(result));
5170 return resultobj;
5171 fail:
5172 return NULL;
5173 }
5174
5175
5176 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5177 PyObject *resultobj = 0;
5178 wxSize *arg1 = (wxSize *) 0 ;
5179 int result;
5180 void *argp1 = 0 ;
5181 int res1 = 0 ;
5182 PyObject *swig_obj[1] ;
5183
5184 if (!args) SWIG_fail;
5185 swig_obj[0] = args;
5186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5187 if (!SWIG_IsOK(res1)) {
5188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5189 }
5190 arg1 = reinterpret_cast< wxSize * >(argp1);
5191 {
5192 result = (int)((wxSize const *)arg1)->GetHeight();
5193 if (PyErr_Occurred()) SWIG_fail;
5194 }
5195 resultobj = SWIG_From_int(static_cast< int >(result));
5196 return resultobj;
5197 fail:
5198 return NULL;
5199 }
5200
5201
5202 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5203 PyObject *resultobj = 0;
5204 wxSize *arg1 = (wxSize *) 0 ;
5205 bool result;
5206 void *argp1 = 0 ;
5207 int res1 = 0 ;
5208 PyObject *swig_obj[1] ;
5209
5210 if (!args) SWIG_fail;
5211 swig_obj[0] = args;
5212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5213 if (!SWIG_IsOK(res1)) {
5214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5215 }
5216 arg1 = reinterpret_cast< wxSize * >(argp1);
5217 {
5218 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5219 if (PyErr_Occurred()) SWIG_fail;
5220 }
5221 {
5222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5223 }
5224 return resultobj;
5225 fail:
5226 return NULL;
5227 }
5228
5229
5230 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5231 PyObject *resultobj = 0;
5232 wxSize *arg1 = (wxSize *) 0 ;
5233 wxSize *arg2 = 0 ;
5234 void *argp1 = 0 ;
5235 int res1 = 0 ;
5236 wxSize temp2 ;
5237 PyObject * obj0 = 0 ;
5238 PyObject * obj1 = 0 ;
5239 char * kwnames[] = {
5240 (char *) "self",(char *) "size", NULL
5241 };
5242
5243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5245 if (!SWIG_IsOK(res1)) {
5246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5247 }
5248 arg1 = reinterpret_cast< wxSize * >(argp1);
5249 {
5250 arg2 = &temp2;
5251 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5252 }
5253 {
5254 (arg1)->SetDefaults((wxSize const &)*arg2);
5255 if (PyErr_Occurred()) SWIG_fail;
5256 }
5257 resultobj = SWIG_Py_Void();
5258 return resultobj;
5259 fail:
5260 return NULL;
5261 }
5262
5263
5264 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5265 PyObject *resultobj = 0;
5266 wxSize *arg1 = (wxSize *) 0 ;
5267 PyObject *result = 0 ;
5268 void *argp1 = 0 ;
5269 int res1 = 0 ;
5270 PyObject *swig_obj[1] ;
5271
5272 if (!args) SWIG_fail;
5273 swig_obj[0] = args;
5274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5275 if (!SWIG_IsOK(res1)) {
5276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5277 }
5278 arg1 = reinterpret_cast< wxSize * >(argp1);
5279 {
5280 result = (PyObject *)wxSize_Get(arg1);
5281 if (PyErr_Occurred()) SWIG_fail;
5282 }
5283 resultobj = result;
5284 return resultobj;
5285 fail:
5286 return NULL;
5287 }
5288
5289
5290 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5291 PyObject *obj;
5292 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5293 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5294 return SWIG_Py_Void();
5295 }
5296
5297 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5298 return SWIG_Python_InitShadowInstance(args);
5299 }
5300
5301 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5302 PyObject *resultobj = 0;
5303 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5304 double arg2 ;
5305 void *argp1 = 0 ;
5306 int res1 = 0 ;
5307 double val2 ;
5308 int ecode2 = 0 ;
5309 PyObject *swig_obj[2] ;
5310
5311 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5313 if (!SWIG_IsOK(res1)) {
5314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5315 }
5316 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5317 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5318 if (!SWIG_IsOK(ecode2)) {
5319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5320 }
5321 arg2 = static_cast< double >(val2);
5322 if (arg1) (arg1)->x = arg2;
5323
5324 resultobj = SWIG_Py_Void();
5325 return resultobj;
5326 fail:
5327 return NULL;
5328 }
5329
5330
5331 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5332 PyObject *resultobj = 0;
5333 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5334 double result;
5335 void *argp1 = 0 ;
5336 int res1 = 0 ;
5337 PyObject *swig_obj[1] ;
5338
5339 if (!args) SWIG_fail;
5340 swig_obj[0] = args;
5341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5342 if (!SWIG_IsOK(res1)) {
5343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5344 }
5345 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5346 result = (double) ((arg1)->x);
5347 resultobj = SWIG_From_double(static_cast< double >(result));
5348 return resultobj;
5349 fail:
5350 return NULL;
5351 }
5352
5353
5354 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5355 PyObject *resultobj = 0;
5356 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5357 double arg2 ;
5358 void *argp1 = 0 ;
5359 int res1 = 0 ;
5360 double val2 ;
5361 int ecode2 = 0 ;
5362 PyObject *swig_obj[2] ;
5363
5364 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5366 if (!SWIG_IsOK(res1)) {
5367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5368 }
5369 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5370 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5371 if (!SWIG_IsOK(ecode2)) {
5372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5373 }
5374 arg2 = static_cast< double >(val2);
5375 if (arg1) (arg1)->y = arg2;
5376
5377 resultobj = SWIG_Py_Void();
5378 return resultobj;
5379 fail:
5380 return NULL;
5381 }
5382
5383
5384 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5385 PyObject *resultobj = 0;
5386 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5387 double result;
5388 void *argp1 = 0 ;
5389 int res1 = 0 ;
5390 PyObject *swig_obj[1] ;
5391
5392 if (!args) SWIG_fail;
5393 swig_obj[0] = args;
5394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5395 if (!SWIG_IsOK(res1)) {
5396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5397 }
5398 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5399 result = (double) ((arg1)->y);
5400 resultobj = SWIG_From_double(static_cast< double >(result));
5401 return resultobj;
5402 fail:
5403 return NULL;
5404 }
5405
5406
5407 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5408 PyObject *resultobj = 0;
5409 double arg1 = (double) 0.0 ;
5410 double arg2 = (double) 0.0 ;
5411 wxRealPoint *result = 0 ;
5412 double val1 ;
5413 int ecode1 = 0 ;
5414 double val2 ;
5415 int ecode2 = 0 ;
5416 PyObject * obj0 = 0 ;
5417 PyObject * obj1 = 0 ;
5418 char * kwnames[] = {
5419 (char *) "x",(char *) "y", NULL
5420 };
5421
5422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5423 if (obj0) {
5424 ecode1 = SWIG_AsVal_double(obj0, &val1);
5425 if (!SWIG_IsOK(ecode1)) {
5426 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5427 }
5428 arg1 = static_cast< double >(val1);
5429 }
5430 if (obj1) {
5431 ecode2 = SWIG_AsVal_double(obj1, &val2);
5432 if (!SWIG_IsOK(ecode2)) {
5433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5434 }
5435 arg2 = static_cast< double >(val2);
5436 }
5437 {
5438 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5439 if (PyErr_Occurred()) SWIG_fail;
5440 }
5441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5442 return resultobj;
5443 fail:
5444 return NULL;
5445 }
5446
5447
5448 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5449 PyObject *resultobj = 0;
5450 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5451 void *argp1 = 0 ;
5452 int res1 = 0 ;
5453 PyObject *swig_obj[1] ;
5454
5455 if (!args) SWIG_fail;
5456 swig_obj[0] = args;
5457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5458 if (!SWIG_IsOK(res1)) {
5459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5460 }
5461 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5462 {
5463 delete arg1;
5464
5465 if (PyErr_Occurred()) SWIG_fail;
5466 }
5467 resultobj = SWIG_Py_Void();
5468 return resultobj;
5469 fail:
5470 return NULL;
5471 }
5472
5473
5474 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5475 PyObject *resultobj = 0;
5476 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5477 PyObject *arg2 = (PyObject *) 0 ;
5478 bool result;
5479 void *argp1 = 0 ;
5480 int res1 = 0 ;
5481 PyObject * obj0 = 0 ;
5482 PyObject * obj1 = 0 ;
5483 char * kwnames[] = {
5484 (char *) "self",(char *) "other", NULL
5485 };
5486
5487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5489 if (!SWIG_IsOK(res1)) {
5490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5491 }
5492 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5493 arg2 = obj1;
5494 {
5495 result = (bool)wxRealPoint___eq__(arg1,arg2);
5496 if (PyErr_Occurred()) SWIG_fail;
5497 }
5498 {
5499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5500 }
5501 return resultobj;
5502 fail:
5503 return NULL;
5504 }
5505
5506
5507 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5508 PyObject *resultobj = 0;
5509 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5510 PyObject *arg2 = (PyObject *) 0 ;
5511 bool result;
5512 void *argp1 = 0 ;
5513 int res1 = 0 ;
5514 PyObject * obj0 = 0 ;
5515 PyObject * obj1 = 0 ;
5516 char * kwnames[] = {
5517 (char *) "self",(char *) "other", NULL
5518 };
5519
5520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5522 if (!SWIG_IsOK(res1)) {
5523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5524 }
5525 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5526 arg2 = obj1;
5527 {
5528 result = (bool)wxRealPoint___ne__(arg1,arg2);
5529 if (PyErr_Occurred()) SWIG_fail;
5530 }
5531 {
5532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5533 }
5534 return resultobj;
5535 fail:
5536 return NULL;
5537 }
5538
5539
5540 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5541 PyObject *resultobj = 0;
5542 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5543 wxRealPoint *arg2 = 0 ;
5544 wxRealPoint result;
5545 void *argp1 = 0 ;
5546 int res1 = 0 ;
5547 wxRealPoint temp2 ;
5548 PyObject * obj0 = 0 ;
5549 PyObject * obj1 = 0 ;
5550 char * kwnames[] = {
5551 (char *) "self",(char *) "pt", NULL
5552 };
5553
5554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5556 if (!SWIG_IsOK(res1)) {
5557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5558 }
5559 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5560 {
5561 arg2 = &temp2;
5562 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5563 }
5564 {
5565 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5566 if (PyErr_Occurred()) SWIG_fail;
5567 }
5568 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5569 return resultobj;
5570 fail:
5571 return NULL;
5572 }
5573
5574
5575 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5576 PyObject *resultobj = 0;
5577 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5578 wxRealPoint *arg2 = 0 ;
5579 wxRealPoint result;
5580 void *argp1 = 0 ;
5581 int res1 = 0 ;
5582 wxRealPoint temp2 ;
5583 PyObject * obj0 = 0 ;
5584 PyObject * obj1 = 0 ;
5585 char * kwnames[] = {
5586 (char *) "self",(char *) "pt", NULL
5587 };
5588
5589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5591 if (!SWIG_IsOK(res1)) {
5592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5593 }
5594 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5595 {
5596 arg2 = &temp2;
5597 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5598 }
5599 {
5600 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5601 if (PyErr_Occurred()) SWIG_fail;
5602 }
5603 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5604 return resultobj;
5605 fail:
5606 return NULL;
5607 }
5608
5609
5610 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5611 PyObject *resultobj = 0;
5612 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5613 double arg2 ;
5614 double arg3 ;
5615 void *argp1 = 0 ;
5616 int res1 = 0 ;
5617 double val2 ;
5618 int ecode2 = 0 ;
5619 double val3 ;
5620 int ecode3 = 0 ;
5621 PyObject * obj0 = 0 ;
5622 PyObject * obj1 = 0 ;
5623 PyObject * obj2 = 0 ;
5624 char * kwnames[] = {
5625 (char *) "self",(char *) "x",(char *) "y", NULL
5626 };
5627
5628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5630 if (!SWIG_IsOK(res1)) {
5631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5632 }
5633 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5634 ecode2 = SWIG_AsVal_double(obj1, &val2);
5635 if (!SWIG_IsOK(ecode2)) {
5636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5637 }
5638 arg2 = static_cast< double >(val2);
5639 ecode3 = SWIG_AsVal_double(obj2, &val3);
5640 if (!SWIG_IsOK(ecode3)) {
5641 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5642 }
5643 arg3 = static_cast< double >(val3);
5644 {
5645 wxRealPoint_Set(arg1,arg2,arg3);
5646 if (PyErr_Occurred()) SWIG_fail;
5647 }
5648 resultobj = SWIG_Py_Void();
5649 return resultobj;
5650 fail:
5651 return NULL;
5652 }
5653
5654
5655 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5656 PyObject *resultobj = 0;
5657 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5658 PyObject *result = 0 ;
5659 void *argp1 = 0 ;
5660 int res1 = 0 ;
5661 PyObject *swig_obj[1] ;
5662
5663 if (!args) SWIG_fail;
5664 swig_obj[0] = args;
5665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5666 if (!SWIG_IsOK(res1)) {
5667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5668 }
5669 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5670 {
5671 result = (PyObject *)wxRealPoint_Get(arg1);
5672 if (PyErr_Occurred()) SWIG_fail;
5673 }
5674 resultobj = result;
5675 return resultobj;
5676 fail:
5677 return NULL;
5678 }
5679
5680
5681 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5682 PyObject *obj;
5683 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5684 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5685 return SWIG_Py_Void();
5686 }
5687
5688 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5689 return SWIG_Python_InitShadowInstance(args);
5690 }
5691
5692 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5693 PyObject *resultobj = 0;
5694 wxPoint *arg1 = (wxPoint *) 0 ;
5695 int arg2 ;
5696 void *argp1 = 0 ;
5697 int res1 = 0 ;
5698 int val2 ;
5699 int ecode2 = 0 ;
5700 PyObject *swig_obj[2] ;
5701
5702 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5704 if (!SWIG_IsOK(res1)) {
5705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5706 }
5707 arg1 = reinterpret_cast< wxPoint * >(argp1);
5708 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5709 if (!SWIG_IsOK(ecode2)) {
5710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5711 }
5712 arg2 = static_cast< int >(val2);
5713 if (arg1) (arg1)->x = arg2;
5714
5715 resultobj = SWIG_Py_Void();
5716 return resultobj;
5717 fail:
5718 return NULL;
5719 }
5720
5721
5722 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5723 PyObject *resultobj = 0;
5724 wxPoint *arg1 = (wxPoint *) 0 ;
5725 int result;
5726 void *argp1 = 0 ;
5727 int res1 = 0 ;
5728 PyObject *swig_obj[1] ;
5729
5730 if (!args) SWIG_fail;
5731 swig_obj[0] = args;
5732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5733 if (!SWIG_IsOK(res1)) {
5734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5735 }
5736 arg1 = reinterpret_cast< wxPoint * >(argp1);
5737 result = (int) ((arg1)->x);
5738 resultobj = SWIG_From_int(static_cast< int >(result));
5739 return resultobj;
5740 fail:
5741 return NULL;
5742 }
5743
5744
5745 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5746 PyObject *resultobj = 0;
5747 wxPoint *arg1 = (wxPoint *) 0 ;
5748 int arg2 ;
5749 void *argp1 = 0 ;
5750 int res1 = 0 ;
5751 int val2 ;
5752 int ecode2 = 0 ;
5753 PyObject *swig_obj[2] ;
5754
5755 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5757 if (!SWIG_IsOK(res1)) {
5758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5759 }
5760 arg1 = reinterpret_cast< wxPoint * >(argp1);
5761 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5762 if (!SWIG_IsOK(ecode2)) {
5763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5764 }
5765 arg2 = static_cast< int >(val2);
5766 if (arg1) (arg1)->y = arg2;
5767
5768 resultobj = SWIG_Py_Void();
5769 return resultobj;
5770 fail:
5771 return NULL;
5772 }
5773
5774
5775 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5776 PyObject *resultobj = 0;
5777 wxPoint *arg1 = (wxPoint *) 0 ;
5778 int result;
5779 void *argp1 = 0 ;
5780 int res1 = 0 ;
5781 PyObject *swig_obj[1] ;
5782
5783 if (!args) SWIG_fail;
5784 swig_obj[0] = args;
5785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5786 if (!SWIG_IsOK(res1)) {
5787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5788 }
5789 arg1 = reinterpret_cast< wxPoint * >(argp1);
5790 result = (int) ((arg1)->y);
5791 resultobj = SWIG_From_int(static_cast< int >(result));
5792 return resultobj;
5793 fail:
5794 return NULL;
5795 }
5796
5797
5798 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5799 PyObject *resultobj = 0;
5800 int arg1 = (int) 0 ;
5801 int arg2 = (int) 0 ;
5802 wxPoint *result = 0 ;
5803 int val1 ;
5804 int ecode1 = 0 ;
5805 int val2 ;
5806 int ecode2 = 0 ;
5807 PyObject * obj0 = 0 ;
5808 PyObject * obj1 = 0 ;
5809 char * kwnames[] = {
5810 (char *) "x",(char *) "y", NULL
5811 };
5812
5813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5814 if (obj0) {
5815 ecode1 = SWIG_AsVal_int(obj0, &val1);
5816 if (!SWIG_IsOK(ecode1)) {
5817 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5818 }
5819 arg1 = static_cast< int >(val1);
5820 }
5821 if (obj1) {
5822 ecode2 = SWIG_AsVal_int(obj1, &val2);
5823 if (!SWIG_IsOK(ecode2)) {
5824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5825 }
5826 arg2 = static_cast< int >(val2);
5827 }
5828 {
5829 result = (wxPoint *)new wxPoint(arg1,arg2);
5830 if (PyErr_Occurred()) SWIG_fail;
5831 }
5832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5833 return resultobj;
5834 fail:
5835 return NULL;
5836 }
5837
5838
5839 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5840 PyObject *resultobj = 0;
5841 wxPoint *arg1 = (wxPoint *) 0 ;
5842 void *argp1 = 0 ;
5843 int res1 = 0 ;
5844 PyObject *swig_obj[1] ;
5845
5846 if (!args) SWIG_fail;
5847 swig_obj[0] = args;
5848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5849 if (!SWIG_IsOK(res1)) {
5850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5851 }
5852 arg1 = reinterpret_cast< wxPoint * >(argp1);
5853 {
5854 delete arg1;
5855
5856 if (PyErr_Occurred()) SWIG_fail;
5857 }
5858 resultobj = SWIG_Py_Void();
5859 return resultobj;
5860 fail:
5861 return NULL;
5862 }
5863
5864
5865 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5866 PyObject *resultobj = 0;
5867 wxPoint *arg1 = (wxPoint *) 0 ;
5868 PyObject *arg2 = (PyObject *) 0 ;
5869 bool result;
5870 void *argp1 = 0 ;
5871 int res1 = 0 ;
5872 PyObject * obj0 = 0 ;
5873 PyObject * obj1 = 0 ;
5874 char * kwnames[] = {
5875 (char *) "self",(char *) "other", NULL
5876 };
5877
5878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5880 if (!SWIG_IsOK(res1)) {
5881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5882 }
5883 arg1 = reinterpret_cast< wxPoint * >(argp1);
5884 arg2 = obj1;
5885 {
5886 result = (bool)wxPoint___eq__(arg1,arg2);
5887 if (PyErr_Occurred()) SWIG_fail;
5888 }
5889 {
5890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5891 }
5892 return resultobj;
5893 fail:
5894 return NULL;
5895 }
5896
5897
5898 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5899 PyObject *resultobj = 0;
5900 wxPoint *arg1 = (wxPoint *) 0 ;
5901 PyObject *arg2 = (PyObject *) 0 ;
5902 bool result;
5903 void *argp1 = 0 ;
5904 int res1 = 0 ;
5905 PyObject * obj0 = 0 ;
5906 PyObject * obj1 = 0 ;
5907 char * kwnames[] = {
5908 (char *) "self",(char *) "other", NULL
5909 };
5910
5911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5913 if (!SWIG_IsOK(res1)) {
5914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5915 }
5916 arg1 = reinterpret_cast< wxPoint * >(argp1);
5917 arg2 = obj1;
5918 {
5919 result = (bool)wxPoint___ne__(arg1,arg2);
5920 if (PyErr_Occurred()) SWIG_fail;
5921 }
5922 {
5923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5924 }
5925 return resultobj;
5926 fail:
5927 return NULL;
5928 }
5929
5930
5931 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5932 PyObject *resultobj = 0;
5933 wxPoint *arg1 = (wxPoint *) 0 ;
5934 wxPoint *arg2 = 0 ;
5935 wxPoint result;
5936 void *argp1 = 0 ;
5937 int res1 = 0 ;
5938 wxPoint temp2 ;
5939 PyObject * obj0 = 0 ;
5940 PyObject * obj1 = 0 ;
5941 char * kwnames[] = {
5942 (char *) "self",(char *) "pt", NULL
5943 };
5944
5945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5947 if (!SWIG_IsOK(res1)) {
5948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5949 }
5950 arg1 = reinterpret_cast< wxPoint * >(argp1);
5951 {
5952 arg2 = &temp2;
5953 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5954 }
5955 {
5956 result = (arg1)->operator +((wxPoint const &)*arg2);
5957 if (PyErr_Occurred()) SWIG_fail;
5958 }
5959 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5960 return resultobj;
5961 fail:
5962 return NULL;
5963 }
5964
5965
5966 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5967 PyObject *resultobj = 0;
5968 wxPoint *arg1 = (wxPoint *) 0 ;
5969 wxPoint *arg2 = 0 ;
5970 wxPoint result;
5971 void *argp1 = 0 ;
5972 int res1 = 0 ;
5973 wxPoint temp2 ;
5974 PyObject * obj0 = 0 ;
5975 PyObject * obj1 = 0 ;
5976 char * kwnames[] = {
5977 (char *) "self",(char *) "pt", NULL
5978 };
5979
5980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5982 if (!SWIG_IsOK(res1)) {
5983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5984 }
5985 arg1 = reinterpret_cast< wxPoint * >(argp1);
5986 {
5987 arg2 = &temp2;
5988 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5989 }
5990 {
5991 result = (arg1)->operator -((wxPoint const &)*arg2);
5992 if (PyErr_Occurred()) SWIG_fail;
5993 }
5994 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5995 return resultobj;
5996 fail:
5997 return NULL;
5998 }
5999
6000
6001 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6002 PyObject *resultobj = 0;
6003 wxPoint *arg1 = (wxPoint *) 0 ;
6004 wxPoint *arg2 = 0 ;
6005 wxPoint *result = 0 ;
6006 void *argp1 = 0 ;
6007 int res1 = 0 ;
6008 wxPoint temp2 ;
6009 PyObject * obj0 = 0 ;
6010 PyObject * obj1 = 0 ;
6011 char * kwnames[] = {
6012 (char *) "self",(char *) "pt", NULL
6013 };
6014
6015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6017 if (!SWIG_IsOK(res1)) {
6018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6019 }
6020 arg1 = reinterpret_cast< wxPoint * >(argp1);
6021 {
6022 arg2 = &temp2;
6023 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6024 }
6025 {
6026 {
6027 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6028 result = (wxPoint *) &_result_ref;
6029 }
6030 if (PyErr_Occurred()) SWIG_fail;
6031 }
6032 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6033 return resultobj;
6034 fail:
6035 return NULL;
6036 }
6037
6038
6039 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6040 PyObject *resultobj = 0;
6041 wxPoint *arg1 = (wxPoint *) 0 ;
6042 wxPoint *arg2 = 0 ;
6043 wxPoint *result = 0 ;
6044 void *argp1 = 0 ;
6045 int res1 = 0 ;
6046 wxPoint temp2 ;
6047 PyObject * obj0 = 0 ;
6048 PyObject * obj1 = 0 ;
6049 char * kwnames[] = {
6050 (char *) "self",(char *) "pt", NULL
6051 };
6052
6053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6055 if (!SWIG_IsOK(res1)) {
6056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6057 }
6058 arg1 = reinterpret_cast< wxPoint * >(argp1);
6059 {
6060 arg2 = &temp2;
6061 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6062 }
6063 {
6064 {
6065 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6066 result = (wxPoint *) &_result_ref;
6067 }
6068 if (PyErr_Occurred()) SWIG_fail;
6069 }
6070 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6071 return resultobj;
6072 fail:
6073 return NULL;
6074 }
6075
6076
6077 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6078 PyObject *resultobj = 0;
6079 wxPoint *arg1 = (wxPoint *) 0 ;
6080 long arg2 ;
6081 long arg3 ;
6082 void *argp1 = 0 ;
6083 int res1 = 0 ;
6084 long val2 ;
6085 int ecode2 = 0 ;
6086 long val3 ;
6087 int ecode3 = 0 ;
6088 PyObject * obj0 = 0 ;
6089 PyObject * obj1 = 0 ;
6090 PyObject * obj2 = 0 ;
6091 char * kwnames[] = {
6092 (char *) "self",(char *) "x",(char *) "y", NULL
6093 };
6094
6095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6097 if (!SWIG_IsOK(res1)) {
6098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6099 }
6100 arg1 = reinterpret_cast< wxPoint * >(argp1);
6101 ecode2 = SWIG_AsVal_long(obj1, &val2);
6102 if (!SWIG_IsOK(ecode2)) {
6103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6104 }
6105 arg2 = static_cast< long >(val2);
6106 ecode3 = SWIG_AsVal_long(obj2, &val3);
6107 if (!SWIG_IsOK(ecode3)) {
6108 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6109 }
6110 arg3 = static_cast< long >(val3);
6111 {
6112 wxPoint_Set(arg1,arg2,arg3);
6113 if (PyErr_Occurred()) SWIG_fail;
6114 }
6115 resultobj = SWIG_Py_Void();
6116 return resultobj;
6117 fail:
6118 return NULL;
6119 }
6120
6121
6122 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6123 PyObject *resultobj = 0;
6124 wxPoint *arg1 = (wxPoint *) 0 ;
6125 PyObject *result = 0 ;
6126 void *argp1 = 0 ;
6127 int res1 = 0 ;
6128 PyObject *swig_obj[1] ;
6129
6130 if (!args) SWIG_fail;
6131 swig_obj[0] = args;
6132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6133 if (!SWIG_IsOK(res1)) {
6134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6135 }
6136 arg1 = reinterpret_cast< wxPoint * >(argp1);
6137 {
6138 result = (PyObject *)wxPoint_Get(arg1);
6139 if (PyErr_Occurred()) SWIG_fail;
6140 }
6141 resultobj = result;
6142 return resultobj;
6143 fail:
6144 return NULL;
6145 }
6146
6147
6148 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6149 PyObject *obj;
6150 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6151 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6152 return SWIG_Py_Void();
6153 }
6154
6155 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6156 return SWIG_Python_InitShadowInstance(args);
6157 }
6158
6159 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6160 PyObject *resultobj = 0;
6161 int arg1 = (int) 0 ;
6162 int arg2 = (int) 0 ;
6163 int arg3 = (int) 0 ;
6164 int arg4 = (int) 0 ;
6165 wxRect *result = 0 ;
6166 int val1 ;
6167 int ecode1 = 0 ;
6168 int val2 ;
6169 int ecode2 = 0 ;
6170 int val3 ;
6171 int ecode3 = 0 ;
6172 int val4 ;
6173 int ecode4 = 0 ;
6174 PyObject * obj0 = 0 ;
6175 PyObject * obj1 = 0 ;
6176 PyObject * obj2 = 0 ;
6177 PyObject * obj3 = 0 ;
6178 char * kwnames[] = {
6179 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6180 };
6181
6182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6183 if (obj0) {
6184 ecode1 = SWIG_AsVal_int(obj0, &val1);
6185 if (!SWIG_IsOK(ecode1)) {
6186 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6187 }
6188 arg1 = static_cast< int >(val1);
6189 }
6190 if (obj1) {
6191 ecode2 = SWIG_AsVal_int(obj1, &val2);
6192 if (!SWIG_IsOK(ecode2)) {
6193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6194 }
6195 arg2 = static_cast< int >(val2);
6196 }
6197 if (obj2) {
6198 ecode3 = SWIG_AsVal_int(obj2, &val3);
6199 if (!SWIG_IsOK(ecode3)) {
6200 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6201 }
6202 arg3 = static_cast< int >(val3);
6203 }
6204 if (obj3) {
6205 ecode4 = SWIG_AsVal_int(obj3, &val4);
6206 if (!SWIG_IsOK(ecode4)) {
6207 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6208 }
6209 arg4 = static_cast< int >(val4);
6210 }
6211 {
6212 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6213 if (PyErr_Occurred()) SWIG_fail;
6214 }
6215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6216 return resultobj;
6217 fail:
6218 return NULL;
6219 }
6220
6221
6222 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6223 PyObject *resultobj = 0;
6224 wxPoint *arg1 = 0 ;
6225 wxPoint *arg2 = 0 ;
6226 wxRect *result = 0 ;
6227 wxPoint temp1 ;
6228 wxPoint temp2 ;
6229 PyObject * obj0 = 0 ;
6230 PyObject * obj1 = 0 ;
6231 char * kwnames[] = {
6232 (char *) "topLeft",(char *) "bottomRight", NULL
6233 };
6234
6235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6236 {
6237 arg1 = &temp1;
6238 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6239 }
6240 {
6241 arg2 = &temp2;
6242 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6243 }
6244 {
6245 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6246 if (PyErr_Occurred()) SWIG_fail;
6247 }
6248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6249 return resultobj;
6250 fail:
6251 return NULL;
6252 }
6253
6254
6255 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6256 PyObject *resultobj = 0;
6257 wxPoint *arg1 = 0 ;
6258 wxSize *arg2 = 0 ;
6259 wxRect *result = 0 ;
6260 wxPoint temp1 ;
6261 wxSize temp2 ;
6262 PyObject * obj0 = 0 ;
6263 PyObject * obj1 = 0 ;
6264 char * kwnames[] = {
6265 (char *) "pos",(char *) "size", NULL
6266 };
6267
6268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6269 {
6270 arg1 = &temp1;
6271 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6272 }
6273 {
6274 arg2 = &temp2;
6275 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6276 }
6277 {
6278 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6279 if (PyErr_Occurred()) SWIG_fail;
6280 }
6281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6282 return resultobj;
6283 fail:
6284 return NULL;
6285 }
6286
6287
6288 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6289 PyObject *resultobj = 0;
6290 wxSize *arg1 = 0 ;
6291 wxRect *result = 0 ;
6292 wxSize temp1 ;
6293 PyObject * obj0 = 0 ;
6294 char * kwnames[] = {
6295 (char *) "size", NULL
6296 };
6297
6298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6299 {
6300 arg1 = &temp1;
6301 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6302 }
6303 {
6304 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6305 if (PyErr_Occurred()) SWIG_fail;
6306 }
6307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6308 return resultobj;
6309 fail:
6310 return NULL;
6311 }
6312
6313
6314 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6315 PyObject *resultobj = 0;
6316 wxRect *arg1 = (wxRect *) 0 ;
6317 void *argp1 = 0 ;
6318 int res1 = 0 ;
6319 PyObject *swig_obj[1] ;
6320
6321 if (!args) SWIG_fail;
6322 swig_obj[0] = args;
6323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6324 if (!SWIG_IsOK(res1)) {
6325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6326 }
6327 arg1 = reinterpret_cast< wxRect * >(argp1);
6328 {
6329 delete arg1;
6330
6331 if (PyErr_Occurred()) SWIG_fail;
6332 }
6333 resultobj = SWIG_Py_Void();
6334 return resultobj;
6335 fail:
6336 return NULL;
6337 }
6338
6339
6340 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6341 PyObject *resultobj = 0;
6342 wxRect *arg1 = (wxRect *) 0 ;
6343 int result;
6344 void *argp1 = 0 ;
6345 int res1 = 0 ;
6346 PyObject *swig_obj[1] ;
6347
6348 if (!args) SWIG_fail;
6349 swig_obj[0] = args;
6350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6351 if (!SWIG_IsOK(res1)) {
6352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6353 }
6354 arg1 = reinterpret_cast< wxRect * >(argp1);
6355 {
6356 result = (int)((wxRect const *)arg1)->GetX();
6357 if (PyErr_Occurred()) SWIG_fail;
6358 }
6359 resultobj = SWIG_From_int(static_cast< int >(result));
6360 return resultobj;
6361 fail:
6362 return NULL;
6363 }
6364
6365
6366 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6367 PyObject *resultobj = 0;
6368 wxRect *arg1 = (wxRect *) 0 ;
6369 int arg2 ;
6370 void *argp1 = 0 ;
6371 int res1 = 0 ;
6372 int val2 ;
6373 int ecode2 = 0 ;
6374 PyObject * obj0 = 0 ;
6375 PyObject * obj1 = 0 ;
6376 char * kwnames[] = {
6377 (char *) "self",(char *) "x", NULL
6378 };
6379
6380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6382 if (!SWIG_IsOK(res1)) {
6383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6384 }
6385 arg1 = reinterpret_cast< wxRect * >(argp1);
6386 ecode2 = SWIG_AsVal_int(obj1, &val2);
6387 if (!SWIG_IsOK(ecode2)) {
6388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6389 }
6390 arg2 = static_cast< int >(val2);
6391 {
6392 (arg1)->SetX(arg2);
6393 if (PyErr_Occurred()) SWIG_fail;
6394 }
6395 resultobj = SWIG_Py_Void();
6396 return resultobj;
6397 fail:
6398 return NULL;
6399 }
6400
6401
6402 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6403 PyObject *resultobj = 0;
6404 wxRect *arg1 = (wxRect *) 0 ;
6405 int result;
6406 void *argp1 = 0 ;
6407 int res1 = 0 ;
6408 PyObject *swig_obj[1] ;
6409
6410 if (!args) SWIG_fail;
6411 swig_obj[0] = args;
6412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6413 if (!SWIG_IsOK(res1)) {
6414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6415 }
6416 arg1 = reinterpret_cast< wxRect * >(argp1);
6417 {
6418 result = (int)(arg1)->GetY();
6419 if (PyErr_Occurred()) SWIG_fail;
6420 }
6421 resultobj = SWIG_From_int(static_cast< int >(result));
6422 return resultobj;
6423 fail:
6424 return NULL;
6425 }
6426
6427
6428 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6429 PyObject *resultobj = 0;
6430 wxRect *arg1 = (wxRect *) 0 ;
6431 int arg2 ;
6432 void *argp1 = 0 ;
6433 int res1 = 0 ;
6434 int val2 ;
6435 int ecode2 = 0 ;
6436 PyObject * obj0 = 0 ;
6437 PyObject * obj1 = 0 ;
6438 char * kwnames[] = {
6439 (char *) "self",(char *) "y", NULL
6440 };
6441
6442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6444 if (!SWIG_IsOK(res1)) {
6445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6446 }
6447 arg1 = reinterpret_cast< wxRect * >(argp1);
6448 ecode2 = SWIG_AsVal_int(obj1, &val2);
6449 if (!SWIG_IsOK(ecode2)) {
6450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6451 }
6452 arg2 = static_cast< int >(val2);
6453 {
6454 (arg1)->SetY(arg2);
6455 if (PyErr_Occurred()) SWIG_fail;
6456 }
6457 resultobj = SWIG_Py_Void();
6458 return resultobj;
6459 fail:
6460 return NULL;
6461 }
6462
6463
6464 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6465 PyObject *resultobj = 0;
6466 wxRect *arg1 = (wxRect *) 0 ;
6467 int result;
6468 void *argp1 = 0 ;
6469 int res1 = 0 ;
6470 PyObject *swig_obj[1] ;
6471
6472 if (!args) SWIG_fail;
6473 swig_obj[0] = args;
6474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6475 if (!SWIG_IsOK(res1)) {
6476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6477 }
6478 arg1 = reinterpret_cast< wxRect * >(argp1);
6479 {
6480 result = (int)((wxRect const *)arg1)->GetWidth();
6481 if (PyErr_Occurred()) SWIG_fail;
6482 }
6483 resultobj = SWIG_From_int(static_cast< int >(result));
6484 return resultobj;
6485 fail:
6486 return NULL;
6487 }
6488
6489
6490 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6491 PyObject *resultobj = 0;
6492 wxRect *arg1 = (wxRect *) 0 ;
6493 int arg2 ;
6494 void *argp1 = 0 ;
6495 int res1 = 0 ;
6496 int val2 ;
6497 int ecode2 = 0 ;
6498 PyObject * obj0 = 0 ;
6499 PyObject * obj1 = 0 ;
6500 char * kwnames[] = {
6501 (char *) "self",(char *) "w", NULL
6502 };
6503
6504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6506 if (!SWIG_IsOK(res1)) {
6507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6508 }
6509 arg1 = reinterpret_cast< wxRect * >(argp1);
6510 ecode2 = SWIG_AsVal_int(obj1, &val2);
6511 if (!SWIG_IsOK(ecode2)) {
6512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6513 }
6514 arg2 = static_cast< int >(val2);
6515 {
6516 (arg1)->SetWidth(arg2);
6517 if (PyErr_Occurred()) SWIG_fail;
6518 }
6519 resultobj = SWIG_Py_Void();
6520 return resultobj;
6521 fail:
6522 return NULL;
6523 }
6524
6525
6526 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6527 PyObject *resultobj = 0;
6528 wxRect *arg1 = (wxRect *) 0 ;
6529 int result;
6530 void *argp1 = 0 ;
6531 int res1 = 0 ;
6532 PyObject *swig_obj[1] ;
6533
6534 if (!args) SWIG_fail;
6535 swig_obj[0] = args;
6536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6537 if (!SWIG_IsOK(res1)) {
6538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6539 }
6540 arg1 = reinterpret_cast< wxRect * >(argp1);
6541 {
6542 result = (int)((wxRect const *)arg1)->GetHeight();
6543 if (PyErr_Occurred()) SWIG_fail;
6544 }
6545 resultobj = SWIG_From_int(static_cast< int >(result));
6546 return resultobj;
6547 fail:
6548 return NULL;
6549 }
6550
6551
6552 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6553 PyObject *resultobj = 0;
6554 wxRect *arg1 = (wxRect *) 0 ;
6555 int arg2 ;
6556 void *argp1 = 0 ;
6557 int res1 = 0 ;
6558 int val2 ;
6559 int ecode2 = 0 ;
6560 PyObject * obj0 = 0 ;
6561 PyObject * obj1 = 0 ;
6562 char * kwnames[] = {
6563 (char *) "self",(char *) "h", NULL
6564 };
6565
6566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6568 if (!SWIG_IsOK(res1)) {
6569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6570 }
6571 arg1 = reinterpret_cast< wxRect * >(argp1);
6572 ecode2 = SWIG_AsVal_int(obj1, &val2);
6573 if (!SWIG_IsOK(ecode2)) {
6574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6575 }
6576 arg2 = static_cast< int >(val2);
6577 {
6578 (arg1)->SetHeight(arg2);
6579 if (PyErr_Occurred()) SWIG_fail;
6580 }
6581 resultobj = SWIG_Py_Void();
6582 return resultobj;
6583 fail:
6584 return NULL;
6585 }
6586
6587
6588 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6589 PyObject *resultobj = 0;
6590 wxRect *arg1 = (wxRect *) 0 ;
6591 wxPoint result;
6592 void *argp1 = 0 ;
6593 int res1 = 0 ;
6594 PyObject *swig_obj[1] ;
6595
6596 if (!args) SWIG_fail;
6597 swig_obj[0] = args;
6598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6599 if (!SWIG_IsOK(res1)) {
6600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6601 }
6602 arg1 = reinterpret_cast< wxRect * >(argp1);
6603 {
6604 result = ((wxRect const *)arg1)->GetPosition();
6605 if (PyErr_Occurred()) SWIG_fail;
6606 }
6607 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6608 return resultobj;
6609 fail:
6610 return NULL;
6611 }
6612
6613
6614 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6615 PyObject *resultobj = 0;
6616 wxRect *arg1 = (wxRect *) 0 ;
6617 wxPoint *arg2 = 0 ;
6618 void *argp1 = 0 ;
6619 int res1 = 0 ;
6620 wxPoint temp2 ;
6621 PyObject * obj0 = 0 ;
6622 PyObject * obj1 = 0 ;
6623 char * kwnames[] = {
6624 (char *) "self",(char *) "p", NULL
6625 };
6626
6627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6629 if (!SWIG_IsOK(res1)) {
6630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6631 }
6632 arg1 = reinterpret_cast< wxRect * >(argp1);
6633 {
6634 arg2 = &temp2;
6635 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6636 }
6637 {
6638 (arg1)->SetPosition((wxPoint const &)*arg2);
6639 if (PyErr_Occurred()) SWIG_fail;
6640 }
6641 resultobj = SWIG_Py_Void();
6642 return resultobj;
6643 fail:
6644 return NULL;
6645 }
6646
6647
6648 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6649 PyObject *resultobj = 0;
6650 wxRect *arg1 = (wxRect *) 0 ;
6651 wxSize result;
6652 void *argp1 = 0 ;
6653 int res1 = 0 ;
6654 PyObject *swig_obj[1] ;
6655
6656 if (!args) SWIG_fail;
6657 swig_obj[0] = args;
6658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6659 if (!SWIG_IsOK(res1)) {
6660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6661 }
6662 arg1 = reinterpret_cast< wxRect * >(argp1);
6663 {
6664 result = ((wxRect const *)arg1)->GetSize();
6665 if (PyErr_Occurred()) SWIG_fail;
6666 }
6667 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6668 return resultobj;
6669 fail:
6670 return NULL;
6671 }
6672
6673
6674 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6675 PyObject *resultobj = 0;
6676 wxRect *arg1 = (wxRect *) 0 ;
6677 wxSize *arg2 = 0 ;
6678 void *argp1 = 0 ;
6679 int res1 = 0 ;
6680 wxSize temp2 ;
6681 PyObject * obj0 = 0 ;
6682 PyObject * obj1 = 0 ;
6683 char * kwnames[] = {
6684 (char *) "self",(char *) "s", NULL
6685 };
6686
6687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6689 if (!SWIG_IsOK(res1)) {
6690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6691 }
6692 arg1 = reinterpret_cast< wxRect * >(argp1);
6693 {
6694 arg2 = &temp2;
6695 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6696 }
6697 {
6698 (arg1)->SetSize((wxSize const &)*arg2);
6699 if (PyErr_Occurred()) SWIG_fail;
6700 }
6701 resultobj = SWIG_Py_Void();
6702 return resultobj;
6703 fail:
6704 return NULL;
6705 }
6706
6707
6708 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6709 PyObject *resultobj = 0;
6710 wxRect *arg1 = (wxRect *) 0 ;
6711 bool result;
6712 void *argp1 = 0 ;
6713 int res1 = 0 ;
6714 PyObject *swig_obj[1] ;
6715
6716 if (!args) SWIG_fail;
6717 swig_obj[0] = args;
6718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6719 if (!SWIG_IsOK(res1)) {
6720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6721 }
6722 arg1 = reinterpret_cast< wxRect * >(argp1);
6723 {
6724 result = (bool)((wxRect const *)arg1)->IsEmpty();
6725 if (PyErr_Occurred()) SWIG_fail;
6726 }
6727 {
6728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6729 }
6730 return resultobj;
6731 fail:
6732 return NULL;
6733 }
6734
6735
6736 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6737 PyObject *resultobj = 0;
6738 wxRect *arg1 = (wxRect *) 0 ;
6739 wxPoint result;
6740 void *argp1 = 0 ;
6741 int res1 = 0 ;
6742 PyObject *swig_obj[1] ;
6743
6744 if (!args) SWIG_fail;
6745 swig_obj[0] = args;
6746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6747 if (!SWIG_IsOK(res1)) {
6748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6749 }
6750 arg1 = reinterpret_cast< wxRect * >(argp1);
6751 {
6752 result = ((wxRect const *)arg1)->GetTopLeft();
6753 if (PyErr_Occurred()) SWIG_fail;
6754 }
6755 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6756 return resultobj;
6757 fail:
6758 return NULL;
6759 }
6760
6761
6762 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6763 PyObject *resultobj = 0;
6764 wxRect *arg1 = (wxRect *) 0 ;
6765 wxPoint *arg2 = 0 ;
6766 void *argp1 = 0 ;
6767 int res1 = 0 ;
6768 wxPoint temp2 ;
6769 PyObject * obj0 = 0 ;
6770 PyObject * obj1 = 0 ;
6771 char * kwnames[] = {
6772 (char *) "self",(char *) "p", NULL
6773 };
6774
6775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6777 if (!SWIG_IsOK(res1)) {
6778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6779 }
6780 arg1 = reinterpret_cast< wxRect * >(argp1);
6781 {
6782 arg2 = &temp2;
6783 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6784 }
6785 {
6786 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6787 if (PyErr_Occurred()) SWIG_fail;
6788 }
6789 resultobj = SWIG_Py_Void();
6790 return resultobj;
6791 fail:
6792 return NULL;
6793 }
6794
6795
6796 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6797 PyObject *resultobj = 0;
6798 wxRect *arg1 = (wxRect *) 0 ;
6799 wxPoint result;
6800 void *argp1 = 0 ;
6801 int res1 = 0 ;
6802 PyObject *swig_obj[1] ;
6803
6804 if (!args) SWIG_fail;
6805 swig_obj[0] = args;
6806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6807 if (!SWIG_IsOK(res1)) {
6808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6809 }
6810 arg1 = reinterpret_cast< wxRect * >(argp1);
6811 {
6812 result = ((wxRect const *)arg1)->GetBottomRight();
6813 if (PyErr_Occurred()) SWIG_fail;
6814 }
6815 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6816 return resultobj;
6817 fail:
6818 return NULL;
6819 }
6820
6821
6822 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6823 PyObject *resultobj = 0;
6824 wxRect *arg1 = (wxRect *) 0 ;
6825 wxPoint *arg2 = 0 ;
6826 void *argp1 = 0 ;
6827 int res1 = 0 ;
6828 wxPoint temp2 ;
6829 PyObject * obj0 = 0 ;
6830 PyObject * obj1 = 0 ;
6831 char * kwnames[] = {
6832 (char *) "self",(char *) "p", NULL
6833 };
6834
6835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6837 if (!SWIG_IsOK(res1)) {
6838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6839 }
6840 arg1 = reinterpret_cast< wxRect * >(argp1);
6841 {
6842 arg2 = &temp2;
6843 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6844 }
6845 {
6846 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6847 if (PyErr_Occurred()) SWIG_fail;
6848 }
6849 resultobj = SWIG_Py_Void();
6850 return resultobj;
6851 fail:
6852 return NULL;
6853 }
6854
6855
6856 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6857 PyObject *resultobj = 0;
6858 wxRect *arg1 = (wxRect *) 0 ;
6859 wxPoint result;
6860 void *argp1 = 0 ;
6861 int res1 = 0 ;
6862 PyObject *swig_obj[1] ;
6863
6864 if (!args) SWIG_fail;
6865 swig_obj[0] = args;
6866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6867 if (!SWIG_IsOK(res1)) {
6868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6869 }
6870 arg1 = reinterpret_cast< wxRect * >(argp1);
6871 {
6872 result = ((wxRect const *)arg1)->GetTopRight();
6873 if (PyErr_Occurred()) SWIG_fail;
6874 }
6875 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6876 return resultobj;
6877 fail:
6878 return NULL;
6879 }
6880
6881
6882 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6883 PyObject *resultobj = 0;
6884 wxRect *arg1 = (wxRect *) 0 ;
6885 wxPoint *arg2 = 0 ;
6886 void *argp1 = 0 ;
6887 int res1 = 0 ;
6888 wxPoint temp2 ;
6889 PyObject * obj0 = 0 ;
6890 PyObject * obj1 = 0 ;
6891 char * kwnames[] = {
6892 (char *) "self",(char *) "p", NULL
6893 };
6894
6895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6897 if (!SWIG_IsOK(res1)) {
6898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6899 }
6900 arg1 = reinterpret_cast< wxRect * >(argp1);
6901 {
6902 arg2 = &temp2;
6903 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6904 }
6905 {
6906 (arg1)->SetTopRight((wxPoint const &)*arg2);
6907 if (PyErr_Occurred()) SWIG_fail;
6908 }
6909 resultobj = SWIG_Py_Void();
6910 return resultobj;
6911 fail:
6912 return NULL;
6913 }
6914
6915
6916 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6917 PyObject *resultobj = 0;
6918 wxRect *arg1 = (wxRect *) 0 ;
6919 wxPoint result;
6920 void *argp1 = 0 ;
6921 int res1 = 0 ;
6922 PyObject *swig_obj[1] ;
6923
6924 if (!args) SWIG_fail;
6925 swig_obj[0] = args;
6926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6927 if (!SWIG_IsOK(res1)) {
6928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6929 }
6930 arg1 = reinterpret_cast< wxRect * >(argp1);
6931 {
6932 result = ((wxRect const *)arg1)->GetBottomLeft();
6933 if (PyErr_Occurred()) SWIG_fail;
6934 }
6935 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6936 return resultobj;
6937 fail:
6938 return NULL;
6939 }
6940
6941
6942 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6943 PyObject *resultobj = 0;
6944 wxRect *arg1 = (wxRect *) 0 ;
6945 wxPoint *arg2 = 0 ;
6946 void *argp1 = 0 ;
6947 int res1 = 0 ;
6948 wxPoint temp2 ;
6949 PyObject * obj0 = 0 ;
6950 PyObject * obj1 = 0 ;
6951 char * kwnames[] = {
6952 (char *) "self",(char *) "p", NULL
6953 };
6954
6955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6957 if (!SWIG_IsOK(res1)) {
6958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6959 }
6960 arg1 = reinterpret_cast< wxRect * >(argp1);
6961 {
6962 arg2 = &temp2;
6963 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6964 }
6965 {
6966 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
6967 if (PyErr_Occurred()) SWIG_fail;
6968 }
6969 resultobj = SWIG_Py_Void();
6970 return resultobj;
6971 fail:
6972 return NULL;
6973 }
6974
6975
6976 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6977 PyObject *resultobj = 0;
6978 wxRect *arg1 = (wxRect *) 0 ;
6979 int result;
6980 void *argp1 = 0 ;
6981 int res1 = 0 ;
6982 PyObject *swig_obj[1] ;
6983
6984 if (!args) SWIG_fail;
6985 swig_obj[0] = args;
6986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6987 if (!SWIG_IsOK(res1)) {
6988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6989 }
6990 arg1 = reinterpret_cast< wxRect * >(argp1);
6991 {
6992 result = (int)((wxRect const *)arg1)->GetLeft();
6993 if (PyErr_Occurred()) SWIG_fail;
6994 }
6995 resultobj = SWIG_From_int(static_cast< int >(result));
6996 return resultobj;
6997 fail:
6998 return NULL;
6999 }
7000
7001
7002 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7003 PyObject *resultobj = 0;
7004 wxRect *arg1 = (wxRect *) 0 ;
7005 int result;
7006 void *argp1 = 0 ;
7007 int res1 = 0 ;
7008 PyObject *swig_obj[1] ;
7009
7010 if (!args) SWIG_fail;
7011 swig_obj[0] = args;
7012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7013 if (!SWIG_IsOK(res1)) {
7014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7015 }
7016 arg1 = reinterpret_cast< wxRect * >(argp1);
7017 {
7018 result = (int)((wxRect const *)arg1)->GetTop();
7019 if (PyErr_Occurred()) SWIG_fail;
7020 }
7021 resultobj = SWIG_From_int(static_cast< int >(result));
7022 return resultobj;
7023 fail:
7024 return NULL;
7025 }
7026
7027
7028 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7029 PyObject *resultobj = 0;
7030 wxRect *arg1 = (wxRect *) 0 ;
7031 int result;
7032 void *argp1 = 0 ;
7033 int res1 = 0 ;
7034 PyObject *swig_obj[1] ;
7035
7036 if (!args) SWIG_fail;
7037 swig_obj[0] = args;
7038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7039 if (!SWIG_IsOK(res1)) {
7040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7041 }
7042 arg1 = reinterpret_cast< wxRect * >(argp1);
7043 {
7044 result = (int)((wxRect const *)arg1)->GetBottom();
7045 if (PyErr_Occurred()) SWIG_fail;
7046 }
7047 resultobj = SWIG_From_int(static_cast< int >(result));
7048 return resultobj;
7049 fail:
7050 return NULL;
7051 }
7052
7053
7054 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7055 PyObject *resultobj = 0;
7056 wxRect *arg1 = (wxRect *) 0 ;
7057 int result;
7058 void *argp1 = 0 ;
7059 int res1 = 0 ;
7060 PyObject *swig_obj[1] ;
7061
7062 if (!args) SWIG_fail;
7063 swig_obj[0] = args;
7064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7065 if (!SWIG_IsOK(res1)) {
7066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7067 }
7068 arg1 = reinterpret_cast< wxRect * >(argp1);
7069 {
7070 result = (int)((wxRect const *)arg1)->GetRight();
7071 if (PyErr_Occurred()) SWIG_fail;
7072 }
7073 resultobj = SWIG_From_int(static_cast< int >(result));
7074 return resultobj;
7075 fail:
7076 return NULL;
7077 }
7078
7079
7080 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7081 PyObject *resultobj = 0;
7082 wxRect *arg1 = (wxRect *) 0 ;
7083 int arg2 ;
7084 void *argp1 = 0 ;
7085 int res1 = 0 ;
7086 int val2 ;
7087 int ecode2 = 0 ;
7088 PyObject * obj0 = 0 ;
7089 PyObject * obj1 = 0 ;
7090 char * kwnames[] = {
7091 (char *) "self",(char *) "left", NULL
7092 };
7093
7094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7096 if (!SWIG_IsOK(res1)) {
7097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7098 }
7099 arg1 = reinterpret_cast< wxRect * >(argp1);
7100 ecode2 = SWIG_AsVal_int(obj1, &val2);
7101 if (!SWIG_IsOK(ecode2)) {
7102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7103 }
7104 arg2 = static_cast< int >(val2);
7105 {
7106 (arg1)->SetLeft(arg2);
7107 if (PyErr_Occurred()) SWIG_fail;
7108 }
7109 resultobj = SWIG_Py_Void();
7110 return resultobj;
7111 fail:
7112 return NULL;
7113 }
7114
7115
7116 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7117 PyObject *resultobj = 0;
7118 wxRect *arg1 = (wxRect *) 0 ;
7119 int arg2 ;
7120 void *argp1 = 0 ;
7121 int res1 = 0 ;
7122 int val2 ;
7123 int ecode2 = 0 ;
7124 PyObject * obj0 = 0 ;
7125 PyObject * obj1 = 0 ;
7126 char * kwnames[] = {
7127 (char *) "self",(char *) "right", NULL
7128 };
7129
7130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7132 if (!SWIG_IsOK(res1)) {
7133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7134 }
7135 arg1 = reinterpret_cast< wxRect * >(argp1);
7136 ecode2 = SWIG_AsVal_int(obj1, &val2);
7137 if (!SWIG_IsOK(ecode2)) {
7138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7139 }
7140 arg2 = static_cast< int >(val2);
7141 {
7142 (arg1)->SetRight(arg2);
7143 if (PyErr_Occurred()) SWIG_fail;
7144 }
7145 resultobj = SWIG_Py_Void();
7146 return resultobj;
7147 fail:
7148 return NULL;
7149 }
7150
7151
7152 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7153 PyObject *resultobj = 0;
7154 wxRect *arg1 = (wxRect *) 0 ;
7155 int arg2 ;
7156 void *argp1 = 0 ;
7157 int res1 = 0 ;
7158 int val2 ;
7159 int ecode2 = 0 ;
7160 PyObject * obj0 = 0 ;
7161 PyObject * obj1 = 0 ;
7162 char * kwnames[] = {
7163 (char *) "self",(char *) "top", NULL
7164 };
7165
7166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7168 if (!SWIG_IsOK(res1)) {
7169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7170 }
7171 arg1 = reinterpret_cast< wxRect * >(argp1);
7172 ecode2 = SWIG_AsVal_int(obj1, &val2);
7173 if (!SWIG_IsOK(ecode2)) {
7174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7175 }
7176 arg2 = static_cast< int >(val2);
7177 {
7178 (arg1)->SetTop(arg2);
7179 if (PyErr_Occurred()) SWIG_fail;
7180 }
7181 resultobj = SWIG_Py_Void();
7182 return resultobj;
7183 fail:
7184 return NULL;
7185 }
7186
7187
7188 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7189 PyObject *resultobj = 0;
7190 wxRect *arg1 = (wxRect *) 0 ;
7191 int arg2 ;
7192 void *argp1 = 0 ;
7193 int res1 = 0 ;
7194 int val2 ;
7195 int ecode2 = 0 ;
7196 PyObject * obj0 = 0 ;
7197 PyObject * obj1 = 0 ;
7198 char * kwnames[] = {
7199 (char *) "self",(char *) "bottom", NULL
7200 };
7201
7202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7204 if (!SWIG_IsOK(res1)) {
7205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7206 }
7207 arg1 = reinterpret_cast< wxRect * >(argp1);
7208 ecode2 = SWIG_AsVal_int(obj1, &val2);
7209 if (!SWIG_IsOK(ecode2)) {
7210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7211 }
7212 arg2 = static_cast< int >(val2);
7213 {
7214 (arg1)->SetBottom(arg2);
7215 if (PyErr_Occurred()) SWIG_fail;
7216 }
7217 resultobj = SWIG_Py_Void();
7218 return resultobj;
7219 fail:
7220 return NULL;
7221 }
7222
7223
7224 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7225 PyObject *resultobj = 0;
7226 wxRect *arg1 = (wxRect *) 0 ;
7227 int arg2 ;
7228 int arg3 ;
7229 wxRect *result = 0 ;
7230 void *argp1 = 0 ;
7231 int res1 = 0 ;
7232 int val2 ;
7233 int ecode2 = 0 ;
7234 int val3 ;
7235 int ecode3 = 0 ;
7236 PyObject * obj0 = 0 ;
7237 PyObject * obj1 = 0 ;
7238 PyObject * obj2 = 0 ;
7239 char * kwnames[] = {
7240 (char *) "self",(char *) "dx",(char *) "dy", NULL
7241 };
7242
7243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7245 if (!SWIG_IsOK(res1)) {
7246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7247 }
7248 arg1 = reinterpret_cast< wxRect * >(argp1);
7249 ecode2 = SWIG_AsVal_int(obj1, &val2);
7250 if (!SWIG_IsOK(ecode2)) {
7251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7252 }
7253 arg2 = static_cast< int >(val2);
7254 ecode3 = SWIG_AsVal_int(obj2, &val3);
7255 if (!SWIG_IsOK(ecode3)) {
7256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7257 }
7258 arg3 = static_cast< int >(val3);
7259 {
7260 {
7261 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7262 result = (wxRect *) &_result_ref;
7263 }
7264 if (PyErr_Occurred()) SWIG_fail;
7265 }
7266 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7267 return resultobj;
7268 fail:
7269 return NULL;
7270 }
7271
7272
7273 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7274 PyObject *resultobj = 0;
7275 wxRect *arg1 = (wxRect *) 0 ;
7276 int arg2 ;
7277 int arg3 ;
7278 wxRect *result = 0 ;
7279 void *argp1 = 0 ;
7280 int res1 = 0 ;
7281 int val2 ;
7282 int ecode2 = 0 ;
7283 int val3 ;
7284 int ecode3 = 0 ;
7285 PyObject * obj0 = 0 ;
7286 PyObject * obj1 = 0 ;
7287 PyObject * obj2 = 0 ;
7288 char * kwnames[] = {
7289 (char *) "self",(char *) "dx",(char *) "dy", NULL
7290 };
7291
7292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7294 if (!SWIG_IsOK(res1)) {
7295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7296 }
7297 arg1 = reinterpret_cast< wxRect * >(argp1);
7298 ecode2 = SWIG_AsVal_int(obj1, &val2);
7299 if (!SWIG_IsOK(ecode2)) {
7300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7301 }
7302 arg2 = static_cast< int >(val2);
7303 ecode3 = SWIG_AsVal_int(obj2, &val3);
7304 if (!SWIG_IsOK(ecode3)) {
7305 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7306 }
7307 arg3 = static_cast< int >(val3);
7308 {
7309 {
7310 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7311 result = (wxRect *) &_result_ref;
7312 }
7313 if (PyErr_Occurred()) SWIG_fail;
7314 }
7315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7316 return resultobj;
7317 fail:
7318 return NULL;
7319 }
7320
7321
7322 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7323 PyObject *resultobj = 0;
7324 wxRect *arg1 = (wxRect *) 0 ;
7325 int arg2 ;
7326 int arg3 ;
7327 void *argp1 = 0 ;
7328 int res1 = 0 ;
7329 int val2 ;
7330 int ecode2 = 0 ;
7331 int val3 ;
7332 int ecode3 = 0 ;
7333 PyObject * obj0 = 0 ;
7334 PyObject * obj1 = 0 ;
7335 PyObject * obj2 = 0 ;
7336 char * kwnames[] = {
7337 (char *) "self",(char *) "dx",(char *) "dy", NULL
7338 };
7339
7340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7342 if (!SWIG_IsOK(res1)) {
7343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7344 }
7345 arg1 = reinterpret_cast< wxRect * >(argp1);
7346 ecode2 = SWIG_AsVal_int(obj1, &val2);
7347 if (!SWIG_IsOK(ecode2)) {
7348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7349 }
7350 arg2 = static_cast< int >(val2);
7351 ecode3 = SWIG_AsVal_int(obj2, &val3);
7352 if (!SWIG_IsOK(ecode3)) {
7353 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7354 }
7355 arg3 = static_cast< int >(val3);
7356 {
7357 (arg1)->Offset(arg2,arg3);
7358 if (PyErr_Occurred()) SWIG_fail;
7359 }
7360 resultobj = SWIG_Py_Void();
7361 return resultobj;
7362 fail:
7363 return NULL;
7364 }
7365
7366
7367 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7368 PyObject *resultobj = 0;
7369 wxRect *arg1 = (wxRect *) 0 ;
7370 wxPoint *arg2 = 0 ;
7371 void *argp1 = 0 ;
7372 int res1 = 0 ;
7373 wxPoint temp2 ;
7374 PyObject * obj0 = 0 ;
7375 PyObject * obj1 = 0 ;
7376 char * kwnames[] = {
7377 (char *) "self",(char *) "pt", NULL
7378 };
7379
7380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7382 if (!SWIG_IsOK(res1)) {
7383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7384 }
7385 arg1 = reinterpret_cast< wxRect * >(argp1);
7386 {
7387 arg2 = &temp2;
7388 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7389 }
7390 {
7391 (arg1)->Offset((wxPoint const &)*arg2);
7392 if (PyErr_Occurred()) SWIG_fail;
7393 }
7394 resultobj = SWIG_Py_Void();
7395 return resultobj;
7396 fail:
7397 return NULL;
7398 }
7399
7400
7401 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7402 PyObject *resultobj = 0;
7403 wxRect *arg1 = (wxRect *) 0 ;
7404 wxRect *arg2 = 0 ;
7405 wxRect result;
7406 void *argp1 = 0 ;
7407 int res1 = 0 ;
7408 wxRect temp2 ;
7409 PyObject * obj0 = 0 ;
7410 PyObject * obj1 = 0 ;
7411 char * kwnames[] = {
7412 (char *) "self",(char *) "rect", NULL
7413 };
7414
7415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7417 if (!SWIG_IsOK(res1)) {
7418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7419 }
7420 arg1 = reinterpret_cast< wxRect * >(argp1);
7421 {
7422 arg2 = &temp2;
7423 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7424 }
7425 {
7426 result = (arg1)->Intersect((wxRect const &)*arg2);
7427 if (PyErr_Occurred()) SWIG_fail;
7428 }
7429 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7430 return resultobj;
7431 fail:
7432 return NULL;
7433 }
7434
7435
7436 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7437 PyObject *resultobj = 0;
7438 wxRect *arg1 = (wxRect *) 0 ;
7439 wxRect *arg2 = 0 ;
7440 wxRect result;
7441 void *argp1 = 0 ;
7442 int res1 = 0 ;
7443 wxRect temp2 ;
7444 PyObject * obj0 = 0 ;
7445 PyObject * obj1 = 0 ;
7446 char * kwnames[] = {
7447 (char *) "self",(char *) "rect", NULL
7448 };
7449
7450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7452 if (!SWIG_IsOK(res1)) {
7453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7454 }
7455 arg1 = reinterpret_cast< wxRect * >(argp1);
7456 {
7457 arg2 = &temp2;
7458 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7459 }
7460 {
7461 result = (arg1)->Union((wxRect const &)*arg2);
7462 if (PyErr_Occurred()) SWIG_fail;
7463 }
7464 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7465 return resultobj;
7466 fail:
7467 return NULL;
7468 }
7469
7470
7471 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7472 PyObject *resultobj = 0;
7473 wxRect *arg1 = (wxRect *) 0 ;
7474 wxRect *arg2 = 0 ;
7475 wxRect result;
7476 void *argp1 = 0 ;
7477 int res1 = 0 ;
7478 wxRect temp2 ;
7479 PyObject * obj0 = 0 ;
7480 PyObject * obj1 = 0 ;
7481 char * kwnames[] = {
7482 (char *) "self",(char *) "rect", NULL
7483 };
7484
7485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7487 if (!SWIG_IsOK(res1)) {
7488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7489 }
7490 arg1 = reinterpret_cast< wxRect * >(argp1);
7491 {
7492 arg2 = &temp2;
7493 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7494 }
7495 {
7496 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7497 if (PyErr_Occurred()) SWIG_fail;
7498 }
7499 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7500 return resultobj;
7501 fail:
7502 return NULL;
7503 }
7504
7505
7506 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7507 PyObject *resultobj = 0;
7508 wxRect *arg1 = (wxRect *) 0 ;
7509 wxRect *arg2 = 0 ;
7510 wxRect *result = 0 ;
7511 void *argp1 = 0 ;
7512 int res1 = 0 ;
7513 wxRect temp2 ;
7514 PyObject * obj0 = 0 ;
7515 PyObject * obj1 = 0 ;
7516 char * kwnames[] = {
7517 (char *) "self",(char *) "rect", NULL
7518 };
7519
7520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7522 if (!SWIG_IsOK(res1)) {
7523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7524 }
7525 arg1 = reinterpret_cast< wxRect * >(argp1);
7526 {
7527 arg2 = &temp2;
7528 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7529 }
7530 {
7531 {
7532 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7533 result = (wxRect *) &_result_ref;
7534 }
7535 if (PyErr_Occurred()) SWIG_fail;
7536 }
7537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7538 return resultobj;
7539 fail:
7540 return NULL;
7541 }
7542
7543
7544 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7545 PyObject *resultobj = 0;
7546 wxRect *arg1 = (wxRect *) 0 ;
7547 PyObject *arg2 = (PyObject *) 0 ;
7548 bool result;
7549 void *argp1 = 0 ;
7550 int res1 = 0 ;
7551 PyObject * obj0 = 0 ;
7552 PyObject * obj1 = 0 ;
7553 char * kwnames[] = {
7554 (char *) "self",(char *) "other", NULL
7555 };
7556
7557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7559 if (!SWIG_IsOK(res1)) {
7560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7561 }
7562 arg1 = reinterpret_cast< wxRect * >(argp1);
7563 arg2 = obj1;
7564 {
7565 result = (bool)wxRect___eq__(arg1,arg2);
7566 if (PyErr_Occurred()) SWIG_fail;
7567 }
7568 {
7569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7570 }
7571 return resultobj;
7572 fail:
7573 return NULL;
7574 }
7575
7576
7577 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7578 PyObject *resultobj = 0;
7579 wxRect *arg1 = (wxRect *) 0 ;
7580 PyObject *arg2 = (PyObject *) 0 ;
7581 bool result;
7582 void *argp1 = 0 ;
7583 int res1 = 0 ;
7584 PyObject * obj0 = 0 ;
7585 PyObject * obj1 = 0 ;
7586 char * kwnames[] = {
7587 (char *) "self",(char *) "other", NULL
7588 };
7589
7590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7592 if (!SWIG_IsOK(res1)) {
7593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7594 }
7595 arg1 = reinterpret_cast< wxRect * >(argp1);
7596 arg2 = obj1;
7597 {
7598 result = (bool)wxRect___ne__(arg1,arg2);
7599 if (PyErr_Occurred()) SWIG_fail;
7600 }
7601 {
7602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7603 }
7604 return resultobj;
7605 fail:
7606 return NULL;
7607 }
7608
7609
7610 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7611 PyObject *resultobj = 0;
7612 wxRect *arg1 = (wxRect *) 0 ;
7613 int arg2 ;
7614 int arg3 ;
7615 bool result;
7616 void *argp1 = 0 ;
7617 int res1 = 0 ;
7618 int val2 ;
7619 int ecode2 = 0 ;
7620 int val3 ;
7621 int ecode3 = 0 ;
7622 PyObject * obj0 = 0 ;
7623 PyObject * obj1 = 0 ;
7624 PyObject * obj2 = 0 ;
7625 char * kwnames[] = {
7626 (char *) "self",(char *) "x",(char *) "y", NULL
7627 };
7628
7629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7631 if (!SWIG_IsOK(res1)) {
7632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7633 }
7634 arg1 = reinterpret_cast< wxRect * >(argp1);
7635 ecode2 = SWIG_AsVal_int(obj1, &val2);
7636 if (!SWIG_IsOK(ecode2)) {
7637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7638 }
7639 arg2 = static_cast< int >(val2);
7640 ecode3 = SWIG_AsVal_int(obj2, &val3);
7641 if (!SWIG_IsOK(ecode3)) {
7642 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7643 }
7644 arg3 = static_cast< int >(val3);
7645 {
7646 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7647 if (PyErr_Occurred()) SWIG_fail;
7648 }
7649 {
7650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7651 }
7652 return resultobj;
7653 fail:
7654 return NULL;
7655 }
7656
7657
7658 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7659 PyObject *resultobj = 0;
7660 wxRect *arg1 = (wxRect *) 0 ;
7661 wxPoint *arg2 = 0 ;
7662 bool result;
7663 void *argp1 = 0 ;
7664 int res1 = 0 ;
7665 wxPoint temp2 ;
7666 PyObject * obj0 = 0 ;
7667 PyObject * obj1 = 0 ;
7668 char * kwnames[] = {
7669 (char *) "self",(char *) "pt", NULL
7670 };
7671
7672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7674 if (!SWIG_IsOK(res1)) {
7675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7676 }
7677 arg1 = reinterpret_cast< wxRect * >(argp1);
7678 {
7679 arg2 = &temp2;
7680 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7681 }
7682 {
7683 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7684 if (PyErr_Occurred()) SWIG_fail;
7685 }
7686 {
7687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7688 }
7689 return resultobj;
7690 fail:
7691 return NULL;
7692 }
7693
7694
7695 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7696 PyObject *resultobj = 0;
7697 wxRect *arg1 = (wxRect *) 0 ;
7698 wxRect *arg2 = 0 ;
7699 bool result;
7700 void *argp1 = 0 ;
7701 int res1 = 0 ;
7702 wxRect temp2 ;
7703 PyObject * obj0 = 0 ;
7704 PyObject * obj1 = 0 ;
7705 char * kwnames[] = {
7706 (char *) "self",(char *) "rect", NULL
7707 };
7708
7709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7711 if (!SWIG_IsOK(res1)) {
7712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7713 }
7714 arg1 = reinterpret_cast< wxRect * >(argp1);
7715 {
7716 arg2 = &temp2;
7717 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7718 }
7719 {
7720 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7721 if (PyErr_Occurred()) SWIG_fail;
7722 }
7723 {
7724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7725 }
7726 return resultobj;
7727 fail:
7728 return NULL;
7729 }
7730
7731
7732 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7733 PyObject *resultobj = 0;
7734 wxRect *arg1 = (wxRect *) 0 ;
7735 wxRect *arg2 = 0 ;
7736 bool result;
7737 void *argp1 = 0 ;
7738 int res1 = 0 ;
7739 wxRect temp2 ;
7740 PyObject * obj0 = 0 ;
7741 PyObject * obj1 = 0 ;
7742 char * kwnames[] = {
7743 (char *) "self",(char *) "rect", NULL
7744 };
7745
7746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7748 if (!SWIG_IsOK(res1)) {
7749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7750 }
7751 arg1 = reinterpret_cast< wxRect * >(argp1);
7752 {
7753 arg2 = &temp2;
7754 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7755 }
7756 {
7757 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7758 if (PyErr_Occurred()) SWIG_fail;
7759 }
7760 {
7761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7762 }
7763 return resultobj;
7764 fail:
7765 return NULL;
7766 }
7767
7768
7769 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7770 PyObject *resultobj = 0;
7771 wxRect *arg1 = (wxRect *) 0 ;
7772 wxRect *arg2 = 0 ;
7773 int arg3 = (int) wxBOTH ;
7774 wxRect result;
7775 void *argp1 = 0 ;
7776 int res1 = 0 ;
7777 wxRect temp2 ;
7778 int val3 ;
7779 int ecode3 = 0 ;
7780 PyObject * obj0 = 0 ;
7781 PyObject * obj1 = 0 ;
7782 PyObject * obj2 = 0 ;
7783 char * kwnames[] = {
7784 (char *) "self",(char *) "r",(char *) "dir", NULL
7785 };
7786
7787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7789 if (!SWIG_IsOK(res1)) {
7790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7791 }
7792 arg1 = reinterpret_cast< wxRect * >(argp1);
7793 {
7794 arg2 = &temp2;
7795 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7796 }
7797 if (obj2) {
7798 ecode3 = SWIG_AsVal_int(obj2, &val3);
7799 if (!SWIG_IsOK(ecode3)) {
7800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7801 }
7802 arg3 = static_cast< int >(val3);
7803 }
7804 {
7805 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7806 if (PyErr_Occurred()) SWIG_fail;
7807 }
7808 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7809 return resultobj;
7810 fail:
7811 return NULL;
7812 }
7813
7814
7815 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7816 PyObject *resultobj = 0;
7817 wxRect *arg1 = (wxRect *) 0 ;
7818 int arg2 ;
7819 void *argp1 = 0 ;
7820 int res1 = 0 ;
7821 int val2 ;
7822 int ecode2 = 0 ;
7823 PyObject *swig_obj[2] ;
7824
7825 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7827 if (!SWIG_IsOK(res1)) {
7828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7829 }
7830 arg1 = reinterpret_cast< wxRect * >(argp1);
7831 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7832 if (!SWIG_IsOK(ecode2)) {
7833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7834 }
7835 arg2 = static_cast< int >(val2);
7836 if (arg1) (arg1)->x = arg2;
7837
7838 resultobj = SWIG_Py_Void();
7839 return resultobj;
7840 fail:
7841 return NULL;
7842 }
7843
7844
7845 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7846 PyObject *resultobj = 0;
7847 wxRect *arg1 = (wxRect *) 0 ;
7848 int result;
7849 void *argp1 = 0 ;
7850 int res1 = 0 ;
7851 PyObject *swig_obj[1] ;
7852
7853 if (!args) SWIG_fail;
7854 swig_obj[0] = args;
7855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7856 if (!SWIG_IsOK(res1)) {
7857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7858 }
7859 arg1 = reinterpret_cast< wxRect * >(argp1);
7860 result = (int) ((arg1)->x);
7861 resultobj = SWIG_From_int(static_cast< int >(result));
7862 return resultobj;
7863 fail:
7864 return NULL;
7865 }
7866
7867
7868 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7869 PyObject *resultobj = 0;
7870 wxRect *arg1 = (wxRect *) 0 ;
7871 int arg2 ;
7872 void *argp1 = 0 ;
7873 int res1 = 0 ;
7874 int val2 ;
7875 int ecode2 = 0 ;
7876 PyObject *swig_obj[2] ;
7877
7878 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7880 if (!SWIG_IsOK(res1)) {
7881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7882 }
7883 arg1 = reinterpret_cast< wxRect * >(argp1);
7884 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7885 if (!SWIG_IsOK(ecode2)) {
7886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7887 }
7888 arg2 = static_cast< int >(val2);
7889 if (arg1) (arg1)->y = arg2;
7890
7891 resultobj = SWIG_Py_Void();
7892 return resultobj;
7893 fail:
7894 return NULL;
7895 }
7896
7897
7898 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7899 PyObject *resultobj = 0;
7900 wxRect *arg1 = (wxRect *) 0 ;
7901 int result;
7902 void *argp1 = 0 ;
7903 int res1 = 0 ;
7904 PyObject *swig_obj[1] ;
7905
7906 if (!args) SWIG_fail;
7907 swig_obj[0] = args;
7908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7909 if (!SWIG_IsOK(res1)) {
7910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7911 }
7912 arg1 = reinterpret_cast< wxRect * >(argp1);
7913 result = (int) ((arg1)->y);
7914 resultobj = SWIG_From_int(static_cast< int >(result));
7915 return resultobj;
7916 fail:
7917 return NULL;
7918 }
7919
7920
7921 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7922 PyObject *resultobj = 0;
7923 wxRect *arg1 = (wxRect *) 0 ;
7924 int arg2 ;
7925 void *argp1 = 0 ;
7926 int res1 = 0 ;
7927 int val2 ;
7928 int ecode2 = 0 ;
7929 PyObject *swig_obj[2] ;
7930
7931 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7933 if (!SWIG_IsOK(res1)) {
7934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7935 }
7936 arg1 = reinterpret_cast< wxRect * >(argp1);
7937 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7938 if (!SWIG_IsOK(ecode2)) {
7939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7940 }
7941 arg2 = static_cast< int >(val2);
7942 if (arg1) (arg1)->width = arg2;
7943
7944 resultobj = SWIG_Py_Void();
7945 return resultobj;
7946 fail:
7947 return NULL;
7948 }
7949
7950
7951 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7952 PyObject *resultobj = 0;
7953 wxRect *arg1 = (wxRect *) 0 ;
7954 int result;
7955 void *argp1 = 0 ;
7956 int res1 = 0 ;
7957 PyObject *swig_obj[1] ;
7958
7959 if (!args) SWIG_fail;
7960 swig_obj[0] = args;
7961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7962 if (!SWIG_IsOK(res1)) {
7963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7964 }
7965 arg1 = reinterpret_cast< wxRect * >(argp1);
7966 result = (int) ((arg1)->width);
7967 resultobj = SWIG_From_int(static_cast< int >(result));
7968 return resultobj;
7969 fail:
7970 return NULL;
7971 }
7972
7973
7974 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7975 PyObject *resultobj = 0;
7976 wxRect *arg1 = (wxRect *) 0 ;
7977 int arg2 ;
7978 void *argp1 = 0 ;
7979 int res1 = 0 ;
7980 int val2 ;
7981 int ecode2 = 0 ;
7982 PyObject *swig_obj[2] ;
7983
7984 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7986 if (!SWIG_IsOK(res1)) {
7987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7988 }
7989 arg1 = reinterpret_cast< wxRect * >(argp1);
7990 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7991 if (!SWIG_IsOK(ecode2)) {
7992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7993 }
7994 arg2 = static_cast< int >(val2);
7995 if (arg1) (arg1)->height = arg2;
7996
7997 resultobj = SWIG_Py_Void();
7998 return resultobj;
7999 fail:
8000 return NULL;
8001 }
8002
8003
8004 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8005 PyObject *resultobj = 0;
8006 wxRect *arg1 = (wxRect *) 0 ;
8007 int result;
8008 void *argp1 = 0 ;
8009 int res1 = 0 ;
8010 PyObject *swig_obj[1] ;
8011
8012 if (!args) SWIG_fail;
8013 swig_obj[0] = args;
8014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8015 if (!SWIG_IsOK(res1)) {
8016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8017 }
8018 arg1 = reinterpret_cast< wxRect * >(argp1);
8019 result = (int) ((arg1)->height);
8020 resultobj = SWIG_From_int(static_cast< int >(result));
8021 return resultobj;
8022 fail:
8023 return NULL;
8024 }
8025
8026
8027 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8028 PyObject *resultobj = 0;
8029 wxRect *arg1 = (wxRect *) 0 ;
8030 int arg2 = (int) 0 ;
8031 int arg3 = (int) 0 ;
8032 int arg4 = (int) 0 ;
8033 int arg5 = (int) 0 ;
8034 void *argp1 = 0 ;
8035 int res1 = 0 ;
8036 int val2 ;
8037 int ecode2 = 0 ;
8038 int val3 ;
8039 int ecode3 = 0 ;
8040 int val4 ;
8041 int ecode4 = 0 ;
8042 int val5 ;
8043 int ecode5 = 0 ;
8044 PyObject * obj0 = 0 ;
8045 PyObject * obj1 = 0 ;
8046 PyObject * obj2 = 0 ;
8047 PyObject * obj3 = 0 ;
8048 PyObject * obj4 = 0 ;
8049 char * kwnames[] = {
8050 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8051 };
8052
8053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8055 if (!SWIG_IsOK(res1)) {
8056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8057 }
8058 arg1 = reinterpret_cast< wxRect * >(argp1);
8059 if (obj1) {
8060 ecode2 = SWIG_AsVal_int(obj1, &val2);
8061 if (!SWIG_IsOK(ecode2)) {
8062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8063 }
8064 arg2 = static_cast< int >(val2);
8065 }
8066 if (obj2) {
8067 ecode3 = SWIG_AsVal_int(obj2, &val3);
8068 if (!SWIG_IsOK(ecode3)) {
8069 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8070 }
8071 arg3 = static_cast< int >(val3);
8072 }
8073 if (obj3) {
8074 ecode4 = SWIG_AsVal_int(obj3, &val4);
8075 if (!SWIG_IsOK(ecode4)) {
8076 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8077 }
8078 arg4 = static_cast< int >(val4);
8079 }
8080 if (obj4) {
8081 ecode5 = SWIG_AsVal_int(obj4, &val5);
8082 if (!SWIG_IsOK(ecode5)) {
8083 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8084 }
8085 arg5 = static_cast< int >(val5);
8086 }
8087 {
8088 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8089 if (PyErr_Occurred()) SWIG_fail;
8090 }
8091 resultobj = SWIG_Py_Void();
8092 return resultobj;
8093 fail:
8094 return NULL;
8095 }
8096
8097
8098 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8099 PyObject *resultobj = 0;
8100 wxRect *arg1 = (wxRect *) 0 ;
8101 PyObject *result = 0 ;
8102 void *argp1 = 0 ;
8103 int res1 = 0 ;
8104 PyObject *swig_obj[1] ;
8105
8106 if (!args) SWIG_fail;
8107 swig_obj[0] = args;
8108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8109 if (!SWIG_IsOK(res1)) {
8110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8111 }
8112 arg1 = reinterpret_cast< wxRect * >(argp1);
8113 {
8114 result = (PyObject *)wxRect_Get(arg1);
8115 if (PyErr_Occurred()) SWIG_fail;
8116 }
8117 resultobj = result;
8118 return resultobj;
8119 fail:
8120 return NULL;
8121 }
8122
8123
8124 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8125 PyObject *obj;
8126 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8127 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8128 return SWIG_Py_Void();
8129 }
8130
8131 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8132 return SWIG_Python_InitShadowInstance(args);
8133 }
8134
8135 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8136 PyObject *resultobj = 0;
8137 wxRect *arg1 = (wxRect *) 0 ;
8138 wxRect *arg2 = (wxRect *) 0 ;
8139 PyObject *result = 0 ;
8140 void *argp1 = 0 ;
8141 int res1 = 0 ;
8142 void *argp2 = 0 ;
8143 int res2 = 0 ;
8144 PyObject * obj0 = 0 ;
8145 PyObject * obj1 = 0 ;
8146 char * kwnames[] = {
8147 (char *) "r1",(char *) "r2", NULL
8148 };
8149
8150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8152 if (!SWIG_IsOK(res1)) {
8153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8154 }
8155 arg1 = reinterpret_cast< wxRect * >(argp1);
8156 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8157 if (!SWIG_IsOK(res2)) {
8158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8159 }
8160 arg2 = reinterpret_cast< wxRect * >(argp2);
8161 {
8162 if (!wxPyCheckForApp()) SWIG_fail;
8163 PyThreadState* __tstate = wxPyBeginAllowThreads();
8164 result = (PyObject *)wxIntersectRect(arg1,arg2);
8165 wxPyEndAllowThreads(__tstate);
8166 if (PyErr_Occurred()) SWIG_fail;
8167 }
8168 resultobj = result;
8169 return resultobj;
8170 fail:
8171 return NULL;
8172 }
8173
8174
8175 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8176 PyObject *resultobj = 0;
8177 double arg1 = (double) 0.0 ;
8178 double arg2 = (double) 0.0 ;
8179 wxPoint2D *result = 0 ;
8180 double val1 ;
8181 int ecode1 = 0 ;
8182 double val2 ;
8183 int ecode2 = 0 ;
8184 PyObject * obj0 = 0 ;
8185 PyObject * obj1 = 0 ;
8186 char * kwnames[] = {
8187 (char *) "x",(char *) "y", NULL
8188 };
8189
8190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8191 if (obj0) {
8192 ecode1 = SWIG_AsVal_double(obj0, &val1);
8193 if (!SWIG_IsOK(ecode1)) {
8194 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8195 }
8196 arg1 = static_cast< double >(val1);
8197 }
8198 if (obj1) {
8199 ecode2 = SWIG_AsVal_double(obj1, &val2);
8200 if (!SWIG_IsOK(ecode2)) {
8201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8202 }
8203 arg2 = static_cast< double >(val2);
8204 }
8205 {
8206 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8207 if (PyErr_Occurred()) SWIG_fail;
8208 }
8209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8210 return resultobj;
8211 fail:
8212 return NULL;
8213 }
8214
8215
8216 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8217 PyObject *resultobj = 0;
8218 wxPoint2D *arg1 = 0 ;
8219 wxPoint2D *result = 0 ;
8220 wxPoint2D temp1 ;
8221 PyObject * obj0 = 0 ;
8222 char * kwnames[] = {
8223 (char *) "pt", NULL
8224 };
8225
8226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8227 {
8228 arg1 = &temp1;
8229 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8230 }
8231 {
8232 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8233 if (PyErr_Occurred()) SWIG_fail;
8234 }
8235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8236 return resultobj;
8237 fail:
8238 return NULL;
8239 }
8240
8241
8242 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8243 PyObject *resultobj = 0;
8244 wxPoint *arg1 = 0 ;
8245 wxPoint2D *result = 0 ;
8246 wxPoint temp1 ;
8247 PyObject * obj0 = 0 ;
8248 char * kwnames[] = {
8249 (char *) "pt", NULL
8250 };
8251
8252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8253 {
8254 arg1 = &temp1;
8255 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8256 }
8257 {
8258 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8259 if (PyErr_Occurred()) SWIG_fail;
8260 }
8261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8262 return resultobj;
8263 fail:
8264 return NULL;
8265 }
8266
8267
8268 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8269 PyObject *resultobj = 0;
8270 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8271 void *argp1 = 0 ;
8272 int res1 = 0 ;
8273 PyObject *swig_obj[1] ;
8274
8275 if (!args) SWIG_fail;
8276 swig_obj[0] = args;
8277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8278 if (!SWIG_IsOK(res1)) {
8279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8280 }
8281 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8282 {
8283 delete arg1;
8284
8285 if (PyErr_Occurred()) SWIG_fail;
8286 }
8287 resultobj = SWIG_Py_Void();
8288 return resultobj;
8289 fail:
8290 return NULL;
8291 }
8292
8293
8294 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8295 PyObject *resultobj = 0;
8296 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8297 int *arg2 = (int *) 0 ;
8298 int *arg3 = (int *) 0 ;
8299 void *argp1 = 0 ;
8300 int res1 = 0 ;
8301 int temp2 ;
8302 int res2 = SWIG_TMPOBJ ;
8303 int temp3 ;
8304 int res3 = SWIG_TMPOBJ ;
8305 PyObject *swig_obj[1] ;
8306
8307 arg2 = &temp2;
8308 arg3 = &temp3;
8309 if (!args) SWIG_fail;
8310 swig_obj[0] = args;
8311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8312 if (!SWIG_IsOK(res1)) {
8313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8314 }
8315 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8316 {
8317 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8318 if (PyErr_Occurred()) SWIG_fail;
8319 }
8320 resultobj = SWIG_Py_Void();
8321 if (SWIG_IsTmpObj(res2)) {
8322 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8323 } else {
8324 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8325 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8326 }
8327 if (SWIG_IsTmpObj(res3)) {
8328 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8329 } else {
8330 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8331 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8332 }
8333 return resultobj;
8334 fail:
8335 return NULL;
8336 }
8337
8338
8339 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8340 PyObject *resultobj = 0;
8341 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8342 int *arg2 = (int *) 0 ;
8343 int *arg3 = (int *) 0 ;
8344 void *argp1 = 0 ;
8345 int res1 = 0 ;
8346 int temp2 ;
8347 int res2 = SWIG_TMPOBJ ;
8348 int temp3 ;
8349 int res3 = SWIG_TMPOBJ ;
8350 PyObject *swig_obj[1] ;
8351
8352 arg2 = &temp2;
8353 arg3 = &temp3;
8354 if (!args) SWIG_fail;
8355 swig_obj[0] = args;
8356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8357 if (!SWIG_IsOK(res1)) {
8358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8359 }
8360 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8361 {
8362 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8363 if (PyErr_Occurred()) SWIG_fail;
8364 }
8365 resultobj = SWIG_Py_Void();
8366 if (SWIG_IsTmpObj(res2)) {
8367 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8368 } else {
8369 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8370 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8371 }
8372 if (SWIG_IsTmpObj(res3)) {
8373 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8374 } else {
8375 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8376 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8377 }
8378 return resultobj;
8379 fail:
8380 return NULL;
8381 }
8382
8383
8384 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8385 PyObject *resultobj = 0;
8386 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8387 double result;
8388 void *argp1 = 0 ;
8389 int res1 = 0 ;
8390 PyObject *swig_obj[1] ;
8391
8392 if (!args) SWIG_fail;
8393 swig_obj[0] = args;
8394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8395 if (!SWIG_IsOK(res1)) {
8396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8397 }
8398 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8399 {
8400 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8401 if (PyErr_Occurred()) SWIG_fail;
8402 }
8403 resultobj = SWIG_From_double(static_cast< double >(result));
8404 return resultobj;
8405 fail:
8406 return NULL;
8407 }
8408
8409
8410 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8411 PyObject *resultobj = 0;
8412 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8413 double result;
8414 void *argp1 = 0 ;
8415 int res1 = 0 ;
8416 PyObject *swig_obj[1] ;
8417
8418 if (!args) SWIG_fail;
8419 swig_obj[0] = args;
8420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8421 if (!SWIG_IsOK(res1)) {
8422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8423 }
8424 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8425 {
8426 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8427 if (PyErr_Occurred()) SWIG_fail;
8428 }
8429 resultobj = SWIG_From_double(static_cast< double >(result));
8430 return resultobj;
8431 fail:
8432 return NULL;
8433 }
8434
8435
8436 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8437 PyObject *resultobj = 0;
8438 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8439 double arg2 ;
8440 void *argp1 = 0 ;
8441 int res1 = 0 ;
8442 double val2 ;
8443 int ecode2 = 0 ;
8444 PyObject * obj0 = 0 ;
8445 PyObject * obj1 = 0 ;
8446 char * kwnames[] = {
8447 (char *) "self",(char *) "length", NULL
8448 };
8449
8450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8452 if (!SWIG_IsOK(res1)) {
8453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8454 }
8455 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8456 ecode2 = SWIG_AsVal_double(obj1, &val2);
8457 if (!SWIG_IsOK(ecode2)) {
8458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8459 }
8460 arg2 = static_cast< double >(val2);
8461 {
8462 (arg1)->SetVectorLength(arg2);
8463 if (PyErr_Occurred()) SWIG_fail;
8464 }
8465 resultobj = SWIG_Py_Void();
8466 return resultobj;
8467 fail:
8468 return NULL;
8469 }
8470
8471
8472 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8473 PyObject *resultobj = 0;
8474 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8475 double arg2 ;
8476 void *argp1 = 0 ;
8477 int res1 = 0 ;
8478 double val2 ;
8479 int ecode2 = 0 ;
8480 PyObject * obj0 = 0 ;
8481 PyObject * obj1 = 0 ;
8482 char * kwnames[] = {
8483 (char *) "self",(char *) "degrees", NULL
8484 };
8485
8486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8488 if (!SWIG_IsOK(res1)) {
8489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8490 }
8491 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8492 ecode2 = SWIG_AsVal_double(obj1, &val2);
8493 if (!SWIG_IsOK(ecode2)) {
8494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8495 }
8496 arg2 = static_cast< double >(val2);
8497 {
8498 (arg1)->SetVectorAngle(arg2);
8499 if (PyErr_Occurred()) SWIG_fail;
8500 }
8501 resultobj = SWIG_Py_Void();
8502 return resultobj;
8503 fail:
8504 return NULL;
8505 }
8506
8507
8508 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8509 PyObject *resultobj = 0;
8510 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8511 wxPoint2D *arg2 = 0 ;
8512 double result;
8513 void *argp1 = 0 ;
8514 int res1 = 0 ;
8515 wxPoint2D temp2 ;
8516 PyObject * obj0 = 0 ;
8517 PyObject * obj1 = 0 ;
8518 char * kwnames[] = {
8519 (char *) "self",(char *) "pt", NULL
8520 };
8521
8522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8524 if (!SWIG_IsOK(res1)) {
8525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8526 }
8527 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8528 {
8529 arg2 = &temp2;
8530 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8531 }
8532 {
8533 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8534 if (PyErr_Occurred()) SWIG_fail;
8535 }
8536 resultobj = SWIG_From_double(static_cast< double >(result));
8537 return resultobj;
8538 fail:
8539 return NULL;
8540 }
8541
8542
8543 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8544 PyObject *resultobj = 0;
8545 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8546 wxPoint2D *arg2 = 0 ;
8547 double result;
8548 void *argp1 = 0 ;
8549 int res1 = 0 ;
8550 wxPoint2D temp2 ;
8551 PyObject * obj0 = 0 ;
8552 PyObject * obj1 = 0 ;
8553 char * kwnames[] = {
8554 (char *) "self",(char *) "pt", NULL
8555 };
8556
8557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8559 if (!SWIG_IsOK(res1)) {
8560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8561 }
8562 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8563 {
8564 arg2 = &temp2;
8565 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8566 }
8567 {
8568 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8569 if (PyErr_Occurred()) SWIG_fail;
8570 }
8571 resultobj = SWIG_From_double(static_cast< double >(result));
8572 return resultobj;
8573 fail:
8574 return NULL;
8575 }
8576
8577
8578 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8579 PyObject *resultobj = 0;
8580 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8581 wxPoint2D *arg2 = 0 ;
8582 double result;
8583 void *argp1 = 0 ;
8584 int res1 = 0 ;
8585 wxPoint2D temp2 ;
8586 PyObject * obj0 = 0 ;
8587 PyObject * obj1 = 0 ;
8588 char * kwnames[] = {
8589 (char *) "self",(char *) "vec", NULL
8590 };
8591
8592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8594 if (!SWIG_IsOK(res1)) {
8595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8596 }
8597 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8598 {
8599 arg2 = &temp2;
8600 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8601 }
8602 {
8603 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8604 if (PyErr_Occurred()) SWIG_fail;
8605 }
8606 resultobj = SWIG_From_double(static_cast< double >(result));
8607 return resultobj;
8608 fail:
8609 return NULL;
8610 }
8611
8612
8613 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8614 PyObject *resultobj = 0;
8615 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8616 wxPoint2D *arg2 = 0 ;
8617 double result;
8618 void *argp1 = 0 ;
8619 int res1 = 0 ;
8620 wxPoint2D temp2 ;
8621 PyObject * obj0 = 0 ;
8622 PyObject * obj1 = 0 ;
8623 char * kwnames[] = {
8624 (char *) "self",(char *) "vec", NULL
8625 };
8626
8627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8629 if (!SWIG_IsOK(res1)) {
8630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8631 }
8632 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8633 {
8634 arg2 = &temp2;
8635 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8636 }
8637 {
8638 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8639 if (PyErr_Occurred()) SWIG_fail;
8640 }
8641 resultobj = SWIG_From_double(static_cast< double >(result));
8642 return resultobj;
8643 fail:
8644 return NULL;
8645 }
8646
8647
8648 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8649 PyObject *resultobj = 0;
8650 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8651 wxPoint2D result;
8652 void *argp1 = 0 ;
8653 int res1 = 0 ;
8654 PyObject *swig_obj[1] ;
8655
8656 if (!args) SWIG_fail;
8657 swig_obj[0] = args;
8658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8659 if (!SWIG_IsOK(res1)) {
8660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8661 }
8662 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8663 {
8664 result = (arg1)->operator -();
8665 if (PyErr_Occurred()) SWIG_fail;
8666 }
8667 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8668 return resultobj;
8669 fail:
8670 return NULL;
8671 }
8672
8673
8674 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8675 PyObject *resultobj = 0;
8676 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8677 wxPoint2D *arg2 = 0 ;
8678 wxPoint2D *result = 0 ;
8679 void *argp1 = 0 ;
8680 int res1 = 0 ;
8681 wxPoint2D temp2 ;
8682 PyObject * obj0 = 0 ;
8683 PyObject * obj1 = 0 ;
8684 char * kwnames[] = {
8685 (char *) "self",(char *) "pt", NULL
8686 };
8687
8688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8690 if (!SWIG_IsOK(res1)) {
8691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8692 }
8693 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8694 {
8695 arg2 = &temp2;
8696 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8697 }
8698 {
8699 {
8700 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8701 result = (wxPoint2D *) &_result_ref;
8702 }
8703 if (PyErr_Occurred()) SWIG_fail;
8704 }
8705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8706 return resultobj;
8707 fail:
8708 return NULL;
8709 }
8710
8711
8712 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8713 PyObject *resultobj = 0;
8714 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8715 wxPoint2D *arg2 = 0 ;
8716 wxPoint2D *result = 0 ;
8717 void *argp1 = 0 ;
8718 int res1 = 0 ;
8719 wxPoint2D temp2 ;
8720 PyObject * obj0 = 0 ;
8721 PyObject * obj1 = 0 ;
8722 char * kwnames[] = {
8723 (char *) "self",(char *) "pt", NULL
8724 };
8725
8726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8728 if (!SWIG_IsOK(res1)) {
8729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8730 }
8731 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8732 {
8733 arg2 = &temp2;
8734 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8735 }
8736 {
8737 {
8738 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8739 result = (wxPoint2D *) &_result_ref;
8740 }
8741 if (PyErr_Occurred()) SWIG_fail;
8742 }
8743 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8744 return resultobj;
8745 fail:
8746 return NULL;
8747 }
8748
8749
8750 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8751 PyObject *resultobj = 0;
8752 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8753 wxPoint2D *arg2 = 0 ;
8754 wxPoint2D *result = 0 ;
8755 void *argp1 = 0 ;
8756 int res1 = 0 ;
8757 wxPoint2D temp2 ;
8758 PyObject * obj0 = 0 ;
8759 PyObject * obj1 = 0 ;
8760 char * kwnames[] = {
8761 (char *) "self",(char *) "pt", NULL
8762 };
8763
8764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8766 if (!SWIG_IsOK(res1)) {
8767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8768 }
8769 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8770 {
8771 arg2 = &temp2;
8772 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8773 }
8774 {
8775 {
8776 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8777 result = (wxPoint2D *) &_result_ref;
8778 }
8779 if (PyErr_Occurred()) SWIG_fail;
8780 }
8781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8782 return resultobj;
8783 fail:
8784 return NULL;
8785 }
8786
8787
8788 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8789 PyObject *resultobj = 0;
8790 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8791 wxPoint2D *arg2 = 0 ;
8792 wxPoint2D *result = 0 ;
8793 void *argp1 = 0 ;
8794 int res1 = 0 ;
8795 wxPoint2D temp2 ;
8796 PyObject * obj0 = 0 ;
8797 PyObject * obj1 = 0 ;
8798 char * kwnames[] = {
8799 (char *) "self",(char *) "pt", NULL
8800 };
8801
8802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8804 if (!SWIG_IsOK(res1)) {
8805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8806 }
8807 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8808 {
8809 arg2 = &temp2;
8810 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8811 }
8812 {
8813 {
8814 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8815 result = (wxPoint2D *) &_result_ref;
8816 }
8817 if (PyErr_Occurred()) SWIG_fail;
8818 }
8819 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8820 return resultobj;
8821 fail:
8822 return NULL;
8823 }
8824
8825
8826 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8827 PyObject *resultobj = 0;
8828 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8829 PyObject *arg2 = (PyObject *) 0 ;
8830 bool result;
8831 void *argp1 = 0 ;
8832 int res1 = 0 ;
8833 PyObject * obj0 = 0 ;
8834 PyObject * obj1 = 0 ;
8835 char * kwnames[] = {
8836 (char *) "self",(char *) "other", NULL
8837 };
8838
8839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8841 if (!SWIG_IsOK(res1)) {
8842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8843 }
8844 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8845 arg2 = obj1;
8846 {
8847 result = (bool)wxPoint2D___eq__(arg1,arg2);
8848 if (PyErr_Occurred()) SWIG_fail;
8849 }
8850 {
8851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8852 }
8853 return resultobj;
8854 fail:
8855 return NULL;
8856 }
8857
8858
8859 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8860 PyObject *resultobj = 0;
8861 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8862 PyObject *arg2 = (PyObject *) 0 ;
8863 bool result;
8864 void *argp1 = 0 ;
8865 int res1 = 0 ;
8866 PyObject * obj0 = 0 ;
8867 PyObject * obj1 = 0 ;
8868 char * kwnames[] = {
8869 (char *) "self",(char *) "other", NULL
8870 };
8871
8872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8874 if (!SWIG_IsOK(res1)) {
8875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8876 }
8877 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8878 arg2 = obj1;
8879 {
8880 result = (bool)wxPoint2D___ne__(arg1,arg2);
8881 if (PyErr_Occurred()) SWIG_fail;
8882 }
8883 {
8884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8885 }
8886 return resultobj;
8887 fail:
8888 return NULL;
8889 }
8890
8891
8892 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8893 PyObject *resultobj = 0;
8894 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8895 double arg2 ;
8896 void *argp1 = 0 ;
8897 int res1 = 0 ;
8898 double val2 ;
8899 int ecode2 = 0 ;
8900 PyObject *swig_obj[2] ;
8901
8902 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8904 if (!SWIG_IsOK(res1)) {
8905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8906 }
8907 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8908 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8909 if (!SWIG_IsOK(ecode2)) {
8910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8911 }
8912 arg2 = static_cast< double >(val2);
8913 if (arg1) (arg1)->m_x = arg2;
8914
8915 resultobj = SWIG_Py_Void();
8916 return resultobj;
8917 fail:
8918 return NULL;
8919 }
8920
8921
8922 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8923 PyObject *resultobj = 0;
8924 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8925 double result;
8926 void *argp1 = 0 ;
8927 int res1 = 0 ;
8928 PyObject *swig_obj[1] ;
8929
8930 if (!args) SWIG_fail;
8931 swig_obj[0] = args;
8932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8933 if (!SWIG_IsOK(res1)) {
8934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8935 }
8936 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8937 result = (double) ((arg1)->m_x);
8938 resultobj = SWIG_From_double(static_cast< double >(result));
8939 return resultobj;
8940 fail:
8941 return NULL;
8942 }
8943
8944
8945 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8946 PyObject *resultobj = 0;
8947 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8948 double arg2 ;
8949 void *argp1 = 0 ;
8950 int res1 = 0 ;
8951 double val2 ;
8952 int ecode2 = 0 ;
8953 PyObject *swig_obj[2] ;
8954
8955 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8957 if (!SWIG_IsOK(res1)) {
8958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8959 }
8960 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8961 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8962 if (!SWIG_IsOK(ecode2)) {
8963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8964 }
8965 arg2 = static_cast< double >(val2);
8966 if (arg1) (arg1)->m_y = arg2;
8967
8968 resultobj = SWIG_Py_Void();
8969 return resultobj;
8970 fail:
8971 return NULL;
8972 }
8973
8974
8975 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8976 PyObject *resultobj = 0;
8977 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8978 double result;
8979 void *argp1 = 0 ;
8980 int res1 = 0 ;
8981 PyObject *swig_obj[1] ;
8982
8983 if (!args) SWIG_fail;
8984 swig_obj[0] = args;
8985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8986 if (!SWIG_IsOK(res1)) {
8987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8988 }
8989 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8990 result = (double) ((arg1)->m_y);
8991 resultobj = SWIG_From_double(static_cast< double >(result));
8992 return resultobj;
8993 fail:
8994 return NULL;
8995 }
8996
8997
8998 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8999 PyObject *resultobj = 0;
9000 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9001 double arg2 = (double) 0 ;
9002 double arg3 = (double) 0 ;
9003 void *argp1 = 0 ;
9004 int res1 = 0 ;
9005 double val2 ;
9006 int ecode2 = 0 ;
9007 double val3 ;
9008 int ecode3 = 0 ;
9009 PyObject * obj0 = 0 ;
9010 PyObject * obj1 = 0 ;
9011 PyObject * obj2 = 0 ;
9012 char * kwnames[] = {
9013 (char *) "self",(char *) "x",(char *) "y", NULL
9014 };
9015
9016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9018 if (!SWIG_IsOK(res1)) {
9019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9020 }
9021 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9022 if (obj1) {
9023 ecode2 = SWIG_AsVal_double(obj1, &val2);
9024 if (!SWIG_IsOK(ecode2)) {
9025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9026 }
9027 arg2 = static_cast< double >(val2);
9028 }
9029 if (obj2) {
9030 ecode3 = SWIG_AsVal_double(obj2, &val3);
9031 if (!SWIG_IsOK(ecode3)) {
9032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9033 }
9034 arg3 = static_cast< double >(val3);
9035 }
9036 {
9037 wxPoint2D_Set(arg1,arg2,arg3);
9038 if (PyErr_Occurred()) SWIG_fail;
9039 }
9040 resultobj = SWIG_Py_Void();
9041 return resultobj;
9042 fail:
9043 return NULL;
9044 }
9045
9046
9047 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9048 PyObject *resultobj = 0;
9049 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9050 PyObject *result = 0 ;
9051 void *argp1 = 0 ;
9052 int res1 = 0 ;
9053 PyObject *swig_obj[1] ;
9054
9055 if (!args) SWIG_fail;
9056 swig_obj[0] = args;
9057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9058 if (!SWIG_IsOK(res1)) {
9059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9060 }
9061 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9062 {
9063 result = (PyObject *)wxPoint2D_Get(arg1);
9064 if (PyErr_Occurred()) SWIG_fail;
9065 }
9066 resultobj = result;
9067 return resultobj;
9068 fail:
9069 return NULL;
9070 }
9071
9072
9073 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9074 PyObject *obj;
9075 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9076 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9077 return SWIG_Py_Void();
9078 }
9079
9080 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9081 return SWIG_Python_InitShadowInstance(args);
9082 }
9083
9084 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9085 PyObject *resultobj = 0;
9086 wxDouble arg1 = (wxDouble) 0.0 ;
9087 wxDouble arg2 = (wxDouble) 0.0 ;
9088 wxDouble arg3 = (wxDouble) 0.0 ;
9089 wxDouble arg4 = (wxDouble) 0.0 ;
9090 wxRect2D *result = 0 ;
9091 void *argp1 ;
9092 int res1 = 0 ;
9093 void *argp2 ;
9094 int res2 = 0 ;
9095 void *argp3 ;
9096 int res3 = 0 ;
9097 void *argp4 ;
9098 int res4 = 0 ;
9099 PyObject * obj0 = 0 ;
9100 PyObject * obj1 = 0 ;
9101 PyObject * obj2 = 0 ;
9102 PyObject * obj3 = 0 ;
9103 char * kwnames[] = {
9104 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9105 };
9106
9107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9108 if (obj0) {
9109 {
9110 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9111 if (!SWIG_IsOK(res1)) {
9112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9113 }
9114 if (!argp1) {
9115 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9116 } else {
9117 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9118 arg1 = *temp;
9119 if (SWIG_IsNewObj(res1)) delete temp;
9120 }
9121 }
9122 }
9123 if (obj1) {
9124 {
9125 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9126 if (!SWIG_IsOK(res2)) {
9127 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9128 }
9129 if (!argp2) {
9130 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9131 } else {
9132 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9133 arg2 = *temp;
9134 if (SWIG_IsNewObj(res2)) delete temp;
9135 }
9136 }
9137 }
9138 if (obj2) {
9139 {
9140 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9141 if (!SWIG_IsOK(res3)) {
9142 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9143 }
9144 if (!argp3) {
9145 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9146 } else {
9147 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9148 arg3 = *temp;
9149 if (SWIG_IsNewObj(res3)) delete temp;
9150 }
9151 }
9152 }
9153 if (obj3) {
9154 {
9155 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9156 if (!SWIG_IsOK(res4)) {
9157 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9158 }
9159 if (!argp4) {
9160 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9161 } else {
9162 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9163 arg4 = *temp;
9164 if (SWIG_IsNewObj(res4)) delete temp;
9165 }
9166 }
9167 }
9168 {
9169 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9170 if (PyErr_Occurred()) SWIG_fail;
9171 }
9172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9173 return resultobj;
9174 fail:
9175 return NULL;
9176 }
9177
9178
9179 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9180 PyObject *resultobj = 0;
9181 wxRect2D *arg1 = (wxRect2D *) 0 ;
9182 void *argp1 = 0 ;
9183 int res1 = 0 ;
9184 PyObject *swig_obj[1] ;
9185
9186 if (!args) SWIG_fail;
9187 swig_obj[0] = args;
9188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9189 if (!SWIG_IsOK(res1)) {
9190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9191 }
9192 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9193 {
9194 delete arg1;
9195
9196 if (PyErr_Occurred()) SWIG_fail;
9197 }
9198 resultobj = SWIG_Py_Void();
9199 return resultobj;
9200 fail:
9201 return NULL;
9202 }
9203
9204
9205 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9206 PyObject *resultobj = 0;
9207 wxRect2D *arg1 = (wxRect2D *) 0 ;
9208 wxPoint2D result;
9209 void *argp1 = 0 ;
9210 int res1 = 0 ;
9211 PyObject *swig_obj[1] ;
9212
9213 if (!args) SWIG_fail;
9214 swig_obj[0] = args;
9215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9216 if (!SWIG_IsOK(res1)) {
9217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9218 }
9219 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9220 {
9221 result = (arg1)->GetPosition();
9222 if (PyErr_Occurred()) SWIG_fail;
9223 }
9224 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9225 return resultobj;
9226 fail:
9227 return NULL;
9228 }
9229
9230
9231 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9232 PyObject *resultobj = 0;
9233 wxRect2D *arg1 = (wxRect2D *) 0 ;
9234 wxSize result;
9235 void *argp1 = 0 ;
9236 int res1 = 0 ;
9237 PyObject *swig_obj[1] ;
9238
9239 if (!args) SWIG_fail;
9240 swig_obj[0] = args;
9241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9242 if (!SWIG_IsOK(res1)) {
9243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9244 }
9245 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9246 {
9247 result = (arg1)->GetSize();
9248 if (PyErr_Occurred()) SWIG_fail;
9249 }
9250 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9251 return resultobj;
9252 fail:
9253 return NULL;
9254 }
9255
9256
9257 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9258 PyObject *resultobj = 0;
9259 wxRect2D *arg1 = (wxRect2D *) 0 ;
9260 wxDouble result;
9261 void *argp1 = 0 ;
9262 int res1 = 0 ;
9263 PyObject *swig_obj[1] ;
9264
9265 if (!args) SWIG_fail;
9266 swig_obj[0] = args;
9267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9268 if (!SWIG_IsOK(res1)) {
9269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9270 }
9271 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9272 {
9273 result = ((wxRect2D const *)arg1)->GetLeft();
9274 if (PyErr_Occurred()) SWIG_fail;
9275 }
9276 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9277 return resultobj;
9278 fail:
9279 return NULL;
9280 }
9281
9282
9283 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9284 PyObject *resultobj = 0;
9285 wxRect2D *arg1 = (wxRect2D *) 0 ;
9286 wxDouble arg2 ;
9287 void *argp1 = 0 ;
9288 int res1 = 0 ;
9289 void *argp2 ;
9290 int res2 = 0 ;
9291 PyObject * obj0 = 0 ;
9292 PyObject * obj1 = 0 ;
9293 char * kwnames[] = {
9294 (char *) "self",(char *) "n", NULL
9295 };
9296
9297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9299 if (!SWIG_IsOK(res1)) {
9300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9301 }
9302 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9303 {
9304 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9305 if (!SWIG_IsOK(res2)) {
9306 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9307 }
9308 if (!argp2) {
9309 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9310 } else {
9311 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9312 arg2 = *temp;
9313 if (SWIG_IsNewObj(res2)) delete temp;
9314 }
9315 }
9316 {
9317 (arg1)->SetLeft(arg2);
9318 if (PyErr_Occurred()) SWIG_fail;
9319 }
9320 resultobj = SWIG_Py_Void();
9321 return resultobj;
9322 fail:
9323 return NULL;
9324 }
9325
9326
9327 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9328 PyObject *resultobj = 0;
9329 wxRect2D *arg1 = (wxRect2D *) 0 ;
9330 wxDouble arg2 ;
9331 void *argp1 = 0 ;
9332 int res1 = 0 ;
9333 void *argp2 ;
9334 int res2 = 0 ;
9335 PyObject * obj0 = 0 ;
9336 PyObject * obj1 = 0 ;
9337 char * kwnames[] = {
9338 (char *) "self",(char *) "n", NULL
9339 };
9340
9341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9343 if (!SWIG_IsOK(res1)) {
9344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9345 }
9346 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9347 {
9348 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9349 if (!SWIG_IsOK(res2)) {
9350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9351 }
9352 if (!argp2) {
9353 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9354 } else {
9355 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9356 arg2 = *temp;
9357 if (SWIG_IsNewObj(res2)) delete temp;
9358 }
9359 }
9360 {
9361 (arg1)->MoveLeftTo(arg2);
9362 if (PyErr_Occurred()) SWIG_fail;
9363 }
9364 resultobj = SWIG_Py_Void();
9365 return resultobj;
9366 fail:
9367 return NULL;
9368 }
9369
9370
9371 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9372 PyObject *resultobj = 0;
9373 wxRect2D *arg1 = (wxRect2D *) 0 ;
9374 wxDouble result;
9375 void *argp1 = 0 ;
9376 int res1 = 0 ;
9377 PyObject *swig_obj[1] ;
9378
9379 if (!args) SWIG_fail;
9380 swig_obj[0] = args;
9381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9382 if (!SWIG_IsOK(res1)) {
9383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9384 }
9385 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9386 {
9387 result = ((wxRect2D const *)arg1)->GetTop();
9388 if (PyErr_Occurred()) SWIG_fail;
9389 }
9390 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9391 return resultobj;
9392 fail:
9393 return NULL;
9394 }
9395
9396
9397 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9398 PyObject *resultobj = 0;
9399 wxRect2D *arg1 = (wxRect2D *) 0 ;
9400 wxDouble arg2 ;
9401 void *argp1 = 0 ;
9402 int res1 = 0 ;
9403 void *argp2 ;
9404 int res2 = 0 ;
9405 PyObject * obj0 = 0 ;
9406 PyObject * obj1 = 0 ;
9407 char * kwnames[] = {
9408 (char *) "self",(char *) "n", NULL
9409 };
9410
9411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9413 if (!SWIG_IsOK(res1)) {
9414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9415 }
9416 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9417 {
9418 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9419 if (!SWIG_IsOK(res2)) {
9420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9421 }
9422 if (!argp2) {
9423 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9424 } else {
9425 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9426 arg2 = *temp;
9427 if (SWIG_IsNewObj(res2)) delete temp;
9428 }
9429 }
9430 {
9431 (arg1)->SetTop(arg2);
9432 if (PyErr_Occurred()) SWIG_fail;
9433 }
9434 resultobj = SWIG_Py_Void();
9435 return resultobj;
9436 fail:
9437 return NULL;
9438 }
9439
9440
9441 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9442 PyObject *resultobj = 0;
9443 wxRect2D *arg1 = (wxRect2D *) 0 ;
9444 wxDouble arg2 ;
9445 void *argp1 = 0 ;
9446 int res1 = 0 ;
9447 void *argp2 ;
9448 int res2 = 0 ;
9449 PyObject * obj0 = 0 ;
9450 PyObject * obj1 = 0 ;
9451 char * kwnames[] = {
9452 (char *) "self",(char *) "n", NULL
9453 };
9454
9455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9457 if (!SWIG_IsOK(res1)) {
9458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9459 }
9460 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9461 {
9462 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9463 if (!SWIG_IsOK(res2)) {
9464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9465 }
9466 if (!argp2) {
9467 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9468 } else {
9469 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9470 arg2 = *temp;
9471 if (SWIG_IsNewObj(res2)) delete temp;
9472 }
9473 }
9474 {
9475 (arg1)->MoveTopTo(arg2);
9476 if (PyErr_Occurred()) SWIG_fail;
9477 }
9478 resultobj = SWIG_Py_Void();
9479 return resultobj;
9480 fail:
9481 return NULL;
9482 }
9483
9484
9485 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9486 PyObject *resultobj = 0;
9487 wxRect2D *arg1 = (wxRect2D *) 0 ;
9488 wxDouble result;
9489 void *argp1 = 0 ;
9490 int res1 = 0 ;
9491 PyObject *swig_obj[1] ;
9492
9493 if (!args) SWIG_fail;
9494 swig_obj[0] = args;
9495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9496 if (!SWIG_IsOK(res1)) {
9497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9498 }
9499 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9500 {
9501 result = ((wxRect2D const *)arg1)->GetBottom();
9502 if (PyErr_Occurred()) SWIG_fail;
9503 }
9504 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9505 return resultobj;
9506 fail:
9507 return NULL;
9508 }
9509
9510
9511 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9512 PyObject *resultobj = 0;
9513 wxRect2D *arg1 = (wxRect2D *) 0 ;
9514 wxDouble arg2 ;
9515 void *argp1 = 0 ;
9516 int res1 = 0 ;
9517 void *argp2 ;
9518 int res2 = 0 ;
9519 PyObject * obj0 = 0 ;
9520 PyObject * obj1 = 0 ;
9521 char * kwnames[] = {
9522 (char *) "self",(char *) "n", NULL
9523 };
9524
9525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9527 if (!SWIG_IsOK(res1)) {
9528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9529 }
9530 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9531 {
9532 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9533 if (!SWIG_IsOK(res2)) {
9534 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9535 }
9536 if (!argp2) {
9537 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9538 } else {
9539 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9540 arg2 = *temp;
9541 if (SWIG_IsNewObj(res2)) delete temp;
9542 }
9543 }
9544 {
9545 (arg1)->SetBottom(arg2);
9546 if (PyErr_Occurred()) SWIG_fail;
9547 }
9548 resultobj = SWIG_Py_Void();
9549 return resultobj;
9550 fail:
9551 return NULL;
9552 }
9553
9554
9555 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9556 PyObject *resultobj = 0;
9557 wxRect2D *arg1 = (wxRect2D *) 0 ;
9558 wxDouble arg2 ;
9559 void *argp1 = 0 ;
9560 int res1 = 0 ;
9561 void *argp2 ;
9562 int res2 = 0 ;
9563 PyObject * obj0 = 0 ;
9564 PyObject * obj1 = 0 ;
9565 char * kwnames[] = {
9566 (char *) "self",(char *) "n", NULL
9567 };
9568
9569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9571 if (!SWIG_IsOK(res1)) {
9572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9573 }
9574 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9575 {
9576 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9577 if (!SWIG_IsOK(res2)) {
9578 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9579 }
9580 if (!argp2) {
9581 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9582 } else {
9583 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9584 arg2 = *temp;
9585 if (SWIG_IsNewObj(res2)) delete temp;
9586 }
9587 }
9588 {
9589 (arg1)->MoveBottomTo(arg2);
9590 if (PyErr_Occurred()) SWIG_fail;
9591 }
9592 resultobj = SWIG_Py_Void();
9593 return resultobj;
9594 fail:
9595 return NULL;
9596 }
9597
9598
9599 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9600 PyObject *resultobj = 0;
9601 wxRect2D *arg1 = (wxRect2D *) 0 ;
9602 wxDouble result;
9603 void *argp1 = 0 ;
9604 int res1 = 0 ;
9605 PyObject *swig_obj[1] ;
9606
9607 if (!args) SWIG_fail;
9608 swig_obj[0] = args;
9609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9610 if (!SWIG_IsOK(res1)) {
9611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9612 }
9613 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9614 {
9615 result = ((wxRect2D const *)arg1)->GetRight();
9616 if (PyErr_Occurred()) SWIG_fail;
9617 }
9618 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9619 return resultobj;
9620 fail:
9621 return NULL;
9622 }
9623
9624
9625 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9626 PyObject *resultobj = 0;
9627 wxRect2D *arg1 = (wxRect2D *) 0 ;
9628 wxDouble arg2 ;
9629 void *argp1 = 0 ;
9630 int res1 = 0 ;
9631 void *argp2 ;
9632 int res2 = 0 ;
9633 PyObject * obj0 = 0 ;
9634 PyObject * obj1 = 0 ;
9635 char * kwnames[] = {
9636 (char *) "self",(char *) "n", NULL
9637 };
9638
9639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9641 if (!SWIG_IsOK(res1)) {
9642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9643 }
9644 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9645 {
9646 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9647 if (!SWIG_IsOK(res2)) {
9648 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9649 }
9650 if (!argp2) {
9651 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9652 } else {
9653 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9654 arg2 = *temp;
9655 if (SWIG_IsNewObj(res2)) delete temp;
9656 }
9657 }
9658 {
9659 (arg1)->SetRight(arg2);
9660 if (PyErr_Occurred()) SWIG_fail;
9661 }
9662 resultobj = SWIG_Py_Void();
9663 return resultobj;
9664 fail:
9665 return NULL;
9666 }
9667
9668
9669 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9670 PyObject *resultobj = 0;
9671 wxRect2D *arg1 = (wxRect2D *) 0 ;
9672 wxDouble arg2 ;
9673 void *argp1 = 0 ;
9674 int res1 = 0 ;
9675 void *argp2 ;
9676 int res2 = 0 ;
9677 PyObject * obj0 = 0 ;
9678 PyObject * obj1 = 0 ;
9679 char * kwnames[] = {
9680 (char *) "self",(char *) "n", NULL
9681 };
9682
9683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9685 if (!SWIG_IsOK(res1)) {
9686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9687 }
9688 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9689 {
9690 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9691 if (!SWIG_IsOK(res2)) {
9692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9693 }
9694 if (!argp2) {
9695 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9696 } else {
9697 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9698 arg2 = *temp;
9699 if (SWIG_IsNewObj(res2)) delete temp;
9700 }
9701 }
9702 {
9703 (arg1)->MoveRightTo(arg2);
9704 if (PyErr_Occurred()) SWIG_fail;
9705 }
9706 resultobj = SWIG_Py_Void();
9707 return resultobj;
9708 fail:
9709 return NULL;
9710 }
9711
9712
9713 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9714 PyObject *resultobj = 0;
9715 wxRect2D *arg1 = (wxRect2D *) 0 ;
9716 wxPoint2D result;
9717 void *argp1 = 0 ;
9718 int res1 = 0 ;
9719 PyObject *swig_obj[1] ;
9720
9721 if (!args) SWIG_fail;
9722 swig_obj[0] = args;
9723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9724 if (!SWIG_IsOK(res1)) {
9725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9726 }
9727 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9728 {
9729 result = ((wxRect2D const *)arg1)->GetLeftTop();
9730 if (PyErr_Occurred()) SWIG_fail;
9731 }
9732 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9733 return resultobj;
9734 fail:
9735 return NULL;
9736 }
9737
9738
9739 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9740 PyObject *resultobj = 0;
9741 wxRect2D *arg1 = (wxRect2D *) 0 ;
9742 wxPoint2D *arg2 = 0 ;
9743 void *argp1 = 0 ;
9744 int res1 = 0 ;
9745 wxPoint2D temp2 ;
9746 PyObject * obj0 = 0 ;
9747 PyObject * obj1 = 0 ;
9748 char * kwnames[] = {
9749 (char *) "self",(char *) "pt", NULL
9750 };
9751
9752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9754 if (!SWIG_IsOK(res1)) {
9755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9756 }
9757 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9758 {
9759 arg2 = &temp2;
9760 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9761 }
9762 {
9763 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9764 if (PyErr_Occurred()) SWIG_fail;
9765 }
9766 resultobj = SWIG_Py_Void();
9767 return resultobj;
9768 fail:
9769 return NULL;
9770 }
9771
9772
9773 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9774 PyObject *resultobj = 0;
9775 wxRect2D *arg1 = (wxRect2D *) 0 ;
9776 wxPoint2D *arg2 = 0 ;
9777 void *argp1 = 0 ;
9778 int res1 = 0 ;
9779 wxPoint2D temp2 ;
9780 PyObject * obj0 = 0 ;
9781 PyObject * obj1 = 0 ;
9782 char * kwnames[] = {
9783 (char *) "self",(char *) "pt", NULL
9784 };
9785
9786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9788 if (!SWIG_IsOK(res1)) {
9789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9790 }
9791 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9792 {
9793 arg2 = &temp2;
9794 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9795 }
9796 {
9797 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9798 if (PyErr_Occurred()) SWIG_fail;
9799 }
9800 resultobj = SWIG_Py_Void();
9801 return resultobj;
9802 fail:
9803 return NULL;
9804 }
9805
9806
9807 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9808 PyObject *resultobj = 0;
9809 wxRect2D *arg1 = (wxRect2D *) 0 ;
9810 wxPoint2D result;
9811 void *argp1 = 0 ;
9812 int res1 = 0 ;
9813 PyObject *swig_obj[1] ;
9814
9815 if (!args) SWIG_fail;
9816 swig_obj[0] = args;
9817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9818 if (!SWIG_IsOK(res1)) {
9819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9820 }
9821 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9822 {
9823 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9824 if (PyErr_Occurred()) SWIG_fail;
9825 }
9826 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9827 return resultobj;
9828 fail:
9829 return NULL;
9830 }
9831
9832
9833 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9834 PyObject *resultobj = 0;
9835 wxRect2D *arg1 = (wxRect2D *) 0 ;
9836 wxPoint2D *arg2 = 0 ;
9837 void *argp1 = 0 ;
9838 int res1 = 0 ;
9839 wxPoint2D temp2 ;
9840 PyObject * obj0 = 0 ;
9841 PyObject * obj1 = 0 ;
9842 char * kwnames[] = {
9843 (char *) "self",(char *) "pt", NULL
9844 };
9845
9846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9848 if (!SWIG_IsOK(res1)) {
9849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9850 }
9851 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9852 {
9853 arg2 = &temp2;
9854 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9855 }
9856 {
9857 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9858 if (PyErr_Occurred()) SWIG_fail;
9859 }
9860 resultobj = SWIG_Py_Void();
9861 return resultobj;
9862 fail:
9863 return NULL;
9864 }
9865
9866
9867 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9868 PyObject *resultobj = 0;
9869 wxRect2D *arg1 = (wxRect2D *) 0 ;
9870 wxPoint2D *arg2 = 0 ;
9871 void *argp1 = 0 ;
9872 int res1 = 0 ;
9873 wxPoint2D temp2 ;
9874 PyObject * obj0 = 0 ;
9875 PyObject * obj1 = 0 ;
9876 char * kwnames[] = {
9877 (char *) "self",(char *) "pt", NULL
9878 };
9879
9880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9882 if (!SWIG_IsOK(res1)) {
9883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9884 }
9885 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9886 {
9887 arg2 = &temp2;
9888 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9889 }
9890 {
9891 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
9892 if (PyErr_Occurred()) SWIG_fail;
9893 }
9894 resultobj = SWIG_Py_Void();
9895 return resultobj;
9896 fail:
9897 return NULL;
9898 }
9899
9900
9901 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9902 PyObject *resultobj = 0;
9903 wxRect2D *arg1 = (wxRect2D *) 0 ;
9904 wxPoint2D result;
9905 void *argp1 = 0 ;
9906 int res1 = 0 ;
9907 PyObject *swig_obj[1] ;
9908
9909 if (!args) SWIG_fail;
9910 swig_obj[0] = args;
9911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9912 if (!SWIG_IsOK(res1)) {
9913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9914 }
9915 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9916 {
9917 result = ((wxRect2D const *)arg1)->GetRightTop();
9918 if (PyErr_Occurred()) SWIG_fail;
9919 }
9920 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9921 return resultobj;
9922 fail:
9923 return NULL;
9924 }
9925
9926
9927 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9928 PyObject *resultobj = 0;
9929 wxRect2D *arg1 = (wxRect2D *) 0 ;
9930 wxPoint2D *arg2 = 0 ;
9931 void *argp1 = 0 ;
9932 int res1 = 0 ;
9933 wxPoint2D temp2 ;
9934 PyObject * obj0 = 0 ;
9935 PyObject * obj1 = 0 ;
9936 char * kwnames[] = {
9937 (char *) "self",(char *) "pt", NULL
9938 };
9939
9940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
9941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9942 if (!SWIG_IsOK(res1)) {
9943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9944 }
9945 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9946 {
9947 arg2 = &temp2;
9948 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9949 }
9950 {
9951 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
9952 if (PyErr_Occurred()) SWIG_fail;
9953 }
9954 resultobj = SWIG_Py_Void();
9955 return resultobj;
9956 fail:
9957 return NULL;
9958 }
9959
9960
9961 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9962 PyObject *resultobj = 0;
9963 wxRect2D *arg1 = (wxRect2D *) 0 ;
9964 wxPoint2D *arg2 = 0 ;
9965 void *argp1 = 0 ;
9966 int res1 = 0 ;
9967 wxPoint2D temp2 ;
9968 PyObject * obj0 = 0 ;
9969 PyObject * obj1 = 0 ;
9970 char * kwnames[] = {
9971 (char *) "self",(char *) "pt", NULL
9972 };
9973
9974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9976 if (!SWIG_IsOK(res1)) {
9977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9978 }
9979 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9980 {
9981 arg2 = &temp2;
9982 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9983 }
9984 {
9985 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
9986 if (PyErr_Occurred()) SWIG_fail;
9987 }
9988 resultobj = SWIG_Py_Void();
9989 return resultobj;
9990 fail:
9991 return NULL;
9992 }
9993
9994
9995 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9996 PyObject *resultobj = 0;
9997 wxRect2D *arg1 = (wxRect2D *) 0 ;
9998 wxPoint2D result;
9999 void *argp1 = 0 ;
10000 int res1 = 0 ;
10001 PyObject *swig_obj[1] ;
10002
10003 if (!args) SWIG_fail;
10004 swig_obj[0] = args;
10005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10006 if (!SWIG_IsOK(res1)) {
10007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10008 }
10009 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10010 {
10011 result = ((wxRect2D const *)arg1)->GetRightBottom();
10012 if (PyErr_Occurred()) SWIG_fail;
10013 }
10014 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10015 return resultobj;
10016 fail:
10017 return NULL;
10018 }
10019
10020
10021 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10022 PyObject *resultobj = 0;
10023 wxRect2D *arg1 = (wxRect2D *) 0 ;
10024 wxPoint2D *arg2 = 0 ;
10025 void *argp1 = 0 ;
10026 int res1 = 0 ;
10027 wxPoint2D temp2 ;
10028 PyObject * obj0 = 0 ;
10029 PyObject * obj1 = 0 ;
10030 char * kwnames[] = {
10031 (char *) "self",(char *) "pt", NULL
10032 };
10033
10034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10036 if (!SWIG_IsOK(res1)) {
10037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10038 }
10039 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10040 {
10041 arg2 = &temp2;
10042 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10043 }
10044 {
10045 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10046 if (PyErr_Occurred()) SWIG_fail;
10047 }
10048 resultobj = SWIG_Py_Void();
10049 return resultobj;
10050 fail:
10051 return NULL;
10052 }
10053
10054
10055 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10056 PyObject *resultobj = 0;
10057 wxRect2D *arg1 = (wxRect2D *) 0 ;
10058 wxPoint2D *arg2 = 0 ;
10059 void *argp1 = 0 ;
10060 int res1 = 0 ;
10061 wxPoint2D temp2 ;
10062 PyObject * obj0 = 0 ;
10063 PyObject * obj1 = 0 ;
10064 char * kwnames[] = {
10065 (char *) "self",(char *) "pt", NULL
10066 };
10067
10068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10070 if (!SWIG_IsOK(res1)) {
10071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10072 }
10073 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10074 {
10075 arg2 = &temp2;
10076 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10077 }
10078 {
10079 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10080 if (PyErr_Occurred()) SWIG_fail;
10081 }
10082 resultobj = SWIG_Py_Void();
10083 return resultobj;
10084 fail:
10085 return NULL;
10086 }
10087
10088
10089 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10090 PyObject *resultobj = 0;
10091 wxRect2D *arg1 = (wxRect2D *) 0 ;
10092 wxPoint2D result;
10093 void *argp1 = 0 ;
10094 int res1 = 0 ;
10095 PyObject *swig_obj[1] ;
10096
10097 if (!args) SWIG_fail;
10098 swig_obj[0] = args;
10099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10100 if (!SWIG_IsOK(res1)) {
10101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10102 }
10103 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10104 {
10105 result = ((wxRect2D const *)arg1)->GetCentre();
10106 if (PyErr_Occurred()) SWIG_fail;
10107 }
10108 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10109 return resultobj;
10110 fail:
10111 return NULL;
10112 }
10113
10114
10115 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10116 PyObject *resultobj = 0;
10117 wxRect2D *arg1 = (wxRect2D *) 0 ;
10118 wxPoint2D *arg2 = 0 ;
10119 void *argp1 = 0 ;
10120 int res1 = 0 ;
10121 wxPoint2D temp2 ;
10122 PyObject * obj0 = 0 ;
10123 PyObject * obj1 = 0 ;
10124 char * kwnames[] = {
10125 (char *) "self",(char *) "pt", NULL
10126 };
10127
10128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10130 if (!SWIG_IsOK(res1)) {
10131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10132 }
10133 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10134 {
10135 arg2 = &temp2;
10136 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10137 }
10138 {
10139 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10140 if (PyErr_Occurred()) SWIG_fail;
10141 }
10142 resultobj = SWIG_Py_Void();
10143 return resultobj;
10144 fail:
10145 return NULL;
10146 }
10147
10148
10149 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10150 PyObject *resultobj = 0;
10151 wxRect2D *arg1 = (wxRect2D *) 0 ;
10152 wxPoint2D *arg2 = 0 ;
10153 void *argp1 = 0 ;
10154 int res1 = 0 ;
10155 wxPoint2D temp2 ;
10156 PyObject * obj0 = 0 ;
10157 PyObject * obj1 = 0 ;
10158 char * kwnames[] = {
10159 (char *) "self",(char *) "pt", NULL
10160 };
10161
10162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10164 if (!SWIG_IsOK(res1)) {
10165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10166 }
10167 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10168 {
10169 arg2 = &temp2;
10170 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10171 }
10172 {
10173 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10174 if (PyErr_Occurred()) SWIG_fail;
10175 }
10176 resultobj = SWIG_Py_Void();
10177 return resultobj;
10178 fail:
10179 return NULL;
10180 }
10181
10182
10183 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10184 PyObject *resultobj = 0;
10185 wxRect2D *arg1 = (wxRect2D *) 0 ;
10186 wxPoint2D *arg2 = 0 ;
10187 wxOutCode result;
10188 void *argp1 = 0 ;
10189 int res1 = 0 ;
10190 wxPoint2D temp2 ;
10191 PyObject * obj0 = 0 ;
10192 PyObject * obj1 = 0 ;
10193 char * kwnames[] = {
10194 (char *) "self",(char *) "pt", NULL
10195 };
10196
10197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10199 if (!SWIG_IsOK(res1)) {
10200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10201 }
10202 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10203 {
10204 arg2 = &temp2;
10205 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10206 }
10207 {
10208 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10209 if (PyErr_Occurred()) SWIG_fail;
10210 }
10211 resultobj = SWIG_From_int(static_cast< int >(result));
10212 return resultobj;
10213 fail:
10214 return NULL;
10215 }
10216
10217
10218 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10219 PyObject *resultobj = 0;
10220 wxRect2D *arg1 = (wxRect2D *) 0 ;
10221 wxPoint2D *arg2 = 0 ;
10222 bool result;
10223 void *argp1 = 0 ;
10224 int res1 = 0 ;
10225 wxPoint2D temp2 ;
10226 PyObject * obj0 = 0 ;
10227 PyObject * obj1 = 0 ;
10228 char * kwnames[] = {
10229 (char *) "self",(char *) "pt", NULL
10230 };
10231
10232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10234 if (!SWIG_IsOK(res1)) {
10235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10236 }
10237 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10238 {
10239 arg2 = &temp2;
10240 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10241 }
10242 {
10243 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10244 if (PyErr_Occurred()) SWIG_fail;
10245 }
10246 {
10247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10248 }
10249 return resultobj;
10250 fail:
10251 return NULL;
10252 }
10253
10254
10255 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10256 PyObject *resultobj = 0;
10257 wxRect2D *arg1 = (wxRect2D *) 0 ;
10258 wxRect2D *arg2 = 0 ;
10259 bool result;
10260 void *argp1 = 0 ;
10261 int res1 = 0 ;
10262 wxRect2D temp2 ;
10263 PyObject * obj0 = 0 ;
10264 PyObject * obj1 = 0 ;
10265 char * kwnames[] = {
10266 (char *) "self",(char *) "rect", NULL
10267 };
10268
10269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10271 if (!SWIG_IsOK(res1)) {
10272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10273 }
10274 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10275 {
10276 arg2 = &temp2;
10277 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10278 }
10279 {
10280 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10281 if (PyErr_Occurred()) SWIG_fail;
10282 }
10283 {
10284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10285 }
10286 return resultobj;
10287 fail:
10288 return NULL;
10289 }
10290
10291
10292 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10293 PyObject *resultobj = 0;
10294 wxRect2D *arg1 = (wxRect2D *) 0 ;
10295 bool result;
10296 void *argp1 = 0 ;
10297 int res1 = 0 ;
10298 PyObject *swig_obj[1] ;
10299
10300 if (!args) SWIG_fail;
10301 swig_obj[0] = args;
10302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10303 if (!SWIG_IsOK(res1)) {
10304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10305 }
10306 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10307 {
10308 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10309 if (PyErr_Occurred()) SWIG_fail;
10310 }
10311 {
10312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10313 }
10314 return resultobj;
10315 fail:
10316 return NULL;
10317 }
10318
10319
10320 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10321 PyObject *resultobj = 0;
10322 wxRect2D *arg1 = (wxRect2D *) 0 ;
10323 wxRect2D *arg2 = 0 ;
10324 bool result;
10325 void *argp1 = 0 ;
10326 int res1 = 0 ;
10327 wxRect2D temp2 ;
10328 PyObject * obj0 = 0 ;
10329 PyObject * obj1 = 0 ;
10330 char * kwnames[] = {
10331 (char *) "self",(char *) "rect", NULL
10332 };
10333
10334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10336 if (!SWIG_IsOK(res1)) {
10337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10338 }
10339 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10340 {
10341 arg2 = &temp2;
10342 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10343 }
10344 {
10345 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10346 if (PyErr_Occurred()) SWIG_fail;
10347 }
10348 {
10349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10350 }
10351 return resultobj;
10352 fail:
10353 return NULL;
10354 }
10355
10356
10357 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10358 PyObject *resultobj = 0;
10359 wxRect2D *arg1 = (wxRect2D *) 0 ;
10360 wxDouble arg2 ;
10361 wxDouble arg3 ;
10362 void *argp1 = 0 ;
10363 int res1 = 0 ;
10364 void *argp2 ;
10365 int res2 = 0 ;
10366 void *argp3 ;
10367 int res3 = 0 ;
10368
10369 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10371 if (!SWIG_IsOK(res1)) {
10372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10373 }
10374 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10375 {
10376 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10377 if (!SWIG_IsOK(res2)) {
10378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10379 }
10380 if (!argp2) {
10381 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10382 } else {
10383 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10384 arg2 = *temp;
10385 if (SWIG_IsNewObj(res2)) delete temp;
10386 }
10387 }
10388 {
10389 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10390 if (!SWIG_IsOK(res3)) {
10391 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10392 }
10393 if (!argp3) {
10394 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10395 } else {
10396 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10397 arg3 = *temp;
10398 if (SWIG_IsNewObj(res3)) delete temp;
10399 }
10400 }
10401 {
10402 (arg1)->Inset(arg2,arg3);
10403 if (PyErr_Occurred()) SWIG_fail;
10404 }
10405 resultobj = SWIG_Py_Void();
10406 return resultobj;
10407 fail:
10408 return NULL;
10409 }
10410
10411
10412 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10413 PyObject *resultobj = 0;
10414 wxRect2D *arg1 = (wxRect2D *) 0 ;
10415 wxDouble arg2 ;
10416 wxDouble arg3 ;
10417 wxDouble arg4 ;
10418 wxDouble arg5 ;
10419 void *argp1 = 0 ;
10420 int res1 = 0 ;
10421 void *argp2 ;
10422 int res2 = 0 ;
10423 void *argp3 ;
10424 int res3 = 0 ;
10425 void *argp4 ;
10426 int res4 = 0 ;
10427 void *argp5 ;
10428 int res5 = 0 ;
10429
10430 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10432 if (!SWIG_IsOK(res1)) {
10433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10434 }
10435 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10436 {
10437 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10438 if (!SWIG_IsOK(res2)) {
10439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10440 }
10441 if (!argp2) {
10442 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10443 } else {
10444 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10445 arg2 = *temp;
10446 if (SWIG_IsNewObj(res2)) delete temp;
10447 }
10448 }
10449 {
10450 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10451 if (!SWIG_IsOK(res3)) {
10452 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10453 }
10454 if (!argp3) {
10455 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10456 } else {
10457 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10458 arg3 = *temp;
10459 if (SWIG_IsNewObj(res3)) delete temp;
10460 }
10461 }
10462 {
10463 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10464 if (!SWIG_IsOK(res4)) {
10465 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10466 }
10467 if (!argp4) {
10468 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10469 } else {
10470 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10471 arg4 = *temp;
10472 if (SWIG_IsNewObj(res4)) delete temp;
10473 }
10474 }
10475 {
10476 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10477 if (!SWIG_IsOK(res5)) {
10478 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10479 }
10480 if (!argp5) {
10481 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10482 } else {
10483 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10484 arg5 = *temp;
10485 if (SWIG_IsNewObj(res5)) delete temp;
10486 }
10487 }
10488 {
10489 (arg1)->Inset(arg2,arg3,arg4,arg5);
10490 if (PyErr_Occurred()) SWIG_fail;
10491 }
10492 resultobj = SWIG_Py_Void();
10493 return resultobj;
10494 fail:
10495 return NULL;
10496 }
10497
10498
10499 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10500 int argc;
10501 PyObject *argv[6];
10502
10503 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10504 --argc;
10505 if (argc == 3) {
10506 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10507 }
10508 if (argc == 5) {
10509 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10510 }
10511
10512 fail:
10513 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10514 return NULL;
10515 }
10516
10517
10518 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10519 PyObject *resultobj = 0;
10520 wxRect2D *arg1 = (wxRect2D *) 0 ;
10521 wxPoint2D *arg2 = 0 ;
10522 void *argp1 = 0 ;
10523 int res1 = 0 ;
10524 wxPoint2D temp2 ;
10525 PyObject * obj0 = 0 ;
10526 PyObject * obj1 = 0 ;
10527 char * kwnames[] = {
10528 (char *) "self",(char *) "pt", NULL
10529 };
10530
10531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10533 if (!SWIG_IsOK(res1)) {
10534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10535 }
10536 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10537 {
10538 arg2 = &temp2;
10539 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10540 }
10541 {
10542 (arg1)->Offset((wxPoint2D const &)*arg2);
10543 if (PyErr_Occurred()) SWIG_fail;
10544 }
10545 resultobj = SWIG_Py_Void();
10546 return resultobj;
10547 fail:
10548 return NULL;
10549 }
10550
10551
10552 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10553 PyObject *resultobj = 0;
10554 wxRect2D *arg1 = (wxRect2D *) 0 ;
10555 wxRect2D *arg2 = 0 ;
10556 void *argp1 = 0 ;
10557 int res1 = 0 ;
10558 wxRect2D temp2 ;
10559 PyObject * obj0 = 0 ;
10560 PyObject * obj1 = 0 ;
10561 char * kwnames[] = {
10562 (char *) "self",(char *) "rect", NULL
10563 };
10564
10565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10567 if (!SWIG_IsOK(res1)) {
10568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10569 }
10570 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10571 {
10572 arg2 = &temp2;
10573 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10574 }
10575 {
10576 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10577 if (PyErr_Occurred()) SWIG_fail;
10578 }
10579 resultobj = SWIG_Py_Void();
10580 return resultobj;
10581 fail:
10582 return NULL;
10583 }
10584
10585
10586 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10587 PyObject *resultobj = 0;
10588 wxRect2D *arg1 = (wxRect2D *) 0 ;
10589 int arg2 ;
10590 int arg3 ;
10591 wxPoint2D result;
10592 void *argp1 = 0 ;
10593 int res1 = 0 ;
10594 int val2 ;
10595 int ecode2 = 0 ;
10596 int val3 ;
10597 int ecode3 = 0 ;
10598 PyObject * obj0 = 0 ;
10599 PyObject * obj1 = 0 ;
10600 PyObject * obj2 = 0 ;
10601 char * kwnames[] = {
10602 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10603 };
10604
10605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10607 if (!SWIG_IsOK(res1)) {
10608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10609 }
10610 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10611 ecode2 = SWIG_AsVal_int(obj1, &val2);
10612 if (!SWIG_IsOK(ecode2)) {
10613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10614 }
10615 arg2 = static_cast< int >(val2);
10616 ecode3 = SWIG_AsVal_int(obj2, &val3);
10617 if (!SWIG_IsOK(ecode3)) {
10618 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10619 }
10620 arg3 = static_cast< int >(val3);
10621 {
10622 result = (arg1)->Interpolate(arg2,arg3);
10623 if (PyErr_Occurred()) SWIG_fail;
10624 }
10625 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10626 return resultobj;
10627 fail:
10628 return NULL;
10629 }
10630
10631
10632 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10633 PyObject *resultobj = 0;
10634 wxRect2D *arg1 = (wxRect2D *) 0 ;
10635 wxRect2D *arg2 = 0 ;
10636 void *argp1 = 0 ;
10637 int res1 = 0 ;
10638 wxRect2D temp2 ;
10639 PyObject * obj0 = 0 ;
10640 PyObject * obj1 = 0 ;
10641 char * kwnames[] = {
10642 (char *) "self",(char *) "otherRect", NULL
10643 };
10644
10645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10647 if (!SWIG_IsOK(res1)) {
10648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10649 }
10650 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10651 {
10652 arg2 = &temp2;
10653 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10654 }
10655 {
10656 (arg1)->Intersect((wxRect2D const &)*arg2);
10657 if (PyErr_Occurred()) SWIG_fail;
10658 }
10659 resultobj = SWIG_Py_Void();
10660 return resultobj;
10661 fail:
10662 return NULL;
10663 }
10664
10665
10666 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10667 PyObject *resultobj = 0;
10668 wxRect2D *arg1 = (wxRect2D *) 0 ;
10669 wxRect2D *arg2 = 0 ;
10670 wxRect2D result;
10671 void *argp1 = 0 ;
10672 int res1 = 0 ;
10673 wxRect2D temp2 ;
10674 PyObject * obj0 = 0 ;
10675 PyObject * obj1 = 0 ;
10676 char * kwnames[] = {
10677 (char *) "self",(char *) "otherRect", NULL
10678 };
10679
10680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10682 if (!SWIG_IsOK(res1)) {
10683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10684 }
10685 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10686 {
10687 arg2 = &temp2;
10688 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10689 }
10690 {
10691 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10692 if (PyErr_Occurred()) SWIG_fail;
10693 }
10694 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10695 return resultobj;
10696 fail:
10697 return NULL;
10698 }
10699
10700
10701 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10702 PyObject *resultobj = 0;
10703 wxRect2D *arg1 = (wxRect2D *) 0 ;
10704 wxRect2D *arg2 = 0 ;
10705 bool result;
10706 void *argp1 = 0 ;
10707 int res1 = 0 ;
10708 wxRect2D temp2 ;
10709 PyObject * obj0 = 0 ;
10710 PyObject * obj1 = 0 ;
10711 char * kwnames[] = {
10712 (char *) "self",(char *) "rect", NULL
10713 };
10714
10715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10717 if (!SWIG_IsOK(res1)) {
10718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10719 }
10720 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10721 {
10722 arg2 = &temp2;
10723 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10724 }
10725 {
10726 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10727 if (PyErr_Occurred()) SWIG_fail;
10728 }
10729 {
10730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10731 }
10732 return resultobj;
10733 fail:
10734 return NULL;
10735 }
10736
10737
10738 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10739 PyObject *resultobj = 0;
10740 wxRect2D *arg1 = (wxRect2D *) 0 ;
10741 wxRect2D *arg2 = 0 ;
10742 void *argp1 = 0 ;
10743 int res1 = 0 ;
10744 wxRect2D temp2 ;
10745 PyObject * obj0 = 0 ;
10746 PyObject * obj1 = 0 ;
10747 char * kwnames[] = {
10748 (char *) "self",(char *) "otherRect", NULL
10749 };
10750
10751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10753 if (!SWIG_IsOK(res1)) {
10754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10755 }
10756 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10757 {
10758 arg2 = &temp2;
10759 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10760 }
10761 {
10762 (arg1)->Union((wxRect2D const &)*arg2);
10763 if (PyErr_Occurred()) SWIG_fail;
10764 }
10765 resultobj = SWIG_Py_Void();
10766 return resultobj;
10767 fail:
10768 return NULL;
10769 }
10770
10771
10772 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10773 PyObject *resultobj = 0;
10774 wxRect2D *arg1 = (wxRect2D *) 0 ;
10775 wxRect2D *arg2 = 0 ;
10776 wxRect2D result;
10777 void *argp1 = 0 ;
10778 int res1 = 0 ;
10779 wxRect2D temp2 ;
10780 PyObject * obj0 = 0 ;
10781 PyObject * obj1 = 0 ;
10782 char * kwnames[] = {
10783 (char *) "self",(char *) "otherRect", NULL
10784 };
10785
10786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10788 if (!SWIG_IsOK(res1)) {
10789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10790 }
10791 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10792 {
10793 arg2 = &temp2;
10794 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10795 }
10796 {
10797 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10798 if (PyErr_Occurred()) SWIG_fail;
10799 }
10800 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10801 return resultobj;
10802 fail:
10803 return NULL;
10804 }
10805
10806
10807 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10808 PyObject *resultobj = 0;
10809 wxRect2D *arg1 = (wxRect2D *) 0 ;
10810 wxDouble arg2 ;
10811 void *argp1 = 0 ;
10812 int res1 = 0 ;
10813 void *argp2 ;
10814 int res2 = 0 ;
10815
10816 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10818 if (!SWIG_IsOK(res1)) {
10819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10820 }
10821 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10822 {
10823 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10824 if (!SWIG_IsOK(res2)) {
10825 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10826 }
10827 if (!argp2) {
10828 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10829 } else {
10830 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10831 arg2 = *temp;
10832 if (SWIG_IsNewObj(res2)) delete temp;
10833 }
10834 }
10835 {
10836 (arg1)->Scale(arg2);
10837 if (PyErr_Occurred()) SWIG_fail;
10838 }
10839 resultobj = SWIG_Py_Void();
10840 return resultobj;
10841 fail:
10842 return NULL;
10843 }
10844
10845
10846 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10847 PyObject *resultobj = 0;
10848 wxRect2D *arg1 = (wxRect2D *) 0 ;
10849 int arg2 ;
10850 int arg3 ;
10851 void *argp1 = 0 ;
10852 int res1 = 0 ;
10853 int val2 ;
10854 int ecode2 = 0 ;
10855 int val3 ;
10856 int ecode3 = 0 ;
10857
10858 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10860 if (!SWIG_IsOK(res1)) {
10861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10862 }
10863 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10864 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10865 if (!SWIG_IsOK(ecode2)) {
10866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10867 }
10868 arg2 = static_cast< int >(val2);
10869 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10870 if (!SWIG_IsOK(ecode3)) {
10871 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10872 }
10873 arg3 = static_cast< int >(val3);
10874 {
10875 (arg1)->Scale(arg2,arg3);
10876 if (PyErr_Occurred()) SWIG_fail;
10877 }
10878 resultobj = SWIG_Py_Void();
10879 return resultobj;
10880 fail:
10881 return NULL;
10882 }
10883
10884
10885 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
10886 int argc;
10887 PyObject *argv[4];
10888
10889 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
10890 --argc;
10891 if (argc == 2) {
10892 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
10893 }
10894 if (argc == 3) {
10895 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
10896 }
10897
10898 fail:
10899 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
10900 return NULL;
10901 }
10902
10903
10904 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10905 PyObject *resultobj = 0;
10906 wxRect2D *arg1 = (wxRect2D *) 0 ;
10907 PyObject *arg2 = (PyObject *) 0 ;
10908 bool result;
10909 void *argp1 = 0 ;
10910 int res1 = 0 ;
10911 PyObject * obj0 = 0 ;
10912 PyObject * obj1 = 0 ;
10913 char * kwnames[] = {
10914 (char *) "self",(char *) "other", NULL
10915 };
10916
10917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10919 if (!SWIG_IsOK(res1)) {
10920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10921 }
10922 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10923 arg2 = obj1;
10924 {
10925 result = (bool)wxRect2D___eq__(arg1,arg2);
10926 if (PyErr_Occurred()) SWIG_fail;
10927 }
10928 {
10929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10930 }
10931 return resultobj;
10932 fail:
10933 return NULL;
10934 }
10935
10936
10937 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10938 PyObject *resultobj = 0;
10939 wxRect2D *arg1 = (wxRect2D *) 0 ;
10940 PyObject *arg2 = (PyObject *) 0 ;
10941 bool result;
10942 void *argp1 = 0 ;
10943 int res1 = 0 ;
10944 PyObject * obj0 = 0 ;
10945 PyObject * obj1 = 0 ;
10946 char * kwnames[] = {
10947 (char *) "self",(char *) "other", NULL
10948 };
10949
10950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10952 if (!SWIG_IsOK(res1)) {
10953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10954 }
10955 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10956 arg2 = obj1;
10957 {
10958 result = (bool)wxRect2D___ne__(arg1,arg2);
10959 if (PyErr_Occurred()) SWIG_fail;
10960 }
10961 {
10962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10963 }
10964 return resultobj;
10965 fail:
10966 return NULL;
10967 }
10968
10969
10970 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10971 PyObject *resultobj = 0;
10972 wxRect2D *arg1 = (wxRect2D *) 0 ;
10973 wxDouble arg2 ;
10974 void *argp1 = 0 ;
10975 int res1 = 0 ;
10976 void *argp2 ;
10977 int res2 = 0 ;
10978 PyObject *swig_obj[2] ;
10979
10980 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
10981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10982 if (!SWIG_IsOK(res1)) {
10983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
10984 }
10985 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10986 {
10987 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10988 if (!SWIG_IsOK(res2)) {
10989 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
10990 }
10991 if (!argp2) {
10992 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
10993 } else {
10994 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10995 arg2 = *temp;
10996 if (SWIG_IsNewObj(res2)) delete temp;
10997 }
10998 }
10999 if (arg1) (arg1)->m_x = arg2;
11000
11001 resultobj = SWIG_Py_Void();
11002 return resultobj;
11003 fail:
11004 return NULL;
11005 }
11006
11007
11008 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11009 PyObject *resultobj = 0;
11010 wxRect2D *arg1 = (wxRect2D *) 0 ;
11011 wxDouble result;
11012 void *argp1 = 0 ;
11013 int res1 = 0 ;
11014 PyObject *swig_obj[1] ;
11015
11016 if (!args) SWIG_fail;
11017 swig_obj[0] = args;
11018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11019 if (!SWIG_IsOK(res1)) {
11020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11021 }
11022 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11023 result = ((arg1)->m_x);
11024 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11025 return resultobj;
11026 fail:
11027 return NULL;
11028 }
11029
11030
11031 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11032 PyObject *resultobj = 0;
11033 wxRect2D *arg1 = (wxRect2D *) 0 ;
11034 wxDouble arg2 ;
11035 void *argp1 = 0 ;
11036 int res1 = 0 ;
11037 void *argp2 ;
11038 int res2 = 0 ;
11039 PyObject *swig_obj[2] ;
11040
11041 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11043 if (!SWIG_IsOK(res1)) {
11044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11045 }
11046 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11047 {
11048 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11049 if (!SWIG_IsOK(res2)) {
11050 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11051 }
11052 if (!argp2) {
11053 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11054 } else {
11055 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11056 arg2 = *temp;
11057 if (SWIG_IsNewObj(res2)) delete temp;
11058 }
11059 }
11060 if (arg1) (arg1)->m_y = arg2;
11061
11062 resultobj = SWIG_Py_Void();
11063 return resultobj;
11064 fail:
11065 return NULL;
11066 }
11067
11068
11069 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11070 PyObject *resultobj = 0;
11071 wxRect2D *arg1 = (wxRect2D *) 0 ;
11072 wxDouble result;
11073 void *argp1 = 0 ;
11074 int res1 = 0 ;
11075 PyObject *swig_obj[1] ;
11076
11077 if (!args) SWIG_fail;
11078 swig_obj[0] = args;
11079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11080 if (!SWIG_IsOK(res1)) {
11081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11082 }
11083 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11084 result = ((arg1)->m_y);
11085 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11086 return resultobj;
11087 fail:
11088 return NULL;
11089 }
11090
11091
11092 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11093 PyObject *resultobj = 0;
11094 wxRect2D *arg1 = (wxRect2D *) 0 ;
11095 wxDouble arg2 ;
11096 void *argp1 = 0 ;
11097 int res1 = 0 ;
11098 void *argp2 ;
11099 int res2 = 0 ;
11100 PyObject *swig_obj[2] ;
11101
11102 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11104 if (!SWIG_IsOK(res1)) {
11105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11106 }
11107 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11108 {
11109 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11110 if (!SWIG_IsOK(res2)) {
11111 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11112 }
11113 if (!argp2) {
11114 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11115 } else {
11116 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11117 arg2 = *temp;
11118 if (SWIG_IsNewObj(res2)) delete temp;
11119 }
11120 }
11121 if (arg1) (arg1)->m_width = arg2;
11122
11123 resultobj = SWIG_Py_Void();
11124 return resultobj;
11125 fail:
11126 return NULL;
11127 }
11128
11129
11130 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11131 PyObject *resultobj = 0;
11132 wxRect2D *arg1 = (wxRect2D *) 0 ;
11133 wxDouble result;
11134 void *argp1 = 0 ;
11135 int res1 = 0 ;
11136 PyObject *swig_obj[1] ;
11137
11138 if (!args) SWIG_fail;
11139 swig_obj[0] = args;
11140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11141 if (!SWIG_IsOK(res1)) {
11142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11143 }
11144 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11145 result = ((arg1)->m_width);
11146 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11147 return resultobj;
11148 fail:
11149 return NULL;
11150 }
11151
11152
11153 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11154 PyObject *resultobj = 0;
11155 wxRect2D *arg1 = (wxRect2D *) 0 ;
11156 wxDouble arg2 ;
11157 void *argp1 = 0 ;
11158 int res1 = 0 ;
11159 void *argp2 ;
11160 int res2 = 0 ;
11161 PyObject *swig_obj[2] ;
11162
11163 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11165 if (!SWIG_IsOK(res1)) {
11166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11167 }
11168 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11169 {
11170 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11171 if (!SWIG_IsOK(res2)) {
11172 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11173 }
11174 if (!argp2) {
11175 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11176 } else {
11177 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11178 arg2 = *temp;
11179 if (SWIG_IsNewObj(res2)) delete temp;
11180 }
11181 }
11182 if (arg1) (arg1)->m_height = arg2;
11183
11184 resultobj = SWIG_Py_Void();
11185 return resultobj;
11186 fail:
11187 return NULL;
11188 }
11189
11190
11191 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11192 PyObject *resultobj = 0;
11193 wxRect2D *arg1 = (wxRect2D *) 0 ;
11194 wxDouble result;
11195 void *argp1 = 0 ;
11196 int res1 = 0 ;
11197 PyObject *swig_obj[1] ;
11198
11199 if (!args) SWIG_fail;
11200 swig_obj[0] = args;
11201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11202 if (!SWIG_IsOK(res1)) {
11203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11204 }
11205 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11206 result = ((arg1)->m_height);
11207 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11208 return resultobj;
11209 fail:
11210 return NULL;
11211 }
11212
11213
11214 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11215 PyObject *resultobj = 0;
11216 wxRect2D *arg1 = (wxRect2D *) 0 ;
11217 wxDouble arg2 = (wxDouble) 0 ;
11218 wxDouble arg3 = (wxDouble) 0 ;
11219 wxDouble arg4 = (wxDouble) 0 ;
11220 wxDouble arg5 = (wxDouble) 0 ;
11221 void *argp1 = 0 ;
11222 int res1 = 0 ;
11223 void *argp2 ;
11224 int res2 = 0 ;
11225 void *argp3 ;
11226 int res3 = 0 ;
11227 void *argp4 ;
11228 int res4 = 0 ;
11229 void *argp5 ;
11230 int res5 = 0 ;
11231 PyObject * obj0 = 0 ;
11232 PyObject * obj1 = 0 ;
11233 PyObject * obj2 = 0 ;
11234 PyObject * obj3 = 0 ;
11235 PyObject * obj4 = 0 ;
11236 char * kwnames[] = {
11237 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11238 };
11239
11240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11242 if (!SWIG_IsOK(res1)) {
11243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11244 }
11245 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11246 if (obj1) {
11247 {
11248 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11249 if (!SWIG_IsOK(res2)) {
11250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11251 }
11252 if (!argp2) {
11253 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11254 } else {
11255 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11256 arg2 = *temp;
11257 if (SWIG_IsNewObj(res2)) delete temp;
11258 }
11259 }
11260 }
11261 if (obj2) {
11262 {
11263 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11264 if (!SWIG_IsOK(res3)) {
11265 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11266 }
11267 if (!argp3) {
11268 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11269 } else {
11270 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11271 arg3 = *temp;
11272 if (SWIG_IsNewObj(res3)) delete temp;
11273 }
11274 }
11275 }
11276 if (obj3) {
11277 {
11278 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11279 if (!SWIG_IsOK(res4)) {
11280 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11281 }
11282 if (!argp4) {
11283 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11284 } else {
11285 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11286 arg4 = *temp;
11287 if (SWIG_IsNewObj(res4)) delete temp;
11288 }
11289 }
11290 }
11291 if (obj4) {
11292 {
11293 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11294 if (!SWIG_IsOK(res5)) {
11295 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11296 }
11297 if (!argp5) {
11298 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11299 } else {
11300 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11301 arg5 = *temp;
11302 if (SWIG_IsNewObj(res5)) delete temp;
11303 }
11304 }
11305 }
11306 {
11307 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11308 if (PyErr_Occurred()) SWIG_fail;
11309 }
11310 resultobj = SWIG_Py_Void();
11311 return resultobj;
11312 fail:
11313 return NULL;
11314 }
11315
11316
11317 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11318 PyObject *resultobj = 0;
11319 wxRect2D *arg1 = (wxRect2D *) 0 ;
11320 PyObject *result = 0 ;
11321 void *argp1 = 0 ;
11322 int res1 = 0 ;
11323 PyObject *swig_obj[1] ;
11324
11325 if (!args) SWIG_fail;
11326 swig_obj[0] = args;
11327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11328 if (!SWIG_IsOK(res1)) {
11329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11330 }
11331 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11332 {
11333 result = (PyObject *)wxRect2D_Get(arg1);
11334 if (PyErr_Occurred()) SWIG_fail;
11335 }
11336 resultobj = result;
11337 return resultobj;
11338 fail:
11339 return NULL;
11340 }
11341
11342
11343 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11344 PyObject *obj;
11345 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11346 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11347 return SWIG_Py_Void();
11348 }
11349
11350 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11351 return SWIG_Python_InitShadowInstance(args);
11352 }
11353
11354 SWIGINTERN int DefaultPosition_set(PyObject *) {
11355 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11356 return 1;
11357 }
11358
11359
11360 SWIGINTERN PyObject *DefaultPosition_get(void) {
11361 PyObject *pyobj = 0;
11362
11363 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11364 return pyobj;
11365 }
11366
11367
11368 SWIGINTERN int DefaultSize_set(PyObject *) {
11369 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11370 return 1;
11371 }
11372
11373
11374 SWIGINTERN PyObject *DefaultSize_get(void) {
11375 PyObject *pyobj = 0;
11376
11377 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11378 return pyobj;
11379 }
11380
11381
11382 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11383 PyObject *resultobj = 0;
11384 PyObject *arg1 = (PyObject *) 0 ;
11385 wxPyInputStream *result = 0 ;
11386 PyObject * obj0 = 0 ;
11387 char * kwnames[] = {
11388 (char *) "p", NULL
11389 };
11390
11391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11392 arg1 = obj0;
11393 {
11394 PyThreadState* __tstate = wxPyBeginAllowThreads();
11395 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11396 wxPyEndAllowThreads(__tstate);
11397 if (PyErr_Occurred()) SWIG_fail;
11398 }
11399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11400 return resultobj;
11401 fail:
11402 return NULL;
11403 }
11404
11405
11406 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11407 PyObject *resultobj = 0;
11408 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11409 void *argp1 = 0 ;
11410 int res1 = 0 ;
11411 PyObject *swig_obj[1] ;
11412
11413 if (!args) SWIG_fail;
11414 swig_obj[0] = args;
11415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
11416 if (!SWIG_IsOK(res1)) {
11417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11418 }
11419 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11420 {
11421 PyThreadState* __tstate = wxPyBeginAllowThreads();
11422 delete arg1;
11423
11424 wxPyEndAllowThreads(__tstate);
11425 if (PyErr_Occurred()) SWIG_fail;
11426 }
11427 resultobj = SWIG_Py_Void();
11428 return resultobj;
11429 fail:
11430 return NULL;
11431 }
11432
11433
11434 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11435 PyObject *resultobj = 0;
11436 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11437 void *argp1 = 0 ;
11438 int res1 = 0 ;
11439 PyObject *swig_obj[1] ;
11440
11441 if (!args) SWIG_fail;
11442 swig_obj[0] = args;
11443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11444 if (!SWIG_IsOK(res1)) {
11445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11446 }
11447 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11448 {
11449 PyThreadState* __tstate = wxPyBeginAllowThreads();
11450 (arg1)->close();
11451 wxPyEndAllowThreads(__tstate);
11452 if (PyErr_Occurred()) SWIG_fail;
11453 }
11454 resultobj = SWIG_Py_Void();
11455 return resultobj;
11456 fail:
11457 return NULL;
11458 }
11459
11460
11461 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11462 PyObject *resultobj = 0;
11463 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11464 void *argp1 = 0 ;
11465 int res1 = 0 ;
11466 PyObject *swig_obj[1] ;
11467
11468 if (!args) SWIG_fail;
11469 swig_obj[0] = args;
11470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11471 if (!SWIG_IsOK(res1)) {
11472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11473 }
11474 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11475 {
11476 PyThreadState* __tstate = wxPyBeginAllowThreads();
11477 (arg1)->flush();
11478 wxPyEndAllowThreads(__tstate);
11479 if (PyErr_Occurred()) SWIG_fail;
11480 }
11481 resultobj = SWIG_Py_Void();
11482 return resultobj;
11483 fail:
11484 return NULL;
11485 }
11486
11487
11488 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11489 PyObject *resultobj = 0;
11490 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11491 bool result;
11492 void *argp1 = 0 ;
11493 int res1 = 0 ;
11494 PyObject *swig_obj[1] ;
11495
11496 if (!args) SWIG_fail;
11497 swig_obj[0] = args;
11498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11499 if (!SWIG_IsOK(res1)) {
11500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11501 }
11502 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11503 {
11504 PyThreadState* __tstate = wxPyBeginAllowThreads();
11505 result = (bool)(arg1)->eof();
11506 wxPyEndAllowThreads(__tstate);
11507 if (PyErr_Occurred()) SWIG_fail;
11508 }
11509 {
11510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11511 }
11512 return resultobj;
11513 fail:
11514 return NULL;
11515 }
11516
11517
11518 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11519 PyObject *resultobj = 0;
11520 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11521 int arg2 = (int) -1 ;
11522 PyObject *result = 0 ;
11523 void *argp1 = 0 ;
11524 int res1 = 0 ;
11525 int val2 ;
11526 int ecode2 = 0 ;
11527 PyObject * obj0 = 0 ;
11528 PyObject * obj1 = 0 ;
11529 char * kwnames[] = {
11530 (char *) "self",(char *) "size", NULL
11531 };
11532
11533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11535 if (!SWIG_IsOK(res1)) {
11536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11537 }
11538 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11539 if (obj1) {
11540 ecode2 = SWIG_AsVal_int(obj1, &val2);
11541 if (!SWIG_IsOK(ecode2)) {
11542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11543 }
11544 arg2 = static_cast< int >(val2);
11545 }
11546 {
11547 PyThreadState* __tstate = wxPyBeginAllowThreads();
11548 result = (PyObject *)(arg1)->read(arg2);
11549 wxPyEndAllowThreads(__tstate);
11550 if (PyErr_Occurred()) SWIG_fail;
11551 }
11552 resultobj = result;
11553 return resultobj;
11554 fail:
11555 return NULL;
11556 }
11557
11558
11559 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11560 PyObject *resultobj = 0;
11561 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11562 int arg2 = (int) -1 ;
11563 PyObject *result = 0 ;
11564 void *argp1 = 0 ;
11565 int res1 = 0 ;
11566 int val2 ;
11567 int ecode2 = 0 ;
11568 PyObject * obj0 = 0 ;
11569 PyObject * obj1 = 0 ;
11570 char * kwnames[] = {
11571 (char *) "self",(char *) "size", NULL
11572 };
11573
11574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11576 if (!SWIG_IsOK(res1)) {
11577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11578 }
11579 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11580 if (obj1) {
11581 ecode2 = SWIG_AsVal_int(obj1, &val2);
11582 if (!SWIG_IsOK(ecode2)) {
11583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11584 }
11585 arg2 = static_cast< int >(val2);
11586 }
11587 {
11588 PyThreadState* __tstate = wxPyBeginAllowThreads();
11589 result = (PyObject *)(arg1)->readline(arg2);
11590 wxPyEndAllowThreads(__tstate);
11591 if (PyErr_Occurred()) SWIG_fail;
11592 }
11593 resultobj = result;
11594 return resultobj;
11595 fail:
11596 return NULL;
11597 }
11598
11599
11600 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11601 PyObject *resultobj = 0;
11602 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11603 int arg2 = (int) -1 ;
11604 PyObject *result = 0 ;
11605 void *argp1 = 0 ;
11606 int res1 = 0 ;
11607 int val2 ;
11608 int ecode2 = 0 ;
11609 PyObject * obj0 = 0 ;
11610 PyObject * obj1 = 0 ;
11611 char * kwnames[] = {
11612 (char *) "self",(char *) "sizehint", NULL
11613 };
11614
11615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11617 if (!SWIG_IsOK(res1)) {
11618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11619 }
11620 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11621 if (obj1) {
11622 ecode2 = SWIG_AsVal_int(obj1, &val2);
11623 if (!SWIG_IsOK(ecode2)) {
11624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11625 }
11626 arg2 = static_cast< int >(val2);
11627 }
11628 {
11629 PyThreadState* __tstate = wxPyBeginAllowThreads();
11630 result = (PyObject *)(arg1)->readlines(arg2);
11631 wxPyEndAllowThreads(__tstate);
11632 if (PyErr_Occurred()) SWIG_fail;
11633 }
11634 resultobj = result;
11635 return resultobj;
11636 fail:
11637 return NULL;
11638 }
11639
11640
11641 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11642 PyObject *resultobj = 0;
11643 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11644 int arg2 ;
11645 int arg3 = (int) 0 ;
11646 void *argp1 = 0 ;
11647 int res1 = 0 ;
11648 int val2 ;
11649 int ecode2 = 0 ;
11650 int val3 ;
11651 int ecode3 = 0 ;
11652 PyObject * obj0 = 0 ;
11653 PyObject * obj1 = 0 ;
11654 PyObject * obj2 = 0 ;
11655 char * kwnames[] = {
11656 (char *) "self",(char *) "offset",(char *) "whence", NULL
11657 };
11658
11659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11661 if (!SWIG_IsOK(res1)) {
11662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11663 }
11664 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11665 ecode2 = SWIG_AsVal_int(obj1, &val2);
11666 if (!SWIG_IsOK(ecode2)) {
11667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11668 }
11669 arg2 = static_cast< int >(val2);
11670 if (obj2) {
11671 ecode3 = SWIG_AsVal_int(obj2, &val3);
11672 if (!SWIG_IsOK(ecode3)) {
11673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11674 }
11675 arg3 = static_cast< int >(val3);
11676 }
11677 {
11678 PyThreadState* __tstate = wxPyBeginAllowThreads();
11679 (arg1)->seek(arg2,arg3);
11680 wxPyEndAllowThreads(__tstate);
11681 if (PyErr_Occurred()) SWIG_fail;
11682 }
11683 resultobj = SWIG_Py_Void();
11684 return resultobj;
11685 fail:
11686 return NULL;
11687 }
11688
11689
11690 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11691 PyObject *resultobj = 0;
11692 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11693 int result;
11694 void *argp1 = 0 ;
11695 int res1 = 0 ;
11696 PyObject *swig_obj[1] ;
11697
11698 if (!args) SWIG_fail;
11699 swig_obj[0] = args;
11700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11701 if (!SWIG_IsOK(res1)) {
11702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11703 }
11704 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11705 {
11706 PyThreadState* __tstate = wxPyBeginAllowThreads();
11707 result = (int)(arg1)->tell();
11708 wxPyEndAllowThreads(__tstate);
11709 if (PyErr_Occurred()) SWIG_fail;
11710 }
11711 resultobj = SWIG_From_int(static_cast< int >(result));
11712 return resultobj;
11713 fail:
11714 return NULL;
11715 }
11716
11717
11718 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11719 PyObject *resultobj = 0;
11720 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11721 char result;
11722 void *argp1 = 0 ;
11723 int res1 = 0 ;
11724 PyObject *swig_obj[1] ;
11725
11726 if (!args) SWIG_fail;
11727 swig_obj[0] = args;
11728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11729 if (!SWIG_IsOK(res1)) {
11730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11731 }
11732 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11733 {
11734 PyThreadState* __tstate = wxPyBeginAllowThreads();
11735 result = (char)(arg1)->Peek();
11736 wxPyEndAllowThreads(__tstate);
11737 if (PyErr_Occurred()) SWIG_fail;
11738 }
11739 resultobj = SWIG_From_char(static_cast< char >(result));
11740 return resultobj;
11741 fail:
11742 return NULL;
11743 }
11744
11745
11746 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11747 PyObject *resultobj = 0;
11748 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11749 char result;
11750 void *argp1 = 0 ;
11751 int res1 = 0 ;
11752 PyObject *swig_obj[1] ;
11753
11754 if (!args) SWIG_fail;
11755 swig_obj[0] = args;
11756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11757 if (!SWIG_IsOK(res1)) {
11758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11759 }
11760 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11761 {
11762 PyThreadState* __tstate = wxPyBeginAllowThreads();
11763 result = (char)(arg1)->GetC();
11764 wxPyEndAllowThreads(__tstate);
11765 if (PyErr_Occurred()) SWIG_fail;
11766 }
11767 resultobj = SWIG_From_char(static_cast< char >(result));
11768 return resultobj;
11769 fail:
11770 return NULL;
11771 }
11772
11773
11774 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11775 PyObject *resultobj = 0;
11776 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11777 size_t result;
11778 void *argp1 = 0 ;
11779 int res1 = 0 ;
11780 PyObject *swig_obj[1] ;
11781
11782 if (!args) SWIG_fail;
11783 swig_obj[0] = args;
11784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11785 if (!SWIG_IsOK(res1)) {
11786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11787 }
11788 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11789 {
11790 PyThreadState* __tstate = wxPyBeginAllowThreads();
11791 result = (size_t)(arg1)->LastRead();
11792 wxPyEndAllowThreads(__tstate);
11793 if (PyErr_Occurred()) SWIG_fail;
11794 }
11795 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11796 return resultobj;
11797 fail:
11798 return NULL;
11799 }
11800
11801
11802 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11803 PyObject *resultobj = 0;
11804 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11805 bool result;
11806 void *argp1 = 0 ;
11807 int res1 = 0 ;
11808 PyObject *swig_obj[1] ;
11809
11810 if (!args) SWIG_fail;
11811 swig_obj[0] = args;
11812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11813 if (!SWIG_IsOK(res1)) {
11814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11815 }
11816 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11817 {
11818 PyThreadState* __tstate = wxPyBeginAllowThreads();
11819 result = (bool)(arg1)->CanRead();
11820 wxPyEndAllowThreads(__tstate);
11821 if (PyErr_Occurred()) SWIG_fail;
11822 }
11823 {
11824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11825 }
11826 return resultobj;
11827 fail:
11828 return NULL;
11829 }
11830
11831
11832 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11833 PyObject *resultobj = 0;
11834 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11835 bool result;
11836 void *argp1 = 0 ;
11837 int res1 = 0 ;
11838 PyObject *swig_obj[1] ;
11839
11840 if (!args) SWIG_fail;
11841 swig_obj[0] = args;
11842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11843 if (!SWIG_IsOK(res1)) {
11844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11845 }
11846 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11847 {
11848 PyThreadState* __tstate = wxPyBeginAllowThreads();
11849 result = (bool)(arg1)->Eof();
11850 wxPyEndAllowThreads(__tstate);
11851 if (PyErr_Occurred()) SWIG_fail;
11852 }
11853 {
11854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11855 }
11856 return resultobj;
11857 fail:
11858 return NULL;
11859 }
11860
11861
11862 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11863 PyObject *resultobj = 0;
11864 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11865 char arg2 ;
11866 bool result;
11867 void *argp1 = 0 ;
11868 int res1 = 0 ;
11869 char val2 ;
11870 int ecode2 = 0 ;
11871 PyObject * obj0 = 0 ;
11872 PyObject * obj1 = 0 ;
11873 char * kwnames[] = {
11874 (char *) "self",(char *) "c", NULL
11875 };
11876
11877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11879 if (!SWIG_IsOK(res1)) {
11880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11881 }
11882 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11883 ecode2 = SWIG_AsVal_char(obj1, &val2);
11884 if (!SWIG_IsOK(ecode2)) {
11885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
11886 }
11887 arg2 = static_cast< char >(val2);
11888 {
11889 PyThreadState* __tstate = wxPyBeginAllowThreads();
11890 result = (bool)(arg1)->Ungetch(arg2);
11891 wxPyEndAllowThreads(__tstate);
11892 if (PyErr_Occurred()) SWIG_fail;
11893 }
11894 {
11895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11896 }
11897 return resultobj;
11898 fail:
11899 return NULL;
11900 }
11901
11902
11903 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11904 PyObject *resultobj = 0;
11905 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11906 long arg2 ;
11907 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
11908 long result;
11909 void *argp1 = 0 ;
11910 int res1 = 0 ;
11911 long val2 ;
11912 int ecode2 = 0 ;
11913 int val3 ;
11914 int ecode3 = 0 ;
11915 PyObject * obj0 = 0 ;
11916 PyObject * obj1 = 0 ;
11917 PyObject * obj2 = 0 ;
11918 char * kwnames[] = {
11919 (char *) "self",(char *) "pos",(char *) "mode", NULL
11920 };
11921
11922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11924 if (!SWIG_IsOK(res1)) {
11925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11926 }
11927 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11928 ecode2 = SWIG_AsVal_long(obj1, &val2);
11929 if (!SWIG_IsOK(ecode2)) {
11930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
11931 }
11932 arg2 = static_cast< long >(val2);
11933 if (obj2) {
11934 ecode3 = SWIG_AsVal_int(obj2, &val3);
11935 if (!SWIG_IsOK(ecode3)) {
11936 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
11937 }
11938 arg3 = static_cast< wxSeekMode >(val3);
11939 }
11940 {
11941 PyThreadState* __tstate = wxPyBeginAllowThreads();
11942 result = (long)(arg1)->SeekI(arg2,arg3);
11943 wxPyEndAllowThreads(__tstate);
11944 if (PyErr_Occurred()) SWIG_fail;
11945 }
11946 resultobj = SWIG_From_long(static_cast< long >(result));
11947 return resultobj;
11948 fail:
11949 return NULL;
11950 }
11951
11952
11953 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11954 PyObject *resultobj = 0;
11955 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11956 long result;
11957 void *argp1 = 0 ;
11958 int res1 = 0 ;
11959 PyObject *swig_obj[1] ;
11960
11961 if (!args) SWIG_fail;
11962 swig_obj[0] = args;
11963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11964 if (!SWIG_IsOK(res1)) {
11965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11966 }
11967 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11968 {
11969 PyThreadState* __tstate = wxPyBeginAllowThreads();
11970 result = (long)(arg1)->TellI();
11971 wxPyEndAllowThreads(__tstate);
11972 if (PyErr_Occurred()) SWIG_fail;
11973 }
11974 resultobj = SWIG_From_long(static_cast< long >(result));
11975 return resultobj;
11976 fail:
11977 return NULL;
11978 }
11979
11980
11981 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11982 PyObject *obj;
11983 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11984 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
11985 return SWIG_Py_Void();
11986 }
11987
11988 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11989 return SWIG_Python_InitShadowInstance(args);
11990 }
11991
11992 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11993 PyObject *resultobj = 0;
11994 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
11995 PyObject *arg2 = (PyObject *) 0 ;
11996 void *argp1 = 0 ;
11997 int res1 = 0 ;
11998 PyObject * obj0 = 0 ;
11999 PyObject * obj1 = 0 ;
12000 char * kwnames[] = {
12001 (char *) "self",(char *) "obj", NULL
12002 };
12003
12004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12006 if (!SWIG_IsOK(res1)) {
12007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12008 }
12009 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12010 arg2 = obj1;
12011 {
12012 PyThreadState* __tstate = wxPyBeginAllowThreads();
12013 wxOutputStream_write(arg1,arg2);
12014 wxPyEndAllowThreads(__tstate);
12015 if (PyErr_Occurred()) SWIG_fail;
12016 }
12017 resultobj = SWIG_Py_Void();
12018 return resultobj;
12019 fail:
12020 return NULL;
12021 }
12022
12023
12024 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12025 PyObject *resultobj = 0;
12026 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12027 size_t result;
12028 void *argp1 = 0 ;
12029 int res1 = 0 ;
12030 PyObject *swig_obj[1] ;
12031
12032 if (!args) SWIG_fail;
12033 swig_obj[0] = args;
12034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12035 if (!SWIG_IsOK(res1)) {
12036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12037 }
12038 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12039 {
12040 PyThreadState* __tstate = wxPyBeginAllowThreads();
12041 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12042 wxPyEndAllowThreads(__tstate);
12043 if (PyErr_Occurred()) SWIG_fail;
12044 }
12045 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12046 return resultobj;
12047 fail:
12048 return NULL;
12049 }
12050
12051
12052 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12053 PyObject *obj;
12054 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12055 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12056 return SWIG_Py_Void();
12057 }
12058
12059 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12060 PyObject *resultobj = 0;
12061 wxInputStream *arg1 = (wxInputStream *) 0 ;
12062 wxString *arg2 = 0 ;
12063 wxString *arg3 = 0 ;
12064 wxString *arg4 = 0 ;
12065 wxDateTime arg5 ;
12066 wxFSFile *result = 0 ;
12067 wxPyInputStream *temp1 ;
12068 bool temp2 = false ;
12069 bool temp3 = false ;
12070 bool temp4 = false ;
12071 void *argp5 ;
12072 int res5 = 0 ;
12073 PyObject * obj0 = 0 ;
12074 PyObject * obj1 = 0 ;
12075 PyObject * obj2 = 0 ;
12076 PyObject * obj3 = 0 ;
12077 PyObject * obj4 = 0 ;
12078 char * kwnames[] = {
12079 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12080 };
12081
12082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12083 {
12084 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12085 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12086 } else {
12087 PyErr_Clear(); // clear the failure of the wxPyConvert above
12088 arg1 = wxPyCBInputStream_create(obj0, true);
12089 if (arg1 == NULL) {
12090 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12091 SWIG_fail;
12092 }
12093 }
12094 }
12095 {
12096 arg2 = wxString_in_helper(obj1);
12097 if (arg2 == NULL) SWIG_fail;
12098 temp2 = true;
12099 }
12100 {
12101 arg3 = wxString_in_helper(obj2);
12102 if (arg3 == NULL) SWIG_fail;
12103 temp3 = true;
12104 }
12105 {
12106 arg4 = wxString_in_helper(obj3);
12107 if (arg4 == NULL) SWIG_fail;
12108 temp4 = true;
12109 }
12110 {
12111 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12112 if (!SWIG_IsOK(res5)) {
12113 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12114 }
12115 if (!argp5) {
12116 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12117 } else {
12118 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12119 arg5 = *temp;
12120 if (SWIG_IsNewObj(res5)) delete temp;
12121 }
12122 }
12123 {
12124 PyThreadState* __tstate = wxPyBeginAllowThreads();
12125 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12126 wxPyEndAllowThreads(__tstate);
12127 if (PyErr_Occurred()) SWIG_fail;
12128 }
12129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12130 {
12131 if (temp2)
12132 delete arg2;
12133 }
12134 {
12135 if (temp3)
12136 delete arg3;
12137 }
12138 {
12139 if (temp4)
12140 delete arg4;
12141 }
12142 return resultobj;
12143 fail:
12144 {
12145 if (temp2)
12146 delete arg2;
12147 }
12148 {
12149 if (temp3)
12150 delete arg3;
12151 }
12152 {
12153 if (temp4)
12154 delete arg4;
12155 }
12156 return NULL;
12157 }
12158
12159
12160 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12161 PyObject *resultobj = 0;
12162 wxFSFile *arg1 = (wxFSFile *) 0 ;
12163 void *argp1 = 0 ;
12164 int res1 = 0 ;
12165 PyObject *swig_obj[1] ;
12166
12167 if (!args) SWIG_fail;
12168 swig_obj[0] = args;
12169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12170 if (!SWIG_IsOK(res1)) {
12171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12172 }
12173 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12174 {
12175 PyThreadState* __tstate = wxPyBeginAllowThreads();
12176 delete arg1;
12177
12178 wxPyEndAllowThreads(__tstate);
12179 if (PyErr_Occurred()) SWIG_fail;
12180 }
12181 resultobj = SWIG_Py_Void();
12182 return resultobj;
12183 fail:
12184 return NULL;
12185 }
12186
12187
12188 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12189 PyObject *resultobj = 0;
12190 wxFSFile *arg1 = (wxFSFile *) 0 ;
12191 wxInputStream *result = 0 ;
12192 void *argp1 = 0 ;
12193 int res1 = 0 ;
12194 PyObject *swig_obj[1] ;
12195
12196 if (!args) SWIG_fail;
12197 swig_obj[0] = args;
12198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12199 if (!SWIG_IsOK(res1)) {
12200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12201 }
12202 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12203 {
12204 PyThreadState* __tstate = wxPyBeginAllowThreads();
12205 result = (wxInputStream *)(arg1)->GetStream();
12206 wxPyEndAllowThreads(__tstate);
12207 if (PyErr_Occurred()) SWIG_fail;
12208 }
12209 {
12210 wxPyInputStream * _ptr = NULL;
12211
12212 if (result) {
12213 _ptr = new wxPyInputStream(result);
12214 }
12215 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12216 }
12217 return resultobj;
12218 fail:
12219 return NULL;
12220 }
12221
12222
12223 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12224 PyObject *resultobj = 0;
12225 wxFSFile *arg1 = (wxFSFile *) 0 ;
12226 void *argp1 = 0 ;
12227 int res1 = 0 ;
12228 PyObject *swig_obj[1] ;
12229
12230 if (!args) SWIG_fail;
12231 swig_obj[0] = args;
12232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12233 if (!SWIG_IsOK(res1)) {
12234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12235 }
12236 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12237 {
12238 PyThreadState* __tstate = wxPyBeginAllowThreads();
12239 (arg1)->DetachStream();
12240 wxPyEndAllowThreads(__tstate);
12241 if (PyErr_Occurred()) SWIG_fail;
12242 }
12243 resultobj = SWIG_Py_Void();
12244 return resultobj;
12245 fail:
12246 return NULL;
12247 }
12248
12249
12250 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12251 PyObject *resultobj = 0;
12252 wxFSFile *arg1 = (wxFSFile *) 0 ;
12253 wxString *result = 0 ;
12254 void *argp1 = 0 ;
12255 int res1 = 0 ;
12256 PyObject *swig_obj[1] ;
12257
12258 if (!args) SWIG_fail;
12259 swig_obj[0] = args;
12260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12261 if (!SWIG_IsOK(res1)) {
12262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12263 }
12264 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12265 {
12266 PyThreadState* __tstate = wxPyBeginAllowThreads();
12267 {
12268 wxString const &_result_ref = (arg1)->GetMimeType();
12269 result = (wxString *) &_result_ref;
12270 }
12271 wxPyEndAllowThreads(__tstate);
12272 if (PyErr_Occurred()) SWIG_fail;
12273 }
12274 {
12275 #if wxUSE_UNICODE
12276 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12277 #else
12278 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12279 #endif
12280 }
12281 return resultobj;
12282 fail:
12283 return NULL;
12284 }
12285
12286
12287 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12288 PyObject *resultobj = 0;
12289 wxFSFile *arg1 = (wxFSFile *) 0 ;
12290 wxString *result = 0 ;
12291 void *argp1 = 0 ;
12292 int res1 = 0 ;
12293 PyObject *swig_obj[1] ;
12294
12295 if (!args) SWIG_fail;
12296 swig_obj[0] = args;
12297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12298 if (!SWIG_IsOK(res1)) {
12299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12300 }
12301 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12302 {
12303 PyThreadState* __tstate = wxPyBeginAllowThreads();
12304 {
12305 wxString const &_result_ref = (arg1)->GetLocation();
12306 result = (wxString *) &_result_ref;
12307 }
12308 wxPyEndAllowThreads(__tstate);
12309 if (PyErr_Occurred()) SWIG_fail;
12310 }
12311 {
12312 #if wxUSE_UNICODE
12313 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12314 #else
12315 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12316 #endif
12317 }
12318 return resultobj;
12319 fail:
12320 return NULL;
12321 }
12322
12323
12324 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12325 PyObject *resultobj = 0;
12326 wxFSFile *arg1 = (wxFSFile *) 0 ;
12327 wxString *result = 0 ;
12328 void *argp1 = 0 ;
12329 int res1 = 0 ;
12330 PyObject *swig_obj[1] ;
12331
12332 if (!args) SWIG_fail;
12333 swig_obj[0] = args;
12334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12335 if (!SWIG_IsOK(res1)) {
12336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12337 }
12338 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12339 {
12340 PyThreadState* __tstate = wxPyBeginAllowThreads();
12341 {
12342 wxString const &_result_ref = (arg1)->GetAnchor();
12343 result = (wxString *) &_result_ref;
12344 }
12345 wxPyEndAllowThreads(__tstate);
12346 if (PyErr_Occurred()) SWIG_fail;
12347 }
12348 {
12349 #if wxUSE_UNICODE
12350 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12351 #else
12352 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12353 #endif
12354 }
12355 return resultobj;
12356 fail:
12357 return NULL;
12358 }
12359
12360
12361 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12362 PyObject *resultobj = 0;
12363 wxFSFile *arg1 = (wxFSFile *) 0 ;
12364 wxDateTime result;
12365 void *argp1 = 0 ;
12366 int res1 = 0 ;
12367 PyObject *swig_obj[1] ;
12368
12369 if (!args) SWIG_fail;
12370 swig_obj[0] = args;
12371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12372 if (!SWIG_IsOK(res1)) {
12373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12374 }
12375 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12376 {
12377 PyThreadState* __tstate = wxPyBeginAllowThreads();
12378 result = (arg1)->GetModificationTime();
12379 wxPyEndAllowThreads(__tstate);
12380 if (PyErr_Occurred()) SWIG_fail;
12381 }
12382 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12383 return resultobj;
12384 fail:
12385 return NULL;
12386 }
12387
12388
12389 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12390 PyObject *obj;
12391 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12392 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12393 return SWIG_Py_Void();
12394 }
12395
12396 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12397 return SWIG_Python_InitShadowInstance(args);
12398 }
12399
12400 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12401 PyObject *resultobj = 0;
12402 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12403 void *argp1 = 0 ;
12404 int res1 = 0 ;
12405 PyObject *swig_obj[1] ;
12406
12407 if (!args) SWIG_fail;
12408 swig_obj[0] = args;
12409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12410 if (!SWIG_IsOK(res1)) {
12411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12412 }
12413 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12414 {
12415 PyThreadState* __tstate = wxPyBeginAllowThreads();
12416 delete arg1;
12417
12418 wxPyEndAllowThreads(__tstate);
12419 if (PyErr_Occurred()) SWIG_fail;
12420 }
12421 resultobj = SWIG_Py_Void();
12422 return resultobj;
12423 fail:
12424 return NULL;
12425 }
12426
12427
12428 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12429 PyObject *obj;
12430 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12431 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12432 return SWIG_Py_Void();
12433 }
12434
12435 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12436 PyObject *resultobj = 0;
12437 wxPyFileSystemHandler *result = 0 ;
12438
12439 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12440 {
12441 PyThreadState* __tstate = wxPyBeginAllowThreads();
12442 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12443 wxPyEndAllowThreads(__tstate);
12444 if (PyErr_Occurred()) SWIG_fail;
12445 }
12446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12447 return resultobj;
12448 fail:
12449 return NULL;
12450 }
12451
12452
12453 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12454 PyObject *resultobj = 0;
12455 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12456 PyObject *arg2 = (PyObject *) 0 ;
12457 PyObject *arg3 = (PyObject *) 0 ;
12458 void *argp1 = 0 ;
12459 int res1 = 0 ;
12460 PyObject * obj0 = 0 ;
12461 PyObject * obj1 = 0 ;
12462 PyObject * obj2 = 0 ;
12463 char * kwnames[] = {
12464 (char *) "self",(char *) "self",(char *) "_class", NULL
12465 };
12466
12467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12469 if (!SWIG_IsOK(res1)) {
12470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12471 }
12472 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12473 arg2 = obj1;
12474 arg3 = obj2;
12475 {
12476 PyThreadState* __tstate = wxPyBeginAllowThreads();
12477 (arg1)->_setCallbackInfo(arg2,arg3);
12478 wxPyEndAllowThreads(__tstate);
12479 if (PyErr_Occurred()) SWIG_fail;
12480 }
12481 resultobj = SWIG_Py_Void();
12482 return resultobj;
12483 fail:
12484 return NULL;
12485 }
12486
12487
12488 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12489 PyObject *resultobj = 0;
12490 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12491 wxString *arg2 = 0 ;
12492 bool result;
12493 void *argp1 = 0 ;
12494 int res1 = 0 ;
12495 bool temp2 = false ;
12496 PyObject * obj0 = 0 ;
12497 PyObject * obj1 = 0 ;
12498 char * kwnames[] = {
12499 (char *) "self",(char *) "location", NULL
12500 };
12501
12502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12504 if (!SWIG_IsOK(res1)) {
12505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12506 }
12507 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12508 {
12509 arg2 = wxString_in_helper(obj1);
12510 if (arg2 == NULL) SWIG_fail;
12511 temp2 = true;
12512 }
12513 {
12514 PyThreadState* __tstate = wxPyBeginAllowThreads();
12515 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12516 wxPyEndAllowThreads(__tstate);
12517 if (PyErr_Occurred()) SWIG_fail;
12518 }
12519 {
12520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12521 }
12522 {
12523 if (temp2)
12524 delete arg2;
12525 }
12526 return resultobj;
12527 fail:
12528 {
12529 if (temp2)
12530 delete arg2;
12531 }
12532 return NULL;
12533 }
12534
12535
12536 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12537 PyObject *resultobj = 0;
12538 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12539 wxFileSystem *arg2 = 0 ;
12540 wxString *arg3 = 0 ;
12541 wxFSFile *result = 0 ;
12542 void *argp1 = 0 ;
12543 int res1 = 0 ;
12544 void *argp2 = 0 ;
12545 int res2 = 0 ;
12546 bool temp3 = false ;
12547 PyObject * obj0 = 0 ;
12548 PyObject * obj1 = 0 ;
12549 PyObject * obj2 = 0 ;
12550 char * kwnames[] = {
12551 (char *) "self",(char *) "fs",(char *) "location", NULL
12552 };
12553
12554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12556 if (!SWIG_IsOK(res1)) {
12557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12558 }
12559 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12560 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12561 if (!SWIG_IsOK(res2)) {
12562 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12563 }
12564 if (!argp2) {
12565 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12566 }
12567 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12568 {
12569 arg3 = wxString_in_helper(obj2);
12570 if (arg3 == NULL) SWIG_fail;
12571 temp3 = true;
12572 }
12573 {
12574 PyThreadState* __tstate = wxPyBeginAllowThreads();
12575 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12576 wxPyEndAllowThreads(__tstate);
12577 if (PyErr_Occurred()) SWIG_fail;
12578 }
12579 {
12580 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
12581 }
12582 {
12583 if (temp3)
12584 delete arg3;
12585 }
12586 return resultobj;
12587 fail:
12588 {
12589 if (temp3)
12590 delete arg3;
12591 }
12592 return NULL;
12593 }
12594
12595
12596 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12597 PyObject *resultobj = 0;
12598 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12599 wxString *arg2 = 0 ;
12600 int arg3 = (int) 0 ;
12601 wxString result;
12602 void *argp1 = 0 ;
12603 int res1 = 0 ;
12604 bool temp2 = false ;
12605 int val3 ;
12606 int ecode3 = 0 ;
12607 PyObject * obj0 = 0 ;
12608 PyObject * obj1 = 0 ;
12609 PyObject * obj2 = 0 ;
12610 char * kwnames[] = {
12611 (char *) "self",(char *) "spec",(char *) "flags", NULL
12612 };
12613
12614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12616 if (!SWIG_IsOK(res1)) {
12617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12618 }
12619 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12620 {
12621 arg2 = wxString_in_helper(obj1);
12622 if (arg2 == NULL) SWIG_fail;
12623 temp2 = true;
12624 }
12625 if (obj2) {
12626 ecode3 = SWIG_AsVal_int(obj2, &val3);
12627 if (!SWIG_IsOK(ecode3)) {
12628 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12629 }
12630 arg3 = static_cast< int >(val3);
12631 }
12632 {
12633 PyThreadState* __tstate = wxPyBeginAllowThreads();
12634 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12635 wxPyEndAllowThreads(__tstate);
12636 if (PyErr_Occurred()) SWIG_fail;
12637 }
12638 {
12639 #if wxUSE_UNICODE
12640 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12641 #else
12642 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12643 #endif
12644 }
12645 {
12646 if (temp2)
12647 delete arg2;
12648 }
12649 return resultobj;
12650 fail:
12651 {
12652 if (temp2)
12653 delete arg2;
12654 }
12655 return NULL;
12656 }
12657
12658
12659 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12660 PyObject *resultobj = 0;
12661 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12662 wxString result;
12663 void *argp1 = 0 ;
12664 int res1 = 0 ;
12665 PyObject *swig_obj[1] ;
12666
12667 if (!args) SWIG_fail;
12668 swig_obj[0] = args;
12669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12670 if (!SWIG_IsOK(res1)) {
12671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12672 }
12673 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12674 {
12675 PyThreadState* __tstate = wxPyBeginAllowThreads();
12676 result = (arg1)->FindNext();
12677 wxPyEndAllowThreads(__tstate);
12678 if (PyErr_Occurred()) SWIG_fail;
12679 }
12680 {
12681 #if wxUSE_UNICODE
12682 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12683 #else
12684 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12685 #endif
12686 }
12687 return resultobj;
12688 fail:
12689 return NULL;
12690 }
12691
12692
12693 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12694 PyObject *resultobj = 0;
12695 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12696 wxString *arg2 = 0 ;
12697 wxString result;
12698 void *argp1 = 0 ;
12699 int res1 = 0 ;
12700 bool temp2 = false ;
12701 PyObject * obj0 = 0 ;
12702 PyObject * obj1 = 0 ;
12703 char * kwnames[] = {
12704 (char *) "self",(char *) "location", NULL
12705 };
12706
12707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12709 if (!SWIG_IsOK(res1)) {
12710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12711 }
12712 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12713 {
12714 arg2 = wxString_in_helper(obj1);
12715 if (arg2 == NULL) SWIG_fail;
12716 temp2 = true;
12717 }
12718 {
12719 PyThreadState* __tstate = wxPyBeginAllowThreads();
12720 result = (arg1)->GetProtocol((wxString const &)*arg2);
12721 wxPyEndAllowThreads(__tstate);
12722 if (PyErr_Occurred()) SWIG_fail;
12723 }
12724 {
12725 #if wxUSE_UNICODE
12726 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12727 #else
12728 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12729 #endif
12730 }
12731 {
12732 if (temp2)
12733 delete arg2;
12734 }
12735 return resultobj;
12736 fail:
12737 {
12738 if (temp2)
12739 delete arg2;
12740 }
12741 return NULL;
12742 }
12743
12744
12745 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12746 PyObject *resultobj = 0;
12747 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12748 wxString *arg2 = 0 ;
12749 wxString result;
12750 void *argp1 = 0 ;
12751 int res1 = 0 ;
12752 bool temp2 = false ;
12753 PyObject * obj0 = 0 ;
12754 PyObject * obj1 = 0 ;
12755 char * kwnames[] = {
12756 (char *) "self",(char *) "location", NULL
12757 };
12758
12759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12761 if (!SWIG_IsOK(res1)) {
12762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12763 }
12764 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12765 {
12766 arg2 = wxString_in_helper(obj1);
12767 if (arg2 == NULL) SWIG_fail;
12768 temp2 = true;
12769 }
12770 {
12771 PyThreadState* __tstate = wxPyBeginAllowThreads();
12772 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12773 wxPyEndAllowThreads(__tstate);
12774 if (PyErr_Occurred()) SWIG_fail;
12775 }
12776 {
12777 #if wxUSE_UNICODE
12778 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12779 #else
12780 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12781 #endif
12782 }
12783 {
12784 if (temp2)
12785 delete arg2;
12786 }
12787 return resultobj;
12788 fail:
12789 {
12790 if (temp2)
12791 delete arg2;
12792 }
12793 return NULL;
12794 }
12795
12796
12797 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12798 PyObject *resultobj = 0;
12799 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12800 wxString *arg2 = 0 ;
12801 wxString result;
12802 void *argp1 = 0 ;
12803 int res1 = 0 ;
12804 bool temp2 = false ;
12805 PyObject * obj0 = 0 ;
12806 PyObject * obj1 = 0 ;
12807 char * kwnames[] = {
12808 (char *) "self",(char *) "location", NULL
12809 };
12810
12811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12813 if (!SWIG_IsOK(res1)) {
12814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12815 }
12816 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12817 {
12818 arg2 = wxString_in_helper(obj1);
12819 if (arg2 == NULL) SWIG_fail;
12820 temp2 = true;
12821 }
12822 {
12823 PyThreadState* __tstate = wxPyBeginAllowThreads();
12824 result = (arg1)->GetAnchor((wxString const &)*arg2);
12825 wxPyEndAllowThreads(__tstate);
12826 if (PyErr_Occurred()) SWIG_fail;
12827 }
12828 {
12829 #if wxUSE_UNICODE
12830 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12831 #else
12832 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12833 #endif
12834 }
12835 {
12836 if (temp2)
12837 delete arg2;
12838 }
12839 return resultobj;
12840 fail:
12841 {
12842 if (temp2)
12843 delete arg2;
12844 }
12845 return NULL;
12846 }
12847
12848
12849 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12850 PyObject *resultobj = 0;
12851 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12852 wxString *arg2 = 0 ;
12853 wxString result;
12854 void *argp1 = 0 ;
12855 int res1 = 0 ;
12856 bool temp2 = false ;
12857 PyObject * obj0 = 0 ;
12858 PyObject * obj1 = 0 ;
12859 char * kwnames[] = {
12860 (char *) "self",(char *) "location", NULL
12861 };
12862
12863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12865 if (!SWIG_IsOK(res1)) {
12866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12867 }
12868 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12869 {
12870 arg2 = wxString_in_helper(obj1);
12871 if (arg2 == NULL) SWIG_fail;
12872 temp2 = true;
12873 }
12874 {
12875 PyThreadState* __tstate = wxPyBeginAllowThreads();
12876 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12877 wxPyEndAllowThreads(__tstate);
12878 if (PyErr_Occurred()) SWIG_fail;
12879 }
12880 {
12881 #if wxUSE_UNICODE
12882 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12883 #else
12884 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12885 #endif
12886 }
12887 {
12888 if (temp2)
12889 delete arg2;
12890 }
12891 return resultobj;
12892 fail:
12893 {
12894 if (temp2)
12895 delete arg2;
12896 }
12897 return NULL;
12898 }
12899
12900
12901 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12902 PyObject *resultobj = 0;
12903 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12904 wxString *arg2 = 0 ;
12905 wxString result;
12906 void *argp1 = 0 ;
12907 int res1 = 0 ;
12908 bool temp2 = false ;
12909 PyObject * obj0 = 0 ;
12910 PyObject * obj1 = 0 ;
12911 char * kwnames[] = {
12912 (char *) "self",(char *) "location", NULL
12913 };
12914
12915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
12916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12917 if (!SWIG_IsOK(res1)) {
12918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12919 }
12920 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12921 {
12922 arg2 = wxString_in_helper(obj1);
12923 if (arg2 == NULL) SWIG_fail;
12924 temp2 = true;
12925 }
12926 {
12927 PyThreadState* __tstate = wxPyBeginAllowThreads();
12928 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
12929 wxPyEndAllowThreads(__tstate);
12930 if (PyErr_Occurred()) SWIG_fail;
12931 }
12932 {
12933 #if wxUSE_UNICODE
12934 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12935 #else
12936 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12937 #endif
12938 }
12939 {
12940 if (temp2)
12941 delete arg2;
12942 }
12943 return resultobj;
12944 fail:
12945 {
12946 if (temp2)
12947 delete arg2;
12948 }
12949 return NULL;
12950 }
12951
12952
12953 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12954 PyObject *obj;
12955 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12956 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
12957 return SWIG_Py_Void();
12958 }
12959
12960 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12961 return SWIG_Python_InitShadowInstance(args);
12962 }
12963
12964 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12965 PyObject *resultobj = 0;
12966 wxFileSystem *result = 0 ;
12967
12968 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
12969 {
12970 PyThreadState* __tstate = wxPyBeginAllowThreads();
12971 result = (wxFileSystem *)new wxFileSystem();
12972 wxPyEndAllowThreads(__tstate);
12973 if (PyErr_Occurred()) SWIG_fail;
12974 }
12975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
12976 return resultobj;
12977 fail:
12978 return NULL;
12979 }
12980
12981
12982 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12983 PyObject *resultobj = 0;
12984 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
12985 void *argp1 = 0 ;
12986 int res1 = 0 ;
12987 PyObject *swig_obj[1] ;
12988
12989 if (!args) SWIG_fail;
12990 swig_obj[0] = args;
12991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
12992 if (!SWIG_IsOK(res1)) {
12993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
12994 }
12995 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
12996 {
12997 PyThreadState* __tstate = wxPyBeginAllowThreads();
12998 delete arg1;
12999
13000 wxPyEndAllowThreads(__tstate);
13001 if (PyErr_Occurred()) SWIG_fail;
13002 }
13003 resultobj = SWIG_Py_Void();
13004 return resultobj;
13005 fail:
13006 return NULL;
13007 }
13008
13009
13010 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13011 PyObject *resultobj = 0;
13012 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13013 wxString *arg2 = 0 ;
13014 bool arg3 = (bool) false ;
13015 void *argp1 = 0 ;
13016 int res1 = 0 ;
13017 bool temp2 = false ;
13018 bool val3 ;
13019 int ecode3 = 0 ;
13020 PyObject * obj0 = 0 ;
13021 PyObject * obj1 = 0 ;
13022 PyObject * obj2 = 0 ;
13023 char * kwnames[] = {
13024 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13025 };
13026
13027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13029 if (!SWIG_IsOK(res1)) {
13030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13031 }
13032 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13033 {
13034 arg2 = wxString_in_helper(obj1);
13035 if (arg2 == NULL) SWIG_fail;
13036 temp2 = true;
13037 }
13038 if (obj2) {
13039 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13040 if (!SWIG_IsOK(ecode3)) {
13041 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13042 }
13043 arg3 = static_cast< bool >(val3);
13044 }
13045 {
13046 PyThreadState* __tstate = wxPyBeginAllowThreads();
13047 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13048 wxPyEndAllowThreads(__tstate);
13049 if (PyErr_Occurred()) SWIG_fail;
13050 }
13051 resultobj = SWIG_Py_Void();
13052 {
13053 if (temp2)
13054 delete arg2;
13055 }
13056 return resultobj;
13057 fail:
13058 {
13059 if (temp2)
13060 delete arg2;
13061 }
13062 return NULL;
13063 }
13064
13065
13066 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13067 PyObject *resultobj = 0;
13068 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13069 wxString result;
13070 void *argp1 = 0 ;
13071 int res1 = 0 ;
13072 PyObject *swig_obj[1] ;
13073
13074 if (!args) SWIG_fail;
13075 swig_obj[0] = args;
13076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13077 if (!SWIG_IsOK(res1)) {
13078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13079 }
13080 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13081 {
13082 PyThreadState* __tstate = wxPyBeginAllowThreads();
13083 result = (arg1)->GetPath();
13084 wxPyEndAllowThreads(__tstate);
13085 if (PyErr_Occurred()) SWIG_fail;
13086 }
13087 {
13088 #if wxUSE_UNICODE
13089 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13090 #else
13091 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13092 #endif
13093 }
13094 return resultobj;
13095 fail:
13096 return NULL;
13097 }
13098
13099
13100 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13101 PyObject *resultobj = 0;
13102 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13103 wxString *arg2 = 0 ;
13104 wxFSFile *result = 0 ;
13105 void *argp1 = 0 ;
13106 int res1 = 0 ;
13107 bool temp2 = false ;
13108 PyObject * obj0 = 0 ;
13109 PyObject * obj1 = 0 ;
13110 char * kwnames[] = {
13111 (char *) "self",(char *) "location", NULL
13112 };
13113
13114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13116 if (!SWIG_IsOK(res1)) {
13117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13118 }
13119 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13120 {
13121 arg2 = wxString_in_helper(obj1);
13122 if (arg2 == NULL) SWIG_fail;
13123 temp2 = true;
13124 }
13125 {
13126 PyThreadState* __tstate = wxPyBeginAllowThreads();
13127 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13128 wxPyEndAllowThreads(__tstate);
13129 if (PyErr_Occurred()) SWIG_fail;
13130 }
13131 {
13132 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13133 }
13134 {
13135 if (temp2)
13136 delete arg2;
13137 }
13138 return resultobj;
13139 fail:
13140 {
13141 if (temp2)
13142 delete arg2;
13143 }
13144 return NULL;
13145 }
13146
13147
13148 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13149 PyObject *resultobj = 0;
13150 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13151 wxString *arg2 = 0 ;
13152 int arg3 = (int) 0 ;
13153 wxString result;
13154 void *argp1 = 0 ;
13155 int res1 = 0 ;
13156 bool temp2 = false ;
13157 int val3 ;
13158 int ecode3 = 0 ;
13159 PyObject * obj0 = 0 ;
13160 PyObject * obj1 = 0 ;
13161 PyObject * obj2 = 0 ;
13162 char * kwnames[] = {
13163 (char *) "self",(char *) "spec",(char *) "flags", NULL
13164 };
13165
13166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13168 if (!SWIG_IsOK(res1)) {
13169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13170 }
13171 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13172 {
13173 arg2 = wxString_in_helper(obj1);
13174 if (arg2 == NULL) SWIG_fail;
13175 temp2 = true;
13176 }
13177 if (obj2) {
13178 ecode3 = SWIG_AsVal_int(obj2, &val3);
13179 if (!SWIG_IsOK(ecode3)) {
13180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13181 }
13182 arg3 = static_cast< int >(val3);
13183 }
13184 {
13185 PyThreadState* __tstate = wxPyBeginAllowThreads();
13186 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13187 wxPyEndAllowThreads(__tstate);
13188 if (PyErr_Occurred()) SWIG_fail;
13189 }
13190 {
13191 #if wxUSE_UNICODE
13192 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13193 #else
13194 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13195 #endif
13196 }
13197 {
13198 if (temp2)
13199 delete arg2;
13200 }
13201 return resultobj;
13202 fail:
13203 {
13204 if (temp2)
13205 delete arg2;
13206 }
13207 return NULL;
13208 }
13209
13210
13211 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13212 PyObject *resultobj = 0;
13213 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13214 wxString result;
13215 void *argp1 = 0 ;
13216 int res1 = 0 ;
13217 PyObject *swig_obj[1] ;
13218
13219 if (!args) SWIG_fail;
13220 swig_obj[0] = args;
13221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13222 if (!SWIG_IsOK(res1)) {
13223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13224 }
13225 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13226 {
13227 PyThreadState* __tstate = wxPyBeginAllowThreads();
13228 result = (arg1)->FindNext();
13229 wxPyEndAllowThreads(__tstate);
13230 if (PyErr_Occurred()) SWIG_fail;
13231 }
13232 {
13233 #if wxUSE_UNICODE
13234 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13235 #else
13236 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13237 #endif
13238 }
13239 return resultobj;
13240 fail:
13241 return NULL;
13242 }
13243
13244
13245 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13246 PyObject *resultobj = 0;
13247 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13248 int res1 = 0 ;
13249 PyObject * obj0 = 0 ;
13250 char * kwnames[] = {
13251 (char *) "handler", NULL
13252 };
13253
13254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13255 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13256 if (!SWIG_IsOK(res1)) {
13257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13258 }
13259 {
13260 PyThreadState* __tstate = wxPyBeginAllowThreads();
13261 wxFileSystem::AddHandler(arg1);
13262 wxPyEndAllowThreads(__tstate);
13263 if (PyErr_Occurred()) SWIG_fail;
13264 }
13265 resultobj = SWIG_Py_Void();
13266 return resultobj;
13267 fail:
13268 return NULL;
13269 }
13270
13271
13272 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13273 PyObject *resultobj = 0;
13274 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13275 wxFileSystemHandler *result = 0 ;
13276 void *argp1 = 0 ;
13277 int res1 = 0 ;
13278 PyObject * obj0 = 0 ;
13279 char * kwnames[] = {
13280 (char *) "handler", NULL
13281 };
13282
13283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13285 if (!SWIG_IsOK(res1)) {
13286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13287 }
13288 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13289 {
13290 PyThreadState* __tstate = wxPyBeginAllowThreads();
13291 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13292 wxPyEndAllowThreads(__tstate);
13293 if (PyErr_Occurred()) SWIG_fail;
13294 }
13295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13296 return resultobj;
13297 fail:
13298 return NULL;
13299 }
13300
13301
13302 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13303 PyObject *resultobj = 0;
13304
13305 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13306 {
13307 PyThreadState* __tstate = wxPyBeginAllowThreads();
13308 wxFileSystem::CleanUpHandlers();
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_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13320 PyObject *resultobj = 0;
13321 wxString *arg1 = 0 ;
13322 wxString result;
13323 bool temp1 = false ;
13324 PyObject * obj0 = 0 ;
13325 char * kwnames[] = {
13326 (char *) "filename", NULL
13327 };
13328
13329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13330 {
13331 arg1 = wxString_in_helper(obj0);
13332 if (arg1 == NULL) SWIG_fail;
13333 temp1 = true;
13334 }
13335 {
13336 PyThreadState* __tstate = wxPyBeginAllowThreads();
13337 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13338 wxPyEndAllowThreads(__tstate);
13339 if (PyErr_Occurred()) SWIG_fail;
13340 }
13341 {
13342 #if wxUSE_UNICODE
13343 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13344 #else
13345 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13346 #endif
13347 }
13348 {
13349 if (temp1)
13350 delete arg1;
13351 }
13352 return resultobj;
13353 fail:
13354 {
13355 if (temp1)
13356 delete arg1;
13357 }
13358 return NULL;
13359 }
13360
13361
13362 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13363 PyObject *resultobj = 0;
13364 wxString *arg1 = 0 ;
13365 wxString result;
13366 bool temp1 = false ;
13367 PyObject * obj0 = 0 ;
13368 char * kwnames[] = {
13369 (char *) "url", NULL
13370 };
13371
13372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13373 {
13374 arg1 = wxString_in_helper(obj0);
13375 if (arg1 == NULL) SWIG_fail;
13376 temp1 = true;
13377 }
13378 {
13379 PyThreadState* __tstate = wxPyBeginAllowThreads();
13380 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
13381 wxPyEndAllowThreads(__tstate);
13382 if (PyErr_Occurred()) SWIG_fail;
13383 }
13384 {
13385 #if wxUSE_UNICODE
13386 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13387 #else
13388 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13389 #endif
13390 }
13391 {
13392 if (temp1)
13393 delete arg1;
13394 }
13395 return resultobj;
13396 fail:
13397 {
13398 if (temp1)
13399 delete arg1;
13400 }
13401 return NULL;
13402 }
13403
13404
13405 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13406 PyObject *obj;
13407 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13408 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13409 return SWIG_Py_Void();
13410 }
13411
13412 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13413 return SWIG_Python_InitShadowInstance(args);
13414 }
13415
13416 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13417 PyObject *resultobj = 0;
13418 wxInternetFSHandler *result = 0 ;
13419
13420 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13421 {
13422 PyThreadState* __tstate = wxPyBeginAllowThreads();
13423 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13424 wxPyEndAllowThreads(__tstate);
13425 if (PyErr_Occurred()) SWIG_fail;
13426 }
13427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13428 return resultobj;
13429 fail:
13430 return NULL;
13431 }
13432
13433
13434 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13435 PyObject *resultobj = 0;
13436 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13437 wxString *arg2 = 0 ;
13438 bool result;
13439 void *argp1 = 0 ;
13440 int res1 = 0 ;
13441 bool temp2 = false ;
13442 PyObject * obj0 = 0 ;
13443 PyObject * obj1 = 0 ;
13444 char * kwnames[] = {
13445 (char *) "self",(char *) "location", NULL
13446 };
13447
13448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13450 if (!SWIG_IsOK(res1)) {
13451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13452 }
13453 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13454 {
13455 arg2 = wxString_in_helper(obj1);
13456 if (arg2 == NULL) SWIG_fail;
13457 temp2 = true;
13458 }
13459 {
13460 PyThreadState* __tstate = wxPyBeginAllowThreads();
13461 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13462 wxPyEndAllowThreads(__tstate);
13463 if (PyErr_Occurred()) SWIG_fail;
13464 }
13465 {
13466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13467 }
13468 {
13469 if (temp2)
13470 delete arg2;
13471 }
13472 return resultobj;
13473 fail:
13474 {
13475 if (temp2)
13476 delete arg2;
13477 }
13478 return NULL;
13479 }
13480
13481
13482 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13483 PyObject *resultobj = 0;
13484 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13485 wxFileSystem *arg2 = 0 ;
13486 wxString *arg3 = 0 ;
13487 wxFSFile *result = 0 ;
13488 void *argp1 = 0 ;
13489 int res1 = 0 ;
13490 void *argp2 = 0 ;
13491 int res2 = 0 ;
13492 bool temp3 = false ;
13493 PyObject * obj0 = 0 ;
13494 PyObject * obj1 = 0 ;
13495 PyObject * obj2 = 0 ;
13496 char * kwnames[] = {
13497 (char *) "self",(char *) "fs",(char *) "location", NULL
13498 };
13499
13500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13502 if (!SWIG_IsOK(res1)) {
13503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13504 }
13505 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13506 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13507 if (!SWIG_IsOK(res2)) {
13508 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13509 }
13510 if (!argp2) {
13511 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13512 }
13513 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13514 {
13515 arg3 = wxString_in_helper(obj2);
13516 if (arg3 == NULL) SWIG_fail;
13517 temp3 = true;
13518 }
13519 {
13520 PyThreadState* __tstate = wxPyBeginAllowThreads();
13521 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13522 wxPyEndAllowThreads(__tstate);
13523 if (PyErr_Occurred()) SWIG_fail;
13524 }
13525 {
13526 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13527 }
13528 {
13529 if (temp3)
13530 delete arg3;
13531 }
13532 return resultobj;
13533 fail:
13534 {
13535 if (temp3)
13536 delete arg3;
13537 }
13538 return NULL;
13539 }
13540
13541
13542 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13543 PyObject *obj;
13544 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13545 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13546 return SWIG_Py_Void();
13547 }
13548
13549 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13550 return SWIG_Python_InitShadowInstance(args);
13551 }
13552
13553 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13554 PyObject *resultobj = 0;
13555 wxZipFSHandler *result = 0 ;
13556
13557 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13558 {
13559 PyThreadState* __tstate = wxPyBeginAllowThreads();
13560 result = (wxZipFSHandler *)new wxZipFSHandler();
13561 wxPyEndAllowThreads(__tstate);
13562 if (PyErr_Occurred()) SWIG_fail;
13563 }
13564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13565 return resultobj;
13566 fail:
13567 return NULL;
13568 }
13569
13570
13571 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13572 PyObject *resultobj = 0;
13573 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13574 wxString *arg2 = 0 ;
13575 bool result;
13576 void *argp1 = 0 ;
13577 int res1 = 0 ;
13578 bool temp2 = false ;
13579 PyObject * obj0 = 0 ;
13580 PyObject * obj1 = 0 ;
13581 char * kwnames[] = {
13582 (char *) "self",(char *) "location", NULL
13583 };
13584
13585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13587 if (!SWIG_IsOK(res1)) {
13588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13589 }
13590 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13591 {
13592 arg2 = wxString_in_helper(obj1);
13593 if (arg2 == NULL) SWIG_fail;
13594 temp2 = true;
13595 }
13596 {
13597 PyThreadState* __tstate = wxPyBeginAllowThreads();
13598 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13599 wxPyEndAllowThreads(__tstate);
13600 if (PyErr_Occurred()) SWIG_fail;
13601 }
13602 {
13603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13604 }
13605 {
13606 if (temp2)
13607 delete arg2;
13608 }
13609 return resultobj;
13610 fail:
13611 {
13612 if (temp2)
13613 delete arg2;
13614 }
13615 return NULL;
13616 }
13617
13618
13619 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13620 PyObject *resultobj = 0;
13621 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13622 wxFileSystem *arg2 = 0 ;
13623 wxString *arg3 = 0 ;
13624 wxFSFile *result = 0 ;
13625 void *argp1 = 0 ;
13626 int res1 = 0 ;
13627 void *argp2 = 0 ;
13628 int res2 = 0 ;
13629 bool temp3 = false ;
13630 PyObject * obj0 = 0 ;
13631 PyObject * obj1 = 0 ;
13632 PyObject * obj2 = 0 ;
13633 char * kwnames[] = {
13634 (char *) "self",(char *) "fs",(char *) "location", NULL
13635 };
13636
13637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13639 if (!SWIG_IsOK(res1)) {
13640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13641 }
13642 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13643 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13644 if (!SWIG_IsOK(res2)) {
13645 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13646 }
13647 if (!argp2) {
13648 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13649 }
13650 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13651 {
13652 arg3 = wxString_in_helper(obj2);
13653 if (arg3 == NULL) SWIG_fail;
13654 temp3 = true;
13655 }
13656 {
13657 PyThreadState* __tstate = wxPyBeginAllowThreads();
13658 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13659 wxPyEndAllowThreads(__tstate);
13660 if (PyErr_Occurred()) SWIG_fail;
13661 }
13662 {
13663 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13664 }
13665 {
13666 if (temp3)
13667 delete arg3;
13668 }
13669 return resultobj;
13670 fail:
13671 {
13672 if (temp3)
13673 delete arg3;
13674 }
13675 return NULL;
13676 }
13677
13678
13679 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13680 PyObject *resultobj = 0;
13681 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13682 wxString *arg2 = 0 ;
13683 int arg3 = (int) 0 ;
13684 wxString result;
13685 void *argp1 = 0 ;
13686 int res1 = 0 ;
13687 bool temp2 = false ;
13688 int val3 ;
13689 int ecode3 = 0 ;
13690 PyObject * obj0 = 0 ;
13691 PyObject * obj1 = 0 ;
13692 PyObject * obj2 = 0 ;
13693 char * kwnames[] = {
13694 (char *) "self",(char *) "spec",(char *) "flags", NULL
13695 };
13696
13697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13699 if (!SWIG_IsOK(res1)) {
13700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13701 }
13702 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13703 {
13704 arg2 = wxString_in_helper(obj1);
13705 if (arg2 == NULL) SWIG_fail;
13706 temp2 = true;
13707 }
13708 if (obj2) {
13709 ecode3 = SWIG_AsVal_int(obj2, &val3);
13710 if (!SWIG_IsOK(ecode3)) {
13711 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13712 }
13713 arg3 = static_cast< int >(val3);
13714 }
13715 {
13716 PyThreadState* __tstate = wxPyBeginAllowThreads();
13717 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13718 wxPyEndAllowThreads(__tstate);
13719 if (PyErr_Occurred()) SWIG_fail;
13720 }
13721 {
13722 #if wxUSE_UNICODE
13723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13724 #else
13725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13726 #endif
13727 }
13728 {
13729 if (temp2)
13730 delete arg2;
13731 }
13732 return resultobj;
13733 fail:
13734 {
13735 if (temp2)
13736 delete arg2;
13737 }
13738 return NULL;
13739 }
13740
13741
13742 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13743 PyObject *resultobj = 0;
13744 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13745 wxString result;
13746 void *argp1 = 0 ;
13747 int res1 = 0 ;
13748 PyObject *swig_obj[1] ;
13749
13750 if (!args) SWIG_fail;
13751 swig_obj[0] = args;
13752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13753 if (!SWIG_IsOK(res1)) {
13754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13755 }
13756 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13757 {
13758 PyThreadState* __tstate = wxPyBeginAllowThreads();
13759 result = (arg1)->FindNext();
13760 wxPyEndAllowThreads(__tstate);
13761 if (PyErr_Occurred()) SWIG_fail;
13762 }
13763 {
13764 #if wxUSE_UNICODE
13765 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13766 #else
13767 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13768 #endif
13769 }
13770 return resultobj;
13771 fail:
13772 return NULL;
13773 }
13774
13775
13776 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13777 PyObject *obj;
13778 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13779 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13780 return SWIG_Py_Void();
13781 }
13782
13783 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13784 return SWIG_Python_InitShadowInstance(args);
13785 }
13786
13787 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13788 PyObject *resultobj = 0;
13789 wxString *arg1 = 0 ;
13790 wxImage *arg2 = 0 ;
13791 long arg3 ;
13792 bool temp1 = false ;
13793 void *argp2 = 0 ;
13794 int res2 = 0 ;
13795 long val3 ;
13796 int ecode3 = 0 ;
13797 PyObject * obj0 = 0 ;
13798 PyObject * obj1 = 0 ;
13799 PyObject * obj2 = 0 ;
13800 char * kwnames[] = {
13801 (char *) "filename",(char *) "image",(char *) "type", NULL
13802 };
13803
13804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13805 {
13806 arg1 = wxString_in_helper(obj0);
13807 if (arg1 == NULL) SWIG_fail;
13808 temp1 = true;
13809 }
13810 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13811 if (!SWIG_IsOK(res2)) {
13812 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13813 }
13814 if (!argp2) {
13815 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13816 }
13817 arg2 = reinterpret_cast< wxImage * >(argp2);
13818 ecode3 = SWIG_AsVal_long(obj2, &val3);
13819 if (!SWIG_IsOK(ecode3)) {
13820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13821 }
13822 arg3 = static_cast< long >(val3);
13823 {
13824 PyThreadState* __tstate = wxPyBeginAllowThreads();
13825 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13826 wxPyEndAllowThreads(__tstate);
13827 if (PyErr_Occurred()) SWIG_fail;
13828 }
13829 resultobj = SWIG_Py_Void();
13830 {
13831 if (temp1)
13832 delete arg1;
13833 }
13834 return resultobj;
13835 fail:
13836 {
13837 if (temp1)
13838 delete arg1;
13839 }
13840 return NULL;
13841 }
13842
13843
13844 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13845 PyObject *resultobj = 0;
13846 wxString *arg1 = 0 ;
13847 wxBitmap *arg2 = 0 ;
13848 long arg3 ;
13849 bool temp1 = false ;
13850 void *argp2 = 0 ;
13851 int res2 = 0 ;
13852 long val3 ;
13853 int ecode3 = 0 ;
13854 PyObject * obj0 = 0 ;
13855 PyObject * obj1 = 0 ;
13856 PyObject * obj2 = 0 ;
13857 char * kwnames[] = {
13858 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13859 };
13860
13861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13862 {
13863 arg1 = wxString_in_helper(obj0);
13864 if (arg1 == NULL) SWIG_fail;
13865 temp1 = true;
13866 }
13867 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13868 if (!SWIG_IsOK(res2)) {
13869 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13870 }
13871 if (!argp2) {
13872 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13873 }
13874 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13875 ecode3 = SWIG_AsVal_long(obj2, &val3);
13876 if (!SWIG_IsOK(ecode3)) {
13877 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13878 }
13879 arg3 = static_cast< long >(val3);
13880 {
13881 PyThreadState* __tstate = wxPyBeginAllowThreads();
13882 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
13883 wxPyEndAllowThreads(__tstate);
13884 if (PyErr_Occurred()) SWIG_fail;
13885 }
13886 resultobj = SWIG_Py_Void();
13887 {
13888 if (temp1)
13889 delete arg1;
13890 }
13891 return resultobj;
13892 fail:
13893 {
13894 if (temp1)
13895 delete arg1;
13896 }
13897 return NULL;
13898 }
13899
13900
13901 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13902 PyObject *resultobj = 0;
13903 wxString *arg1 = 0 ;
13904 PyObject *arg2 = (PyObject *) 0 ;
13905 bool temp1 = false ;
13906 PyObject * obj0 = 0 ;
13907 PyObject * obj1 = 0 ;
13908 char * kwnames[] = {
13909 (char *) "filename",(char *) "data", NULL
13910 };
13911
13912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
13913 {
13914 arg1 = wxString_in_helper(obj0);
13915 if (arg1 == NULL) SWIG_fail;
13916 temp1 = true;
13917 }
13918 arg2 = obj1;
13919 {
13920 PyThreadState* __tstate = wxPyBeginAllowThreads();
13921 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
13922 wxPyEndAllowThreads(__tstate);
13923 if (PyErr_Occurred()) SWIG_fail;
13924 }
13925 resultobj = SWIG_Py_Void();
13926 {
13927 if (temp1)
13928 delete arg1;
13929 }
13930 return resultobj;
13931 fail:
13932 {
13933 if (temp1)
13934 delete arg1;
13935 }
13936 return NULL;
13937 }
13938
13939
13940 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13941 PyObject *resultobj = 0;
13942 wxMemoryFSHandler *result = 0 ;
13943
13944 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
13945 {
13946 PyThreadState* __tstate = wxPyBeginAllowThreads();
13947 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
13948 wxPyEndAllowThreads(__tstate);
13949 if (PyErr_Occurred()) SWIG_fail;
13950 }
13951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
13952 return resultobj;
13953 fail:
13954 return NULL;
13955 }
13956
13957
13958 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13959 PyObject *resultobj = 0;
13960 wxString *arg1 = 0 ;
13961 bool temp1 = false ;
13962 PyObject * obj0 = 0 ;
13963 char * kwnames[] = {
13964 (char *) "filename", NULL
13965 };
13966
13967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
13968 {
13969 arg1 = wxString_in_helper(obj0);
13970 if (arg1 == NULL) SWIG_fail;
13971 temp1 = true;
13972 }
13973 {
13974 PyThreadState* __tstate = wxPyBeginAllowThreads();
13975 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
13976 wxPyEndAllowThreads(__tstate);
13977 if (PyErr_Occurred()) SWIG_fail;
13978 }
13979 resultobj = SWIG_Py_Void();
13980 {
13981 if (temp1)
13982 delete arg1;
13983 }
13984 return resultobj;
13985 fail:
13986 {
13987 if (temp1)
13988 delete arg1;
13989 }
13990 return NULL;
13991 }
13992
13993
13994 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13995 PyObject *resultobj = 0;
13996 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
13997 wxString *arg2 = 0 ;
13998 bool result;
13999 void *argp1 = 0 ;
14000 int res1 = 0 ;
14001 bool temp2 = false ;
14002 PyObject * obj0 = 0 ;
14003 PyObject * obj1 = 0 ;
14004 char * kwnames[] = {
14005 (char *) "self",(char *) "location", NULL
14006 };
14007
14008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14010 if (!SWIG_IsOK(res1)) {
14011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14012 }
14013 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14014 {
14015 arg2 = wxString_in_helper(obj1);
14016 if (arg2 == NULL) SWIG_fail;
14017 temp2 = true;
14018 }
14019 {
14020 PyThreadState* __tstate = wxPyBeginAllowThreads();
14021 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14022 wxPyEndAllowThreads(__tstate);
14023 if (PyErr_Occurred()) SWIG_fail;
14024 }
14025 {
14026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14027 }
14028 {
14029 if (temp2)
14030 delete arg2;
14031 }
14032 return resultobj;
14033 fail:
14034 {
14035 if (temp2)
14036 delete arg2;
14037 }
14038 return NULL;
14039 }
14040
14041
14042 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14043 PyObject *resultobj = 0;
14044 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14045 wxFileSystem *arg2 = 0 ;
14046 wxString *arg3 = 0 ;
14047 wxFSFile *result = 0 ;
14048 void *argp1 = 0 ;
14049 int res1 = 0 ;
14050 void *argp2 = 0 ;
14051 int res2 = 0 ;
14052 bool temp3 = false ;
14053 PyObject * obj0 = 0 ;
14054 PyObject * obj1 = 0 ;
14055 PyObject * obj2 = 0 ;
14056 char * kwnames[] = {
14057 (char *) "self",(char *) "fs",(char *) "location", NULL
14058 };
14059
14060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14062 if (!SWIG_IsOK(res1)) {
14063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14064 }
14065 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14066 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14067 if (!SWIG_IsOK(res2)) {
14068 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14069 }
14070 if (!argp2) {
14071 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14072 }
14073 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14074 {
14075 arg3 = wxString_in_helper(obj2);
14076 if (arg3 == NULL) SWIG_fail;
14077 temp3 = true;
14078 }
14079 {
14080 PyThreadState* __tstate = wxPyBeginAllowThreads();
14081 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14082 wxPyEndAllowThreads(__tstate);
14083 if (PyErr_Occurred()) SWIG_fail;
14084 }
14085 {
14086 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14087 }
14088 {
14089 if (temp3)
14090 delete arg3;
14091 }
14092 return resultobj;
14093 fail:
14094 {
14095 if (temp3)
14096 delete arg3;
14097 }
14098 return NULL;
14099 }
14100
14101
14102 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14103 PyObject *resultobj = 0;
14104 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14105 wxString *arg2 = 0 ;
14106 int arg3 = (int) 0 ;
14107 wxString result;
14108 void *argp1 = 0 ;
14109 int res1 = 0 ;
14110 bool temp2 = false ;
14111 int val3 ;
14112 int ecode3 = 0 ;
14113 PyObject * obj0 = 0 ;
14114 PyObject * obj1 = 0 ;
14115 PyObject * obj2 = 0 ;
14116 char * kwnames[] = {
14117 (char *) "self",(char *) "spec",(char *) "flags", NULL
14118 };
14119
14120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14122 if (!SWIG_IsOK(res1)) {
14123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14124 }
14125 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14126 {
14127 arg2 = wxString_in_helper(obj1);
14128 if (arg2 == NULL) SWIG_fail;
14129 temp2 = true;
14130 }
14131 if (obj2) {
14132 ecode3 = SWIG_AsVal_int(obj2, &val3);
14133 if (!SWIG_IsOK(ecode3)) {
14134 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14135 }
14136 arg3 = static_cast< int >(val3);
14137 }
14138 {
14139 PyThreadState* __tstate = wxPyBeginAllowThreads();
14140 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14141 wxPyEndAllowThreads(__tstate);
14142 if (PyErr_Occurred()) SWIG_fail;
14143 }
14144 {
14145 #if wxUSE_UNICODE
14146 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14147 #else
14148 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14149 #endif
14150 }
14151 {
14152 if (temp2)
14153 delete arg2;
14154 }
14155 return resultobj;
14156 fail:
14157 {
14158 if (temp2)
14159 delete arg2;
14160 }
14161 return NULL;
14162 }
14163
14164
14165 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14166 PyObject *resultobj = 0;
14167 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14168 wxString result;
14169 void *argp1 = 0 ;
14170 int res1 = 0 ;
14171 PyObject *swig_obj[1] ;
14172
14173 if (!args) SWIG_fail;
14174 swig_obj[0] = args;
14175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14176 if (!SWIG_IsOK(res1)) {
14177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14178 }
14179 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14180 {
14181 PyThreadState* __tstate = wxPyBeginAllowThreads();
14182 result = (arg1)->FindNext();
14183 wxPyEndAllowThreads(__tstate);
14184 if (PyErr_Occurred()) SWIG_fail;
14185 }
14186 {
14187 #if wxUSE_UNICODE
14188 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14189 #else
14190 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14191 #endif
14192 }
14193 return resultobj;
14194 fail:
14195 return NULL;
14196 }
14197
14198
14199 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14200 PyObject *obj;
14201 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14202 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14203 return SWIG_Py_Void();
14204 }
14205
14206 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14207 return SWIG_Python_InitShadowInstance(args);
14208 }
14209
14210 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14211 PyObject *resultobj = 0;
14212 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14213 wxString result;
14214 void *argp1 = 0 ;
14215 int res1 = 0 ;
14216 PyObject *swig_obj[1] ;
14217
14218 if (!args) SWIG_fail;
14219 swig_obj[0] = args;
14220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14221 if (!SWIG_IsOK(res1)) {
14222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14223 }
14224 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14225 {
14226 PyThreadState* __tstate = wxPyBeginAllowThreads();
14227 result = (arg1)->GetName();
14228 wxPyEndAllowThreads(__tstate);
14229 if (PyErr_Occurred()) SWIG_fail;
14230 }
14231 {
14232 #if wxUSE_UNICODE
14233 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14234 #else
14235 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14236 #endif
14237 }
14238 return resultobj;
14239 fail:
14240 return NULL;
14241 }
14242
14243
14244 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14245 PyObject *resultobj = 0;
14246 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14247 wxString result;
14248 void *argp1 = 0 ;
14249 int res1 = 0 ;
14250 PyObject *swig_obj[1] ;
14251
14252 if (!args) SWIG_fail;
14253 swig_obj[0] = args;
14254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14255 if (!SWIG_IsOK(res1)) {
14256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14257 }
14258 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14259 {
14260 PyThreadState* __tstate = wxPyBeginAllowThreads();
14261 result = (arg1)->GetExtension();
14262 wxPyEndAllowThreads(__tstate);
14263 if (PyErr_Occurred()) SWIG_fail;
14264 }
14265 {
14266 #if wxUSE_UNICODE
14267 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14268 #else
14269 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14270 #endif
14271 }
14272 return resultobj;
14273 fail:
14274 return NULL;
14275 }
14276
14277
14278 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14279 PyObject *resultobj = 0;
14280 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14281 long result;
14282 void *argp1 = 0 ;
14283 int res1 = 0 ;
14284 PyObject *swig_obj[1] ;
14285
14286 if (!args) SWIG_fail;
14287 swig_obj[0] = args;
14288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14289 if (!SWIG_IsOK(res1)) {
14290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14291 }
14292 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14293 {
14294 PyThreadState* __tstate = wxPyBeginAllowThreads();
14295 result = (long)(arg1)->GetType();
14296 wxPyEndAllowThreads(__tstate);
14297 if (PyErr_Occurred()) SWIG_fail;
14298 }
14299 resultobj = SWIG_From_long(static_cast< long >(result));
14300 return resultobj;
14301 fail:
14302 return NULL;
14303 }
14304
14305
14306 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14307 PyObject *resultobj = 0;
14308 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14309 wxString result;
14310 void *argp1 = 0 ;
14311 int res1 = 0 ;
14312 PyObject *swig_obj[1] ;
14313
14314 if (!args) SWIG_fail;
14315 swig_obj[0] = args;
14316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14317 if (!SWIG_IsOK(res1)) {
14318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14319 }
14320 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14321 {
14322 PyThreadState* __tstate = wxPyBeginAllowThreads();
14323 result = (arg1)->GetMimeType();
14324 wxPyEndAllowThreads(__tstate);
14325 if (PyErr_Occurred()) SWIG_fail;
14326 }
14327 {
14328 #if wxUSE_UNICODE
14329 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14330 #else
14331 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14332 #endif
14333 }
14334 return resultobj;
14335 fail:
14336 return NULL;
14337 }
14338
14339
14340 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14341 PyObject *resultobj = 0;
14342 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14343 wxString *arg2 = 0 ;
14344 bool result;
14345 void *argp1 = 0 ;
14346 int res1 = 0 ;
14347 bool temp2 = false ;
14348 PyObject * obj0 = 0 ;
14349 PyObject * obj1 = 0 ;
14350 char * kwnames[] = {
14351 (char *) "self",(char *) "name", NULL
14352 };
14353
14354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14356 if (!SWIG_IsOK(res1)) {
14357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14358 }
14359 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14360 {
14361 arg2 = wxString_in_helper(obj1);
14362 if (arg2 == NULL) SWIG_fail;
14363 temp2 = true;
14364 }
14365 {
14366 PyThreadState* __tstate = wxPyBeginAllowThreads();
14367 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14368 wxPyEndAllowThreads(__tstate);
14369 if (PyErr_Occurred()) SWIG_fail;
14370 }
14371 {
14372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14373 }
14374 {
14375 if (temp2)
14376 delete arg2;
14377 }
14378 return resultobj;
14379 fail:
14380 {
14381 if (temp2)
14382 delete arg2;
14383 }
14384 return NULL;
14385 }
14386
14387
14388 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14389 PyObject *resultobj = 0;
14390 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14391 wxInputStream *arg2 = 0 ;
14392 bool result;
14393 void *argp1 = 0 ;
14394 int res1 = 0 ;
14395 wxPyInputStream *temp2 ;
14396 bool created2 ;
14397 PyObject * obj0 = 0 ;
14398 PyObject * obj1 = 0 ;
14399 char * kwnames[] = {
14400 (char *) "self",(char *) "stream", NULL
14401 };
14402
14403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14405 if (!SWIG_IsOK(res1)) {
14406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14407 }
14408 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14409 {
14410 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14411 arg2 = temp2->m_wxis;
14412 created2 = false;
14413 } else {
14414 PyErr_Clear(); // clear the failure of the wxPyConvert above
14415 arg2 = wxPyCBInputStream_create(obj1, false);
14416 if (arg2 == NULL) {
14417 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14418 SWIG_fail;
14419 }
14420 created2 = true;
14421 }
14422 }
14423 {
14424 PyThreadState* __tstate = wxPyBeginAllowThreads();
14425 result = (bool)(arg1)->CanRead(*arg2);
14426 wxPyEndAllowThreads(__tstate);
14427 if (PyErr_Occurred()) SWIG_fail;
14428 }
14429 {
14430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14431 }
14432 {
14433 if (created2) delete arg2;
14434 }
14435 return resultobj;
14436 fail:
14437 {
14438 if (created2) delete arg2;
14439 }
14440 return NULL;
14441 }
14442
14443
14444 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14445 PyObject *resultobj = 0;
14446 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14447 wxString *arg2 = 0 ;
14448 void *argp1 = 0 ;
14449 int res1 = 0 ;
14450 bool temp2 = false ;
14451 PyObject * obj0 = 0 ;
14452 PyObject * obj1 = 0 ;
14453 char * kwnames[] = {
14454 (char *) "self",(char *) "name", NULL
14455 };
14456
14457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14459 if (!SWIG_IsOK(res1)) {
14460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14461 }
14462 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14463 {
14464 arg2 = wxString_in_helper(obj1);
14465 if (arg2 == NULL) SWIG_fail;
14466 temp2 = true;
14467 }
14468 {
14469 PyThreadState* __tstate = wxPyBeginAllowThreads();
14470 (arg1)->SetName((wxString const &)*arg2);
14471 wxPyEndAllowThreads(__tstate);
14472 if (PyErr_Occurred()) SWIG_fail;
14473 }
14474 resultobj = SWIG_Py_Void();
14475 {
14476 if (temp2)
14477 delete arg2;
14478 }
14479 return resultobj;
14480 fail:
14481 {
14482 if (temp2)
14483 delete arg2;
14484 }
14485 return NULL;
14486 }
14487
14488
14489 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14490 PyObject *resultobj = 0;
14491 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14492 wxString *arg2 = 0 ;
14493 void *argp1 = 0 ;
14494 int res1 = 0 ;
14495 bool temp2 = false ;
14496 PyObject * obj0 = 0 ;
14497 PyObject * obj1 = 0 ;
14498 char * kwnames[] = {
14499 (char *) "self",(char *) "extension", NULL
14500 };
14501
14502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
14503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14504 if (!SWIG_IsOK(res1)) {
14505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14506 }
14507 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14508 {
14509 arg2 = wxString_in_helper(obj1);
14510 if (arg2 == NULL) SWIG_fail;
14511 temp2 = true;
14512 }
14513 {
14514 PyThreadState* __tstate = wxPyBeginAllowThreads();
14515 (arg1)->SetExtension((wxString const &)*arg2);
14516 wxPyEndAllowThreads(__tstate);
14517 if (PyErr_Occurred()) SWIG_fail;
14518 }
14519 resultobj = SWIG_Py_Void();
14520 {
14521 if (temp2)
14522 delete arg2;
14523 }
14524 return resultobj;
14525 fail:
14526 {
14527 if (temp2)
14528 delete arg2;
14529 }
14530 return NULL;
14531 }
14532
14533
14534 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14535 PyObject *resultobj = 0;
14536 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14537 long arg2 ;
14538 void *argp1 = 0 ;
14539 int res1 = 0 ;
14540 long val2 ;
14541 int ecode2 = 0 ;
14542 PyObject * obj0 = 0 ;
14543 PyObject * obj1 = 0 ;
14544 char * kwnames[] = {
14545 (char *) "self",(char *) "type", NULL
14546 };
14547
14548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14550 if (!SWIG_IsOK(res1)) {
14551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14552 }
14553 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14554 ecode2 = SWIG_AsVal_long(obj1, &val2);
14555 if (!SWIG_IsOK(ecode2)) {
14556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14557 }
14558 arg2 = static_cast< long >(val2);
14559 {
14560 PyThreadState* __tstate = wxPyBeginAllowThreads();
14561 (arg1)->SetType(arg2);
14562 wxPyEndAllowThreads(__tstate);
14563 if (PyErr_Occurred()) SWIG_fail;
14564 }
14565 resultobj = SWIG_Py_Void();
14566 return resultobj;
14567 fail:
14568 return NULL;
14569 }
14570
14571
14572 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14573 PyObject *resultobj = 0;
14574 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14575 wxString *arg2 = 0 ;
14576 void *argp1 = 0 ;
14577 int res1 = 0 ;
14578 bool temp2 = false ;
14579 PyObject * obj0 = 0 ;
14580 PyObject * obj1 = 0 ;
14581 char * kwnames[] = {
14582 (char *) "self",(char *) "mimetype", NULL
14583 };
14584
14585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14587 if (!SWIG_IsOK(res1)) {
14588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14589 }
14590 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14591 {
14592 arg2 = wxString_in_helper(obj1);
14593 if (arg2 == NULL) SWIG_fail;
14594 temp2 = true;
14595 }
14596 {
14597 PyThreadState* __tstate = wxPyBeginAllowThreads();
14598 (arg1)->SetMimeType((wxString const &)*arg2);
14599 wxPyEndAllowThreads(__tstate);
14600 if (PyErr_Occurred()) SWIG_fail;
14601 }
14602 resultobj = SWIG_Py_Void();
14603 {
14604 if (temp2)
14605 delete arg2;
14606 }
14607 return resultobj;
14608 fail:
14609 {
14610 if (temp2)
14611 delete arg2;
14612 }
14613 return NULL;
14614 }
14615
14616
14617 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14618 PyObject *obj;
14619 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14620 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14621 return SWIG_Py_Void();
14622 }
14623
14624 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14625 PyObject *resultobj = 0;
14626 wxPyImageHandler *result = 0 ;
14627
14628 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14629 {
14630 PyThreadState* __tstate = wxPyBeginAllowThreads();
14631 result = (wxPyImageHandler *)new wxPyImageHandler();
14632 wxPyEndAllowThreads(__tstate);
14633 if (PyErr_Occurred()) SWIG_fail;
14634 }
14635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14636 return resultobj;
14637 fail:
14638 return NULL;
14639 }
14640
14641
14642 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14643 PyObject *resultobj = 0;
14644 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14645 PyObject *arg2 = (PyObject *) 0 ;
14646 void *argp1 = 0 ;
14647 int res1 = 0 ;
14648 PyObject * obj0 = 0 ;
14649 PyObject * obj1 = 0 ;
14650 char * kwnames[] = {
14651 (char *) "self",(char *) "self", NULL
14652 };
14653
14654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14656 if (!SWIG_IsOK(res1)) {
14657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14658 }
14659 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14660 arg2 = obj1;
14661 {
14662 PyThreadState* __tstate = wxPyBeginAllowThreads();
14663 (arg1)->_SetSelf(arg2);
14664 wxPyEndAllowThreads(__tstate);
14665 if (PyErr_Occurred()) SWIG_fail;
14666 }
14667 resultobj = SWIG_Py_Void();
14668 return resultobj;
14669 fail:
14670 return NULL;
14671 }
14672
14673
14674 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14675 PyObject *obj;
14676 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14677 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14678 return SWIG_Py_Void();
14679 }
14680
14681 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14682 return SWIG_Python_InitShadowInstance(args);
14683 }
14684
14685 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14686 PyObject *resultobj = 0;
14687 wxImageHistogram *result = 0 ;
14688
14689 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14690 {
14691 PyThreadState* __tstate = wxPyBeginAllowThreads();
14692 result = (wxImageHistogram *)new wxImageHistogram();
14693 wxPyEndAllowThreads(__tstate);
14694 if (PyErr_Occurred()) SWIG_fail;
14695 }
14696 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14697 return resultobj;
14698 fail:
14699 return NULL;
14700 }
14701
14702
14703 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14704 PyObject *resultobj = 0;
14705 byte arg1 ;
14706 byte arg2 ;
14707 byte arg3 ;
14708 unsigned long result;
14709 unsigned char val1 ;
14710 int ecode1 = 0 ;
14711 unsigned char val2 ;
14712 int ecode2 = 0 ;
14713 unsigned char val3 ;
14714 int ecode3 = 0 ;
14715 PyObject * obj0 = 0 ;
14716 PyObject * obj1 = 0 ;
14717 PyObject * obj2 = 0 ;
14718 char * kwnames[] = {
14719 (char *) "r",(char *) "g",(char *) "b", NULL
14720 };
14721
14722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14723 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14724 if (!SWIG_IsOK(ecode1)) {
14725 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14726 }
14727 arg1 = static_cast< byte >(val1);
14728 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14729 if (!SWIG_IsOK(ecode2)) {
14730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14731 }
14732 arg2 = static_cast< byte >(val2);
14733 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14734 if (!SWIG_IsOK(ecode3)) {
14735 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14736 }
14737 arg3 = static_cast< byte >(val3);
14738 {
14739 PyThreadState* __tstate = wxPyBeginAllowThreads();
14740 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14741 wxPyEndAllowThreads(__tstate);
14742 if (PyErr_Occurred()) SWIG_fail;
14743 }
14744 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14745 return resultobj;
14746 fail:
14747 return NULL;
14748 }
14749
14750
14751 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14752 PyObject *resultobj = 0;
14753 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14754 byte *arg2 = (byte *) 0 ;
14755 byte *arg3 = (byte *) 0 ;
14756 byte *arg4 = (byte *) 0 ;
14757 byte arg5 = (byte) 1 ;
14758 byte arg6 = (byte) 0 ;
14759 byte arg7 = (byte) 0 ;
14760 bool result;
14761 void *argp1 = 0 ;
14762 int res1 = 0 ;
14763 byte temp2 ;
14764 int res2 = SWIG_TMPOBJ ;
14765 byte temp3 ;
14766 int res3 = SWIG_TMPOBJ ;
14767 byte temp4 ;
14768 int res4 = SWIG_TMPOBJ ;
14769 unsigned char val5 ;
14770 int ecode5 = 0 ;
14771 unsigned char val6 ;
14772 int ecode6 = 0 ;
14773 unsigned char val7 ;
14774 int ecode7 = 0 ;
14775 PyObject * obj0 = 0 ;
14776 PyObject * obj1 = 0 ;
14777 PyObject * obj2 = 0 ;
14778 PyObject * obj3 = 0 ;
14779 char * kwnames[] = {
14780 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14781 };
14782
14783 arg2 = &temp2;
14784 arg3 = &temp3;
14785 arg4 = &temp4;
14786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14788 if (!SWIG_IsOK(res1)) {
14789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14790 }
14791 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14792 if (obj1) {
14793 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14794 if (!SWIG_IsOK(ecode5)) {
14795 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14796 }
14797 arg5 = static_cast< byte >(val5);
14798 }
14799 if (obj2) {
14800 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14801 if (!SWIG_IsOK(ecode6)) {
14802 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14803 }
14804 arg6 = static_cast< byte >(val6);
14805 }
14806 if (obj3) {
14807 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14808 if (!SWIG_IsOK(ecode7)) {
14809 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14810 }
14811 arg7 = static_cast< byte >(val7);
14812 }
14813 {
14814 PyThreadState* __tstate = wxPyBeginAllowThreads();
14815 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14816 wxPyEndAllowThreads(__tstate);
14817 if (PyErr_Occurred()) SWIG_fail;
14818 }
14819 {
14820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14821 }
14822 if (SWIG_IsTmpObj(res2)) {
14823 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14824 } else {
14825 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14826 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14827 }
14828 if (SWIG_IsTmpObj(res3)) {
14829 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14830 } else {
14831 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14832 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14833 }
14834 if (SWIG_IsTmpObj(res4)) {
14835 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14836 } else {
14837 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14838 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14839 }
14840 return resultobj;
14841 fail:
14842 return NULL;
14843 }
14844
14845
14846 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14847 PyObject *resultobj = 0;
14848 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14849 unsigned long arg2 ;
14850 unsigned long result;
14851 void *argp1 = 0 ;
14852 int res1 = 0 ;
14853 unsigned long val2 ;
14854 int ecode2 = 0 ;
14855 PyObject * obj0 = 0 ;
14856 PyObject * obj1 = 0 ;
14857 char * kwnames[] = {
14858 (char *) "self",(char *) "key", NULL
14859 };
14860
14861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14863 if (!SWIG_IsOK(res1)) {
14864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14865 }
14866 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14867 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14868 if (!SWIG_IsOK(ecode2)) {
14869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14870 }
14871 arg2 = static_cast< unsigned long >(val2);
14872 {
14873 PyThreadState* __tstate = wxPyBeginAllowThreads();
14874 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14875 wxPyEndAllowThreads(__tstate);
14876 if (PyErr_Occurred()) SWIG_fail;
14877 }
14878 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14879 return resultobj;
14880 fail:
14881 return NULL;
14882 }
14883
14884
14885 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14886 PyObject *resultobj = 0;
14887 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14888 byte arg2 ;
14889 byte arg3 ;
14890 byte arg4 ;
14891 unsigned long result;
14892 void *argp1 = 0 ;
14893 int res1 = 0 ;
14894 unsigned char val2 ;
14895 int ecode2 = 0 ;
14896 unsigned char val3 ;
14897 int ecode3 = 0 ;
14898 unsigned char val4 ;
14899 int ecode4 = 0 ;
14900 PyObject * obj0 = 0 ;
14901 PyObject * obj1 = 0 ;
14902 PyObject * obj2 = 0 ;
14903 PyObject * obj3 = 0 ;
14904 char * kwnames[] = {
14905 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14906 };
14907
14908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14912 }
14913 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14914 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14915 if (!SWIG_IsOK(ecode2)) {
14916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
14917 }
14918 arg2 = static_cast< byte >(val2);
14919 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14920 if (!SWIG_IsOK(ecode3)) {
14921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
14922 }
14923 arg3 = static_cast< byte >(val3);
14924 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14925 if (!SWIG_IsOK(ecode4)) {
14926 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
14927 }
14928 arg4 = static_cast< byte >(val4);
14929 {
14930 PyThreadState* __tstate = wxPyBeginAllowThreads();
14931 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
14932 wxPyEndAllowThreads(__tstate);
14933 if (PyErr_Occurred()) SWIG_fail;
14934 }
14935 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14936 return resultobj;
14937 fail:
14938 return NULL;
14939 }
14940
14941
14942 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14943 PyObject *resultobj = 0;
14944 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14945 wxColour *arg2 = 0 ;
14946 unsigned long result;
14947 void *argp1 = 0 ;
14948 int res1 = 0 ;
14949 wxColour temp2 ;
14950 PyObject * obj0 = 0 ;
14951 PyObject * obj1 = 0 ;
14952 char * kwnames[] = {
14953 (char *) "self",(char *) "colour", NULL
14954 };
14955
14956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
14957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14958 if (!SWIG_IsOK(res1)) {
14959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14960 }
14961 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14962 {
14963 arg2 = &temp2;
14964 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14965 }
14966 {
14967 PyThreadState* __tstate = wxPyBeginAllowThreads();
14968 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
14969 wxPyEndAllowThreads(__tstate);
14970 if (PyErr_Occurred()) SWIG_fail;
14971 }
14972 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14973 return resultobj;
14974 fail:
14975 return NULL;
14976 }
14977
14978
14979 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14980 PyObject *obj;
14981 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14982 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
14983 return SWIG_Py_Void();
14984 }
14985
14986 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14987 return SWIG_Python_InitShadowInstance(args);
14988 }
14989
14990 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14991 PyObject *resultobj = 0;
14992 byte arg1 = (byte) 0 ;
14993 byte arg2 = (byte) 0 ;
14994 byte arg3 = (byte) 0 ;
14995 wxImage_RGBValue *result = 0 ;
14996 unsigned char val1 ;
14997 int ecode1 = 0 ;
14998 unsigned char val2 ;
14999 int ecode2 = 0 ;
15000 unsigned char val3 ;
15001 int ecode3 = 0 ;
15002 PyObject * obj0 = 0 ;
15003 PyObject * obj1 = 0 ;
15004 PyObject * obj2 = 0 ;
15005 char * kwnames[] = {
15006 (char *) "r",(char *) "g",(char *) "b", NULL
15007 };
15008
15009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15010 if (obj0) {
15011 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15012 if (!SWIG_IsOK(ecode1)) {
15013 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15014 }
15015 arg1 = static_cast< byte >(val1);
15016 }
15017 if (obj1) {
15018 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15019 if (!SWIG_IsOK(ecode2)) {
15020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15021 }
15022 arg2 = static_cast< byte >(val2);
15023 }
15024 if (obj2) {
15025 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15026 if (!SWIG_IsOK(ecode3)) {
15027 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15028 }
15029 arg3 = static_cast< byte >(val3);
15030 }
15031 {
15032 PyThreadState* __tstate = wxPyBeginAllowThreads();
15033 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15034 wxPyEndAllowThreads(__tstate);
15035 if (PyErr_Occurred()) SWIG_fail;
15036 }
15037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15038 return resultobj;
15039 fail:
15040 return NULL;
15041 }
15042
15043
15044 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15045 PyObject *resultobj = 0;
15046 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15047 byte arg2 ;
15048 void *argp1 = 0 ;
15049 int res1 = 0 ;
15050 unsigned char val2 ;
15051 int ecode2 = 0 ;
15052 PyObject *swig_obj[2] ;
15053
15054 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15056 if (!SWIG_IsOK(res1)) {
15057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15058 }
15059 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15060 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15061 if (!SWIG_IsOK(ecode2)) {
15062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15063 }
15064 arg2 = static_cast< byte >(val2);
15065 if (arg1) (arg1)->red = arg2;
15066
15067 resultobj = SWIG_Py_Void();
15068 return resultobj;
15069 fail:
15070 return NULL;
15071 }
15072
15073
15074 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15075 PyObject *resultobj = 0;
15076 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15077 byte result;
15078 void *argp1 = 0 ;
15079 int res1 = 0 ;
15080 PyObject *swig_obj[1] ;
15081
15082 if (!args) SWIG_fail;
15083 swig_obj[0] = args;
15084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15085 if (!SWIG_IsOK(res1)) {
15086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15087 }
15088 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15089 result = (byte) ((arg1)->red);
15090 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15091 return resultobj;
15092 fail:
15093 return NULL;
15094 }
15095
15096
15097 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15098 PyObject *resultobj = 0;
15099 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15100 byte arg2 ;
15101 void *argp1 = 0 ;
15102 int res1 = 0 ;
15103 unsigned char val2 ;
15104 int ecode2 = 0 ;
15105 PyObject *swig_obj[2] ;
15106
15107 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15109 if (!SWIG_IsOK(res1)) {
15110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15111 }
15112 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15113 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15114 if (!SWIG_IsOK(ecode2)) {
15115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15116 }
15117 arg2 = static_cast< byte >(val2);
15118 if (arg1) (arg1)->green = arg2;
15119
15120 resultobj = SWIG_Py_Void();
15121 return resultobj;
15122 fail:
15123 return NULL;
15124 }
15125
15126
15127 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15128 PyObject *resultobj = 0;
15129 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15130 byte result;
15131 void *argp1 = 0 ;
15132 int res1 = 0 ;
15133 PyObject *swig_obj[1] ;
15134
15135 if (!args) SWIG_fail;
15136 swig_obj[0] = args;
15137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15138 if (!SWIG_IsOK(res1)) {
15139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15140 }
15141 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15142 result = (byte) ((arg1)->green);
15143 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15144 return resultobj;
15145 fail:
15146 return NULL;
15147 }
15148
15149
15150 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15151 PyObject *resultobj = 0;
15152 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15153 byte arg2 ;
15154 void *argp1 = 0 ;
15155 int res1 = 0 ;
15156 unsigned char val2 ;
15157 int ecode2 = 0 ;
15158 PyObject *swig_obj[2] ;
15159
15160 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15162 if (!SWIG_IsOK(res1)) {
15163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15164 }
15165 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15166 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15167 if (!SWIG_IsOK(ecode2)) {
15168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15169 }
15170 arg2 = static_cast< byte >(val2);
15171 if (arg1) (arg1)->blue = arg2;
15172
15173 resultobj = SWIG_Py_Void();
15174 return resultobj;
15175 fail:
15176 return NULL;
15177 }
15178
15179
15180 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15181 PyObject *resultobj = 0;
15182 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15183 byte result;
15184 void *argp1 = 0 ;
15185 int res1 = 0 ;
15186 PyObject *swig_obj[1] ;
15187
15188 if (!args) SWIG_fail;
15189 swig_obj[0] = args;
15190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15191 if (!SWIG_IsOK(res1)) {
15192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15193 }
15194 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15195 result = (byte) ((arg1)->blue);
15196 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15197 return resultobj;
15198 fail:
15199 return NULL;
15200 }
15201
15202
15203 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15204 PyObject *obj;
15205 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15206 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15207 return SWIG_Py_Void();
15208 }
15209
15210 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15211 return SWIG_Python_InitShadowInstance(args);
15212 }
15213
15214 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15215 PyObject *resultobj = 0;
15216 double arg1 = (double) 0.0 ;
15217 double arg2 = (double) 0.0 ;
15218 double arg3 = (double) 0.0 ;
15219 wxImage_HSVValue *result = 0 ;
15220 double val1 ;
15221 int ecode1 = 0 ;
15222 double val2 ;
15223 int ecode2 = 0 ;
15224 double val3 ;
15225 int ecode3 = 0 ;
15226 PyObject * obj0 = 0 ;
15227 PyObject * obj1 = 0 ;
15228 PyObject * obj2 = 0 ;
15229 char * kwnames[] = {
15230 (char *) "h",(char *) "s",(char *) "v", NULL
15231 };
15232
15233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15234 if (obj0) {
15235 ecode1 = SWIG_AsVal_double(obj0, &val1);
15236 if (!SWIG_IsOK(ecode1)) {
15237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15238 }
15239 arg1 = static_cast< double >(val1);
15240 }
15241 if (obj1) {
15242 ecode2 = SWIG_AsVal_double(obj1, &val2);
15243 if (!SWIG_IsOK(ecode2)) {
15244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15245 }
15246 arg2 = static_cast< double >(val2);
15247 }
15248 if (obj2) {
15249 ecode3 = SWIG_AsVal_double(obj2, &val3);
15250 if (!SWIG_IsOK(ecode3)) {
15251 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15252 }
15253 arg3 = static_cast< double >(val3);
15254 }
15255 {
15256 PyThreadState* __tstate = wxPyBeginAllowThreads();
15257 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15258 wxPyEndAllowThreads(__tstate);
15259 if (PyErr_Occurred()) SWIG_fail;
15260 }
15261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15262 return resultobj;
15263 fail:
15264 return NULL;
15265 }
15266
15267
15268 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15269 PyObject *resultobj = 0;
15270 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15271 double arg2 ;
15272 void *argp1 = 0 ;
15273 int res1 = 0 ;
15274 double val2 ;
15275 int ecode2 = 0 ;
15276 PyObject *swig_obj[2] ;
15277
15278 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15280 if (!SWIG_IsOK(res1)) {
15281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15282 }
15283 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15284 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15285 if (!SWIG_IsOK(ecode2)) {
15286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15287 }
15288 arg2 = static_cast< double >(val2);
15289 if (arg1) (arg1)->hue = arg2;
15290
15291 resultobj = SWIG_Py_Void();
15292 return resultobj;
15293 fail:
15294 return NULL;
15295 }
15296
15297
15298 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15299 PyObject *resultobj = 0;
15300 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15301 double result;
15302 void *argp1 = 0 ;
15303 int res1 = 0 ;
15304 PyObject *swig_obj[1] ;
15305
15306 if (!args) SWIG_fail;
15307 swig_obj[0] = args;
15308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15309 if (!SWIG_IsOK(res1)) {
15310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15311 }
15312 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15313 result = (double) ((arg1)->hue);
15314 resultobj = SWIG_From_double(static_cast< double >(result));
15315 return resultobj;
15316 fail:
15317 return NULL;
15318 }
15319
15320
15321 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15322 PyObject *resultobj = 0;
15323 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15324 double arg2 ;
15325 void *argp1 = 0 ;
15326 int res1 = 0 ;
15327 double val2 ;
15328 int ecode2 = 0 ;
15329 PyObject *swig_obj[2] ;
15330
15331 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15333 if (!SWIG_IsOK(res1)) {
15334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15335 }
15336 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15337 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15338 if (!SWIG_IsOK(ecode2)) {
15339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15340 }
15341 arg2 = static_cast< double >(val2);
15342 if (arg1) (arg1)->saturation = arg2;
15343
15344 resultobj = SWIG_Py_Void();
15345 return resultobj;
15346 fail:
15347 return NULL;
15348 }
15349
15350
15351 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15352 PyObject *resultobj = 0;
15353 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15354 double result;
15355 void *argp1 = 0 ;
15356 int res1 = 0 ;
15357 PyObject *swig_obj[1] ;
15358
15359 if (!args) SWIG_fail;
15360 swig_obj[0] = args;
15361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15362 if (!SWIG_IsOK(res1)) {
15363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15364 }
15365 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15366 result = (double) ((arg1)->saturation);
15367 resultobj = SWIG_From_double(static_cast< double >(result));
15368 return resultobj;
15369 fail:
15370 return NULL;
15371 }
15372
15373
15374 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15375 PyObject *resultobj = 0;
15376 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15377 double arg2 ;
15378 void *argp1 = 0 ;
15379 int res1 = 0 ;
15380 double val2 ;
15381 int ecode2 = 0 ;
15382 PyObject *swig_obj[2] ;
15383
15384 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15386 if (!SWIG_IsOK(res1)) {
15387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15388 }
15389 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15390 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15391 if (!SWIG_IsOK(ecode2)) {
15392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15393 }
15394 arg2 = static_cast< double >(val2);
15395 if (arg1) (arg1)->value = arg2;
15396
15397 resultobj = SWIG_Py_Void();
15398 return resultobj;
15399 fail:
15400 return NULL;
15401 }
15402
15403
15404 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15405 PyObject *resultobj = 0;
15406 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15407 double result;
15408 void *argp1 = 0 ;
15409 int res1 = 0 ;
15410 PyObject *swig_obj[1] ;
15411
15412 if (!args) SWIG_fail;
15413 swig_obj[0] = args;
15414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15415 if (!SWIG_IsOK(res1)) {
15416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15417 }
15418 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15419 result = (double) ((arg1)->value);
15420 resultobj = SWIG_From_double(static_cast< double >(result));
15421 return resultobj;
15422 fail:
15423 return NULL;
15424 }
15425
15426
15427 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15428 PyObject *obj;
15429 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15430 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15431 return SWIG_Py_Void();
15432 }
15433
15434 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15435 return SWIG_Python_InitShadowInstance(args);
15436 }
15437
15438 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15439 PyObject *resultobj = 0;
15440 wxString *arg1 = 0 ;
15441 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15442 int arg3 = (int) -1 ;
15443 wxImage *result = 0 ;
15444 bool temp1 = false ;
15445 long val2 ;
15446 int ecode2 = 0 ;
15447 int val3 ;
15448 int ecode3 = 0 ;
15449 PyObject * obj0 = 0 ;
15450 PyObject * obj1 = 0 ;
15451 PyObject * obj2 = 0 ;
15452 char * kwnames[] = {
15453 (char *) "name",(char *) "type",(char *) "index", NULL
15454 };
15455
15456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15457 {
15458 arg1 = wxString_in_helper(obj0);
15459 if (arg1 == NULL) SWIG_fail;
15460 temp1 = true;
15461 }
15462 if (obj1) {
15463 ecode2 = SWIG_AsVal_long(obj1, &val2);
15464 if (!SWIG_IsOK(ecode2)) {
15465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15466 }
15467 arg2 = static_cast< long >(val2);
15468 }
15469 if (obj2) {
15470 ecode3 = SWIG_AsVal_int(obj2, &val3);
15471 if (!SWIG_IsOK(ecode3)) {
15472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15473 }
15474 arg3 = static_cast< int >(val3);
15475 }
15476 {
15477 PyThreadState* __tstate = wxPyBeginAllowThreads();
15478 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15479 wxPyEndAllowThreads(__tstate);
15480 if (PyErr_Occurred()) SWIG_fail;
15481 }
15482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15483 {
15484 if (temp1)
15485 delete arg1;
15486 }
15487 return resultobj;
15488 fail:
15489 {
15490 if (temp1)
15491 delete arg1;
15492 }
15493 return NULL;
15494 }
15495
15496
15497 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15498 PyObject *resultobj = 0;
15499 wxImage *arg1 = (wxImage *) 0 ;
15500 void *argp1 = 0 ;
15501 int res1 = 0 ;
15502 PyObject *swig_obj[1] ;
15503
15504 if (!args) SWIG_fail;
15505 swig_obj[0] = args;
15506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15507 if (!SWIG_IsOK(res1)) {
15508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15509 }
15510 arg1 = reinterpret_cast< wxImage * >(argp1);
15511 {
15512 PyThreadState* __tstate = wxPyBeginAllowThreads();
15513 delete arg1;
15514
15515 wxPyEndAllowThreads(__tstate);
15516 if (PyErr_Occurred()) SWIG_fail;
15517 }
15518 resultobj = SWIG_Py_Void();
15519 return resultobj;
15520 fail:
15521 return NULL;
15522 }
15523
15524
15525 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15526 PyObject *resultobj = 0;
15527 wxString *arg1 = 0 ;
15528 wxString *arg2 = 0 ;
15529 int arg3 = (int) -1 ;
15530 wxImage *result = 0 ;
15531 bool temp1 = false ;
15532 bool temp2 = false ;
15533 int val3 ;
15534 int ecode3 = 0 ;
15535 PyObject * obj0 = 0 ;
15536 PyObject * obj1 = 0 ;
15537 PyObject * obj2 = 0 ;
15538 char * kwnames[] = {
15539 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15540 };
15541
15542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15543 {
15544 arg1 = wxString_in_helper(obj0);
15545 if (arg1 == NULL) SWIG_fail;
15546 temp1 = true;
15547 }
15548 {
15549 arg2 = wxString_in_helper(obj1);
15550 if (arg2 == NULL) SWIG_fail;
15551 temp2 = true;
15552 }
15553 if (obj2) {
15554 ecode3 = SWIG_AsVal_int(obj2, &val3);
15555 if (!SWIG_IsOK(ecode3)) {
15556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15557 }
15558 arg3 = static_cast< int >(val3);
15559 }
15560 {
15561 PyThreadState* __tstate = wxPyBeginAllowThreads();
15562 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15563 wxPyEndAllowThreads(__tstate);
15564 if (PyErr_Occurred()) SWIG_fail;
15565 }
15566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15567 {
15568 if (temp1)
15569 delete arg1;
15570 }
15571 {
15572 if (temp2)
15573 delete arg2;
15574 }
15575 return resultobj;
15576 fail:
15577 {
15578 if (temp1)
15579 delete arg1;
15580 }
15581 {
15582 if (temp2)
15583 delete arg2;
15584 }
15585 return NULL;
15586 }
15587
15588
15589 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15590 PyObject *resultobj = 0;
15591 wxInputStream *arg1 = 0 ;
15592 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15593 int arg3 = (int) -1 ;
15594 wxImage *result = 0 ;
15595 wxPyInputStream *temp1 ;
15596 bool created1 ;
15597 long val2 ;
15598 int ecode2 = 0 ;
15599 int val3 ;
15600 int ecode3 = 0 ;
15601 PyObject * obj0 = 0 ;
15602 PyObject * obj1 = 0 ;
15603 PyObject * obj2 = 0 ;
15604 char * kwnames[] = {
15605 (char *) "stream",(char *) "type",(char *) "index", NULL
15606 };
15607
15608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15609 {
15610 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15611 arg1 = temp1->m_wxis;
15612 created1 = false;
15613 } else {
15614 PyErr_Clear(); // clear the failure of the wxPyConvert above
15615 arg1 = wxPyCBInputStream_create(obj0, false);
15616 if (arg1 == NULL) {
15617 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15618 SWIG_fail;
15619 }
15620 created1 = true;
15621 }
15622 }
15623 if (obj1) {
15624 ecode2 = SWIG_AsVal_long(obj1, &val2);
15625 if (!SWIG_IsOK(ecode2)) {
15626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15627 }
15628 arg2 = static_cast< long >(val2);
15629 }
15630 if (obj2) {
15631 ecode3 = SWIG_AsVal_int(obj2, &val3);
15632 if (!SWIG_IsOK(ecode3)) {
15633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15634 }
15635 arg3 = static_cast< int >(val3);
15636 }
15637 {
15638 PyThreadState* __tstate = wxPyBeginAllowThreads();
15639 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15640 wxPyEndAllowThreads(__tstate);
15641 if (PyErr_Occurred()) SWIG_fail;
15642 }
15643 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15644 {
15645 if (created1) delete arg1;
15646 }
15647 return resultobj;
15648 fail:
15649 {
15650 if (created1) delete arg1;
15651 }
15652 return NULL;
15653 }
15654
15655
15656 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15657 PyObject *resultobj = 0;
15658 wxInputStream *arg1 = 0 ;
15659 wxString *arg2 = 0 ;
15660 int arg3 = (int) -1 ;
15661 wxImage *result = 0 ;
15662 wxPyInputStream *temp1 ;
15663 bool created1 ;
15664 bool temp2 = false ;
15665 int val3 ;
15666 int ecode3 = 0 ;
15667 PyObject * obj0 = 0 ;
15668 PyObject * obj1 = 0 ;
15669 PyObject * obj2 = 0 ;
15670 char * kwnames[] = {
15671 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15672 };
15673
15674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15675 {
15676 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15677 arg1 = temp1->m_wxis;
15678 created1 = false;
15679 } else {
15680 PyErr_Clear(); // clear the failure of the wxPyConvert above
15681 arg1 = wxPyCBInputStream_create(obj0, false);
15682 if (arg1 == NULL) {
15683 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15684 SWIG_fail;
15685 }
15686 created1 = true;
15687 }
15688 }
15689 {
15690 arg2 = wxString_in_helper(obj1);
15691 if (arg2 == NULL) SWIG_fail;
15692 temp2 = true;
15693 }
15694 if (obj2) {
15695 ecode3 = SWIG_AsVal_int(obj2, &val3);
15696 if (!SWIG_IsOK(ecode3)) {
15697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15698 }
15699 arg3 = static_cast< int >(val3);
15700 }
15701 {
15702 PyThreadState* __tstate = wxPyBeginAllowThreads();
15703 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15704 wxPyEndAllowThreads(__tstate);
15705 if (PyErr_Occurred()) SWIG_fail;
15706 }
15707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15708 {
15709 if (created1) delete arg1;
15710 }
15711 {
15712 if (temp2)
15713 delete arg2;
15714 }
15715 return resultobj;
15716 fail:
15717 {
15718 if (created1) delete arg1;
15719 }
15720 {
15721 if (temp2)
15722 delete arg2;
15723 }
15724 return NULL;
15725 }
15726
15727
15728 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15729 PyObject *resultobj = 0;
15730 int arg1 = (int) 0 ;
15731 int arg2 = (int) 0 ;
15732 bool arg3 = (bool) true ;
15733 wxImage *result = 0 ;
15734 int val1 ;
15735 int ecode1 = 0 ;
15736 int val2 ;
15737 int ecode2 = 0 ;
15738 bool val3 ;
15739 int ecode3 = 0 ;
15740 PyObject * obj0 = 0 ;
15741 PyObject * obj1 = 0 ;
15742 PyObject * obj2 = 0 ;
15743 char * kwnames[] = {
15744 (char *) "width",(char *) "height",(char *) "clear", NULL
15745 };
15746
15747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15748 if (obj0) {
15749 ecode1 = SWIG_AsVal_int(obj0, &val1);
15750 if (!SWIG_IsOK(ecode1)) {
15751 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15752 }
15753 arg1 = static_cast< int >(val1);
15754 }
15755 if (obj1) {
15756 ecode2 = SWIG_AsVal_int(obj1, &val2);
15757 if (!SWIG_IsOK(ecode2)) {
15758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15759 }
15760 arg2 = static_cast< int >(val2);
15761 }
15762 if (obj2) {
15763 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15764 if (!SWIG_IsOK(ecode3)) {
15765 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15766 }
15767 arg3 = static_cast< bool >(val3);
15768 }
15769 {
15770 PyThreadState* __tstate = wxPyBeginAllowThreads();
15771 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15772 wxPyEndAllowThreads(__tstate);
15773 if (PyErr_Occurred()) SWIG_fail;
15774 }
15775 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15776 return resultobj;
15777 fail:
15778 return NULL;
15779 }
15780
15781
15782 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15783 PyObject *resultobj = 0;
15784 wxBitmap *arg1 = 0 ;
15785 wxImage *result = 0 ;
15786 void *argp1 = 0 ;
15787 int res1 = 0 ;
15788 PyObject * obj0 = 0 ;
15789 char * kwnames[] = {
15790 (char *) "bitmap", NULL
15791 };
15792
15793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15794 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15795 if (!SWIG_IsOK(res1)) {
15796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15797 }
15798 if (!argp1) {
15799 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15800 }
15801 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15802 {
15803 if (!wxPyCheckForApp()) SWIG_fail;
15804 PyThreadState* __tstate = wxPyBeginAllowThreads();
15805 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15806 wxPyEndAllowThreads(__tstate);
15807 if (PyErr_Occurred()) SWIG_fail;
15808 }
15809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15810 return resultobj;
15811 fail:
15812 return NULL;
15813 }
15814
15815
15816 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15817 PyObject *resultobj = 0;
15818 int arg1 ;
15819 int arg2 ;
15820 buffer arg3 ;
15821 int arg4 ;
15822 wxImage *result = 0 ;
15823 int val1 ;
15824 int ecode1 = 0 ;
15825 int val2 ;
15826 int ecode2 = 0 ;
15827 Py_ssize_t temp3 ;
15828 PyObject * obj0 = 0 ;
15829 PyObject * obj1 = 0 ;
15830 PyObject * obj2 = 0 ;
15831 char * kwnames[] = {
15832 (char *) "width",(char *) "height",(char *) "data", NULL
15833 };
15834
15835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15836 ecode1 = SWIG_AsVal_int(obj0, &val1);
15837 if (!SWIG_IsOK(ecode1)) {
15838 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15839 }
15840 arg1 = static_cast< int >(val1);
15841 ecode2 = SWIG_AsVal_int(obj1, &val2);
15842 if (!SWIG_IsOK(ecode2)) {
15843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15844 }
15845 arg2 = static_cast< int >(val2);
15846 {
15847 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15848 arg4 = (int)temp3;
15849 }
15850 {
15851 PyThreadState* __tstate = wxPyBeginAllowThreads();
15852 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
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_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15864 PyObject *resultobj = 0;
15865 int arg1 ;
15866 int arg2 ;
15867 buffer arg3 ;
15868 int arg4 ;
15869 buffer arg5 ;
15870 int arg6 ;
15871 wxImage *result = 0 ;
15872 int val1 ;
15873 int ecode1 = 0 ;
15874 int val2 ;
15875 int ecode2 = 0 ;
15876 Py_ssize_t temp3 ;
15877 Py_ssize_t temp5 ;
15878 PyObject * obj0 = 0 ;
15879 PyObject * obj1 = 0 ;
15880 PyObject * obj2 = 0 ;
15881 PyObject * obj3 = 0 ;
15882 char * kwnames[] = {
15883 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
15884 };
15885
15886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15887 ecode1 = SWIG_AsVal_int(obj0, &val1);
15888 if (!SWIG_IsOK(ecode1)) {
15889 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
15890 }
15891 arg1 = static_cast< int >(val1);
15892 ecode2 = SWIG_AsVal_int(obj1, &val2);
15893 if (!SWIG_IsOK(ecode2)) {
15894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
15895 }
15896 arg2 = static_cast< int >(val2);
15897 {
15898 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15899 arg4 = (int)temp3;
15900 }
15901 {
15902 if (obj3 != Py_None) {
15903 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
15904 arg6 = (int)temp5;
15905 }
15906 }
15907 {
15908 PyThreadState* __tstate = wxPyBeginAllowThreads();
15909 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
15910 wxPyEndAllowThreads(__tstate);
15911 if (PyErr_Occurred()) SWIG_fail;
15912 }
15913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15914 return resultobj;
15915 fail:
15916 return NULL;
15917 }
15918
15919
15920 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15921 PyObject *resultobj = 0;
15922 wxImage *arg1 = (wxImage *) 0 ;
15923 int arg2 ;
15924 int arg3 ;
15925 bool arg4 = (bool) true ;
15926 void *argp1 = 0 ;
15927 int res1 = 0 ;
15928 int val2 ;
15929 int ecode2 = 0 ;
15930 int val3 ;
15931 int ecode3 = 0 ;
15932 bool val4 ;
15933 int ecode4 = 0 ;
15934 PyObject * obj0 = 0 ;
15935 PyObject * obj1 = 0 ;
15936 PyObject * obj2 = 0 ;
15937 PyObject * obj3 = 0 ;
15938 char * kwnames[] = {
15939 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
15940 };
15941
15942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15944 if (!SWIG_IsOK(res1)) {
15945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
15946 }
15947 arg1 = reinterpret_cast< wxImage * >(argp1);
15948 ecode2 = SWIG_AsVal_int(obj1, &val2);
15949 if (!SWIG_IsOK(ecode2)) {
15950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
15951 }
15952 arg2 = static_cast< int >(val2);
15953 ecode3 = SWIG_AsVal_int(obj2, &val3);
15954 if (!SWIG_IsOK(ecode3)) {
15955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
15956 }
15957 arg3 = static_cast< int >(val3);
15958 if (obj3) {
15959 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15960 if (!SWIG_IsOK(ecode4)) {
15961 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
15962 }
15963 arg4 = static_cast< bool >(val4);
15964 }
15965 {
15966 PyThreadState* __tstate = wxPyBeginAllowThreads();
15967 (arg1)->Create(arg2,arg3,arg4);
15968 wxPyEndAllowThreads(__tstate);
15969 if (PyErr_Occurred()) SWIG_fail;
15970 }
15971 resultobj = SWIG_Py_Void();
15972 return resultobj;
15973 fail:
15974 return NULL;
15975 }
15976
15977
15978 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15979 PyObject *resultobj = 0;
15980 wxImage *arg1 = (wxImage *) 0 ;
15981 void *argp1 = 0 ;
15982 int res1 = 0 ;
15983 PyObject *swig_obj[1] ;
15984
15985 if (!args) SWIG_fail;
15986 swig_obj[0] = args;
15987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15988 if (!SWIG_IsOK(res1)) {
15989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
15990 }
15991 arg1 = reinterpret_cast< wxImage * >(argp1);
15992 {
15993 PyThreadState* __tstate = wxPyBeginAllowThreads();
15994 (arg1)->Destroy();
15995 wxPyEndAllowThreads(__tstate);
15996 if (PyErr_Occurred()) SWIG_fail;
15997 }
15998 resultobj = SWIG_Py_Void();
15999 return resultobj;
16000 fail:
16001 return NULL;
16002 }
16003
16004
16005 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16006 PyObject *resultobj = 0;
16007 wxImage *arg1 = (wxImage *) 0 ;
16008 int arg2 ;
16009 int arg3 ;
16010 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16011 SwigValueWrapper<wxImage > result;
16012 void *argp1 = 0 ;
16013 int res1 = 0 ;
16014 int val2 ;
16015 int ecode2 = 0 ;
16016 int val3 ;
16017 int ecode3 = 0 ;
16018 int val4 ;
16019 int ecode4 = 0 ;
16020 PyObject * obj0 = 0 ;
16021 PyObject * obj1 = 0 ;
16022 PyObject * obj2 = 0 ;
16023 PyObject * obj3 = 0 ;
16024 char * kwnames[] = {
16025 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16026 };
16027
16028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16030 if (!SWIG_IsOK(res1)) {
16031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16032 }
16033 arg1 = reinterpret_cast< wxImage * >(argp1);
16034 ecode2 = SWIG_AsVal_int(obj1, &val2);
16035 if (!SWIG_IsOK(ecode2)) {
16036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16037 }
16038 arg2 = static_cast< int >(val2);
16039 ecode3 = SWIG_AsVal_int(obj2, &val3);
16040 if (!SWIG_IsOK(ecode3)) {
16041 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16042 }
16043 arg3 = static_cast< int >(val3);
16044 if (obj3) {
16045 ecode4 = SWIG_AsVal_int(obj3, &val4);
16046 if (!SWIG_IsOK(ecode4)) {
16047 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16048 }
16049 arg4 = static_cast< int >(val4);
16050 }
16051 {
16052 PyThreadState* __tstate = wxPyBeginAllowThreads();
16053 result = (arg1)->Scale(arg2,arg3,arg4);
16054 wxPyEndAllowThreads(__tstate);
16055 if (PyErr_Occurred()) SWIG_fail;
16056 }
16057 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16058 return resultobj;
16059 fail:
16060 return NULL;
16061 }
16062
16063
16064 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16065 PyObject *resultobj = 0;
16066 wxImage *arg1 = (wxImage *) 0 ;
16067 int arg2 ;
16068 int arg3 ;
16069 SwigValueWrapper<wxImage > result;
16070 void *argp1 = 0 ;
16071 int res1 = 0 ;
16072 int val2 ;
16073 int ecode2 = 0 ;
16074 int val3 ;
16075 int ecode3 = 0 ;
16076 PyObject * obj0 = 0 ;
16077 PyObject * obj1 = 0 ;
16078 PyObject * obj2 = 0 ;
16079 char * kwnames[] = {
16080 (char *) "self",(char *) "width",(char *) "height", NULL
16081 };
16082
16083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16085 if (!SWIG_IsOK(res1)) {
16086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16087 }
16088 arg1 = reinterpret_cast< wxImage * >(argp1);
16089 ecode2 = SWIG_AsVal_int(obj1, &val2);
16090 if (!SWIG_IsOK(ecode2)) {
16091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16092 }
16093 arg2 = static_cast< int >(val2);
16094 ecode3 = SWIG_AsVal_int(obj2, &val3);
16095 if (!SWIG_IsOK(ecode3)) {
16096 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16097 }
16098 arg3 = static_cast< int >(val3);
16099 {
16100 PyThreadState* __tstate = wxPyBeginAllowThreads();
16101 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16102 wxPyEndAllowThreads(__tstate);
16103 if (PyErr_Occurred()) SWIG_fail;
16104 }
16105 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16106 return resultobj;
16107 fail:
16108 return NULL;
16109 }
16110
16111
16112 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16113 PyObject *resultobj = 0;
16114 wxImage *arg1 = (wxImage *) 0 ;
16115 int arg2 ;
16116 int arg3 ;
16117 SwigValueWrapper<wxImage > result;
16118 void *argp1 = 0 ;
16119 int res1 = 0 ;
16120 int val2 ;
16121 int ecode2 = 0 ;
16122 int val3 ;
16123 int ecode3 = 0 ;
16124 PyObject * obj0 = 0 ;
16125 PyObject * obj1 = 0 ;
16126 PyObject * obj2 = 0 ;
16127 char * kwnames[] = {
16128 (char *) "self",(char *) "width",(char *) "height", NULL
16129 };
16130
16131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16133 if (!SWIG_IsOK(res1)) {
16134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16135 }
16136 arg1 = reinterpret_cast< wxImage * >(argp1);
16137 ecode2 = SWIG_AsVal_int(obj1, &val2);
16138 if (!SWIG_IsOK(ecode2)) {
16139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16140 }
16141 arg2 = static_cast< int >(val2);
16142 ecode3 = SWIG_AsVal_int(obj2, &val3);
16143 if (!SWIG_IsOK(ecode3)) {
16144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16145 }
16146 arg3 = static_cast< int >(val3);
16147 {
16148 PyThreadState* __tstate = wxPyBeginAllowThreads();
16149 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16150 wxPyEndAllowThreads(__tstate);
16151 if (PyErr_Occurred()) SWIG_fail;
16152 }
16153 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16154 return resultobj;
16155 fail:
16156 return NULL;
16157 }
16158
16159
16160 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16161 PyObject *resultobj = 0;
16162 wxImage *arg1 = (wxImage *) 0 ;
16163 int arg2 ;
16164 SwigValueWrapper<wxImage > result;
16165 void *argp1 = 0 ;
16166 int res1 = 0 ;
16167 int val2 ;
16168 int ecode2 = 0 ;
16169 PyObject * obj0 = 0 ;
16170 PyObject * obj1 = 0 ;
16171 char * kwnames[] = {
16172 (char *) "self",(char *) "radius", NULL
16173 };
16174
16175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16177 if (!SWIG_IsOK(res1)) {
16178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16179 }
16180 arg1 = reinterpret_cast< wxImage * >(argp1);
16181 ecode2 = SWIG_AsVal_int(obj1, &val2);
16182 if (!SWIG_IsOK(ecode2)) {
16183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16184 }
16185 arg2 = static_cast< int >(val2);
16186 {
16187 PyThreadState* __tstate = wxPyBeginAllowThreads();
16188 result = (arg1)->Blur(arg2);
16189 wxPyEndAllowThreads(__tstate);
16190 if (PyErr_Occurred()) SWIG_fail;
16191 }
16192 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16193 return resultobj;
16194 fail:
16195 return NULL;
16196 }
16197
16198
16199 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16200 PyObject *resultobj = 0;
16201 wxImage *arg1 = (wxImage *) 0 ;
16202 int arg2 ;
16203 SwigValueWrapper<wxImage > result;
16204 void *argp1 = 0 ;
16205 int res1 = 0 ;
16206 int val2 ;
16207 int ecode2 = 0 ;
16208 PyObject * obj0 = 0 ;
16209 PyObject * obj1 = 0 ;
16210 char * kwnames[] = {
16211 (char *) "self",(char *) "radius", NULL
16212 };
16213
16214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16216 if (!SWIG_IsOK(res1)) {
16217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16218 }
16219 arg1 = reinterpret_cast< wxImage * >(argp1);
16220 ecode2 = SWIG_AsVal_int(obj1, &val2);
16221 if (!SWIG_IsOK(ecode2)) {
16222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16223 }
16224 arg2 = static_cast< int >(val2);
16225 {
16226 PyThreadState* __tstate = wxPyBeginAllowThreads();
16227 result = (arg1)->BlurHorizontal(arg2);
16228 wxPyEndAllowThreads(__tstate);
16229 if (PyErr_Occurred()) SWIG_fail;
16230 }
16231 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16232 return resultobj;
16233 fail:
16234 return NULL;
16235 }
16236
16237
16238 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16239 PyObject *resultobj = 0;
16240 wxImage *arg1 = (wxImage *) 0 ;
16241 int arg2 ;
16242 SwigValueWrapper<wxImage > result;
16243 void *argp1 = 0 ;
16244 int res1 = 0 ;
16245 int val2 ;
16246 int ecode2 = 0 ;
16247 PyObject * obj0 = 0 ;
16248 PyObject * obj1 = 0 ;
16249 char * kwnames[] = {
16250 (char *) "self",(char *) "radius", NULL
16251 };
16252
16253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16255 if (!SWIG_IsOK(res1)) {
16256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16257 }
16258 arg1 = reinterpret_cast< wxImage * >(argp1);
16259 ecode2 = SWIG_AsVal_int(obj1, &val2);
16260 if (!SWIG_IsOK(ecode2)) {
16261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16262 }
16263 arg2 = static_cast< int >(val2);
16264 {
16265 PyThreadState* __tstate = wxPyBeginAllowThreads();
16266 result = (arg1)->BlurVertical(arg2);
16267 wxPyEndAllowThreads(__tstate);
16268 if (PyErr_Occurred()) SWIG_fail;
16269 }
16270 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16271 return resultobj;
16272 fail:
16273 return NULL;
16274 }
16275
16276
16277 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16278 PyObject *resultobj = 0;
16279 wxImage *arg1 = (wxImage *) 0 ;
16280 int arg2 ;
16281 int arg3 ;
16282 SwigValueWrapper<wxImage > result;
16283 void *argp1 = 0 ;
16284 int res1 = 0 ;
16285 int val2 ;
16286 int ecode2 = 0 ;
16287 int val3 ;
16288 int ecode3 = 0 ;
16289 PyObject * obj0 = 0 ;
16290 PyObject * obj1 = 0 ;
16291 PyObject * obj2 = 0 ;
16292 char * kwnames[] = {
16293 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16294 };
16295
16296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16298 if (!SWIG_IsOK(res1)) {
16299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16300 }
16301 arg1 = reinterpret_cast< wxImage * >(argp1);
16302 ecode2 = SWIG_AsVal_int(obj1, &val2);
16303 if (!SWIG_IsOK(ecode2)) {
16304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16305 }
16306 arg2 = static_cast< int >(val2);
16307 ecode3 = SWIG_AsVal_int(obj2, &val3);
16308 if (!SWIG_IsOK(ecode3)) {
16309 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16310 }
16311 arg3 = static_cast< int >(val3);
16312 {
16313 PyThreadState* __tstate = wxPyBeginAllowThreads();
16314 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16315 wxPyEndAllowThreads(__tstate);
16316 if (PyErr_Occurred()) SWIG_fail;
16317 }
16318 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16319 return resultobj;
16320 fail:
16321 return NULL;
16322 }
16323
16324
16325 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16326 PyObject *resultobj = 0;
16327 wxImage *arg1 = (wxImage *) 0 ;
16328 int arg2 ;
16329 int arg3 ;
16330 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16331 wxImage *result = 0 ;
16332 void *argp1 = 0 ;
16333 int res1 = 0 ;
16334 int val2 ;
16335 int ecode2 = 0 ;
16336 int val3 ;
16337 int ecode3 = 0 ;
16338 int val4 ;
16339 int ecode4 = 0 ;
16340 PyObject * obj0 = 0 ;
16341 PyObject * obj1 = 0 ;
16342 PyObject * obj2 = 0 ;
16343 PyObject * obj3 = 0 ;
16344 char * kwnames[] = {
16345 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16346 };
16347
16348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16350 if (!SWIG_IsOK(res1)) {
16351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16352 }
16353 arg1 = reinterpret_cast< wxImage * >(argp1);
16354 ecode2 = SWIG_AsVal_int(obj1, &val2);
16355 if (!SWIG_IsOK(ecode2)) {
16356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16357 }
16358 arg2 = static_cast< int >(val2);
16359 ecode3 = SWIG_AsVal_int(obj2, &val3);
16360 if (!SWIG_IsOK(ecode3)) {
16361 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16362 }
16363 arg3 = static_cast< int >(val3);
16364 if (obj3) {
16365 ecode4 = SWIG_AsVal_int(obj3, &val4);
16366 if (!SWIG_IsOK(ecode4)) {
16367 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16368 }
16369 arg4 = static_cast< int >(val4);
16370 }
16371 {
16372 PyThreadState* __tstate = wxPyBeginAllowThreads();
16373 {
16374 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
16375 result = (wxImage *) &_result_ref;
16376 }
16377 wxPyEndAllowThreads(__tstate);
16378 if (PyErr_Occurred()) SWIG_fail;
16379 }
16380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16381 return resultobj;
16382 fail:
16383 return NULL;
16384 }
16385
16386
16387 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16388 PyObject *resultobj = 0;
16389 wxImage *arg1 = (wxImage *) 0 ;
16390 wxSize *arg2 = 0 ;
16391 wxPoint *arg3 = 0 ;
16392 int arg4 = (int) -1 ;
16393 int arg5 = (int) -1 ;
16394 int arg6 = (int) -1 ;
16395 wxImage *result = 0 ;
16396 void *argp1 = 0 ;
16397 int res1 = 0 ;
16398 wxSize temp2 ;
16399 wxPoint temp3 ;
16400 int val4 ;
16401 int ecode4 = 0 ;
16402 int val5 ;
16403 int ecode5 = 0 ;
16404 int val6 ;
16405 int ecode6 = 0 ;
16406 PyObject * obj0 = 0 ;
16407 PyObject * obj1 = 0 ;
16408 PyObject * obj2 = 0 ;
16409 PyObject * obj3 = 0 ;
16410 PyObject * obj4 = 0 ;
16411 PyObject * obj5 = 0 ;
16412 char * kwnames[] = {
16413 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16414 };
16415
16416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16418 if (!SWIG_IsOK(res1)) {
16419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16420 }
16421 arg1 = reinterpret_cast< wxImage * >(argp1);
16422 {
16423 arg2 = &temp2;
16424 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16425 }
16426 {
16427 arg3 = &temp3;
16428 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16429 }
16430 if (obj3) {
16431 ecode4 = SWIG_AsVal_int(obj3, &val4);
16432 if (!SWIG_IsOK(ecode4)) {
16433 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16434 }
16435 arg4 = static_cast< int >(val4);
16436 }
16437 if (obj4) {
16438 ecode5 = SWIG_AsVal_int(obj4, &val5);
16439 if (!SWIG_IsOK(ecode5)) {
16440 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16441 }
16442 arg5 = static_cast< int >(val5);
16443 }
16444 if (obj5) {
16445 ecode6 = SWIG_AsVal_int(obj5, &val6);
16446 if (!SWIG_IsOK(ecode6)) {
16447 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16448 }
16449 arg6 = static_cast< int >(val6);
16450 }
16451 {
16452 PyThreadState* __tstate = wxPyBeginAllowThreads();
16453 {
16454 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16455 result = (wxImage *) &_result_ref;
16456 }
16457 wxPyEndAllowThreads(__tstate);
16458 if (PyErr_Occurred()) SWIG_fail;
16459 }
16460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16461 return resultobj;
16462 fail:
16463 return NULL;
16464 }
16465
16466
16467 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16468 PyObject *resultobj = 0;
16469 wxImage *arg1 = (wxImage *) 0 ;
16470 int arg2 ;
16471 int arg3 ;
16472 byte arg4 ;
16473 byte arg5 ;
16474 byte arg6 ;
16475 void *argp1 = 0 ;
16476 int res1 = 0 ;
16477 int val2 ;
16478 int ecode2 = 0 ;
16479 int val3 ;
16480 int ecode3 = 0 ;
16481 unsigned char val4 ;
16482 int ecode4 = 0 ;
16483 unsigned char val5 ;
16484 int ecode5 = 0 ;
16485 unsigned char val6 ;
16486 int ecode6 = 0 ;
16487 PyObject * obj0 = 0 ;
16488 PyObject * obj1 = 0 ;
16489 PyObject * obj2 = 0 ;
16490 PyObject * obj3 = 0 ;
16491 PyObject * obj4 = 0 ;
16492 PyObject * obj5 = 0 ;
16493 char * kwnames[] = {
16494 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16495 };
16496
16497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16499 if (!SWIG_IsOK(res1)) {
16500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16501 }
16502 arg1 = reinterpret_cast< wxImage * >(argp1);
16503 ecode2 = SWIG_AsVal_int(obj1, &val2);
16504 if (!SWIG_IsOK(ecode2)) {
16505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16506 }
16507 arg2 = static_cast< int >(val2);
16508 ecode3 = SWIG_AsVal_int(obj2, &val3);
16509 if (!SWIG_IsOK(ecode3)) {
16510 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16511 }
16512 arg3 = static_cast< int >(val3);
16513 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16514 if (!SWIG_IsOK(ecode4)) {
16515 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16516 }
16517 arg4 = static_cast< byte >(val4);
16518 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16519 if (!SWIG_IsOK(ecode5)) {
16520 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16521 }
16522 arg5 = static_cast< byte >(val5);
16523 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16524 if (!SWIG_IsOK(ecode6)) {
16525 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16526 }
16527 arg6 = static_cast< byte >(val6);
16528 {
16529 PyThreadState* __tstate = wxPyBeginAllowThreads();
16530 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16531 wxPyEndAllowThreads(__tstate);
16532 if (PyErr_Occurred()) SWIG_fail;
16533 }
16534 resultobj = SWIG_Py_Void();
16535 return resultobj;
16536 fail:
16537 return NULL;
16538 }
16539
16540
16541 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16542 PyObject *resultobj = 0;
16543 wxImage *arg1 = (wxImage *) 0 ;
16544 wxRect *arg2 = 0 ;
16545 byte arg3 ;
16546 byte arg4 ;
16547 byte arg5 ;
16548 void *argp1 = 0 ;
16549 int res1 = 0 ;
16550 wxRect temp2 ;
16551 unsigned char val3 ;
16552 int ecode3 = 0 ;
16553 unsigned char val4 ;
16554 int ecode4 = 0 ;
16555 unsigned char val5 ;
16556 int ecode5 = 0 ;
16557 PyObject * obj0 = 0 ;
16558 PyObject * obj1 = 0 ;
16559 PyObject * obj2 = 0 ;
16560 PyObject * obj3 = 0 ;
16561 PyObject * obj4 = 0 ;
16562 char * kwnames[] = {
16563 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16564 };
16565
16566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16568 if (!SWIG_IsOK(res1)) {
16569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16570 }
16571 arg1 = reinterpret_cast< wxImage * >(argp1);
16572 {
16573 arg2 = &temp2;
16574 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16575 }
16576 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16577 if (!SWIG_IsOK(ecode3)) {
16578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16579 }
16580 arg3 = static_cast< byte >(val3);
16581 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16582 if (!SWIG_IsOK(ecode4)) {
16583 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16584 }
16585 arg4 = static_cast< byte >(val4);
16586 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16587 if (!SWIG_IsOK(ecode5)) {
16588 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16589 }
16590 arg5 = static_cast< byte >(val5);
16591 {
16592 PyThreadState* __tstate = wxPyBeginAllowThreads();
16593 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16594 wxPyEndAllowThreads(__tstate);
16595 if (PyErr_Occurred()) SWIG_fail;
16596 }
16597 resultobj = SWIG_Py_Void();
16598 return resultobj;
16599 fail:
16600 return NULL;
16601 }
16602
16603
16604 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16605 PyObject *resultobj = 0;
16606 wxImage *arg1 = (wxImage *) 0 ;
16607 int arg2 ;
16608 int arg3 ;
16609 byte result;
16610 void *argp1 = 0 ;
16611 int res1 = 0 ;
16612 int val2 ;
16613 int ecode2 = 0 ;
16614 int val3 ;
16615 int ecode3 = 0 ;
16616 PyObject * obj0 = 0 ;
16617 PyObject * obj1 = 0 ;
16618 PyObject * obj2 = 0 ;
16619 char * kwnames[] = {
16620 (char *) "self",(char *) "x",(char *) "y", NULL
16621 };
16622
16623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16625 if (!SWIG_IsOK(res1)) {
16626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
16627 }
16628 arg1 = reinterpret_cast< wxImage * >(argp1);
16629 ecode2 = SWIG_AsVal_int(obj1, &val2);
16630 if (!SWIG_IsOK(ecode2)) {
16631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
16632 }
16633 arg2 = static_cast< int >(val2);
16634 ecode3 = SWIG_AsVal_int(obj2, &val3);
16635 if (!SWIG_IsOK(ecode3)) {
16636 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
16637 }
16638 arg3 = static_cast< int >(val3);
16639 {
16640 PyThreadState* __tstate = wxPyBeginAllowThreads();
16641 result = (byte)(arg1)->GetRed(arg2,arg3);
16642 wxPyEndAllowThreads(__tstate);
16643 if (PyErr_Occurred()) SWIG_fail;
16644 }
16645 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16646 return resultobj;
16647 fail:
16648 return NULL;
16649 }
16650
16651
16652 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16653 PyObject *resultobj = 0;
16654 wxImage *arg1 = (wxImage *) 0 ;
16655 int arg2 ;
16656 int arg3 ;
16657 byte result;
16658 void *argp1 = 0 ;
16659 int res1 = 0 ;
16660 int val2 ;
16661 int ecode2 = 0 ;
16662 int val3 ;
16663 int ecode3 = 0 ;
16664 PyObject * obj0 = 0 ;
16665 PyObject * obj1 = 0 ;
16666 PyObject * obj2 = 0 ;
16667 char * kwnames[] = {
16668 (char *) "self",(char *) "x",(char *) "y", NULL
16669 };
16670
16671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16673 if (!SWIG_IsOK(res1)) {
16674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16675 }
16676 arg1 = reinterpret_cast< wxImage * >(argp1);
16677 ecode2 = SWIG_AsVal_int(obj1, &val2);
16678 if (!SWIG_IsOK(ecode2)) {
16679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
16680 }
16681 arg2 = static_cast< int >(val2);
16682 ecode3 = SWIG_AsVal_int(obj2, &val3);
16683 if (!SWIG_IsOK(ecode3)) {
16684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
16685 }
16686 arg3 = static_cast< int >(val3);
16687 {
16688 PyThreadState* __tstate = wxPyBeginAllowThreads();
16689 result = (byte)(arg1)->GetGreen(arg2,arg3);
16690 wxPyEndAllowThreads(__tstate);
16691 if (PyErr_Occurred()) SWIG_fail;
16692 }
16693 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16694 return resultobj;
16695 fail:
16696 return NULL;
16697 }
16698
16699
16700 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16701 PyObject *resultobj = 0;
16702 wxImage *arg1 = (wxImage *) 0 ;
16703 int arg2 ;
16704 int arg3 ;
16705 byte result;
16706 void *argp1 = 0 ;
16707 int res1 = 0 ;
16708 int val2 ;
16709 int ecode2 = 0 ;
16710 int val3 ;
16711 int ecode3 = 0 ;
16712 PyObject * obj0 = 0 ;
16713 PyObject * obj1 = 0 ;
16714 PyObject * obj2 = 0 ;
16715 char * kwnames[] = {
16716 (char *) "self",(char *) "x",(char *) "y", NULL
16717 };
16718
16719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16721 if (!SWIG_IsOK(res1)) {
16722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16723 }
16724 arg1 = reinterpret_cast< wxImage * >(argp1);
16725 ecode2 = SWIG_AsVal_int(obj1, &val2);
16726 if (!SWIG_IsOK(ecode2)) {
16727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16728 }
16729 arg2 = static_cast< int >(val2);
16730 ecode3 = SWIG_AsVal_int(obj2, &val3);
16731 if (!SWIG_IsOK(ecode3)) {
16732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16733 }
16734 arg3 = static_cast< int >(val3);
16735 {
16736 PyThreadState* __tstate = wxPyBeginAllowThreads();
16737 result = (byte)(arg1)->GetBlue(arg2,arg3);
16738 wxPyEndAllowThreads(__tstate);
16739 if (PyErr_Occurred()) SWIG_fail;
16740 }
16741 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16742 return resultobj;
16743 fail:
16744 return NULL;
16745 }
16746
16747
16748 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16749 PyObject *resultobj = 0;
16750 wxImage *arg1 = (wxImage *) 0 ;
16751 int arg2 ;
16752 int arg3 ;
16753 byte arg4 ;
16754 void *argp1 = 0 ;
16755 int res1 = 0 ;
16756 int val2 ;
16757 int ecode2 = 0 ;
16758 int val3 ;
16759 int ecode3 = 0 ;
16760 unsigned char val4 ;
16761 int ecode4 = 0 ;
16762 PyObject * obj0 = 0 ;
16763 PyObject * obj1 = 0 ;
16764 PyObject * obj2 = 0 ;
16765 PyObject * obj3 = 0 ;
16766 char * kwnames[] = {
16767 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16768 };
16769
16770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16772 if (!SWIG_IsOK(res1)) {
16773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16774 }
16775 arg1 = reinterpret_cast< wxImage * >(argp1);
16776 ecode2 = SWIG_AsVal_int(obj1, &val2);
16777 if (!SWIG_IsOK(ecode2)) {
16778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16779 }
16780 arg2 = static_cast< int >(val2);
16781 ecode3 = SWIG_AsVal_int(obj2, &val3);
16782 if (!SWIG_IsOK(ecode3)) {
16783 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16784 }
16785 arg3 = static_cast< int >(val3);
16786 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16787 if (!SWIG_IsOK(ecode4)) {
16788 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16789 }
16790 arg4 = static_cast< byte >(val4);
16791 {
16792 PyThreadState* __tstate = wxPyBeginAllowThreads();
16793 (arg1)->SetAlpha(arg2,arg3,arg4);
16794 wxPyEndAllowThreads(__tstate);
16795 if (PyErr_Occurred()) SWIG_fail;
16796 }
16797 resultobj = SWIG_Py_Void();
16798 return resultobj;
16799 fail:
16800 return NULL;
16801 }
16802
16803
16804 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16805 PyObject *resultobj = 0;
16806 wxImage *arg1 = (wxImage *) 0 ;
16807 int arg2 ;
16808 int arg3 ;
16809 byte result;
16810 void *argp1 = 0 ;
16811 int res1 = 0 ;
16812 int val2 ;
16813 int ecode2 = 0 ;
16814 int val3 ;
16815 int ecode3 = 0 ;
16816 PyObject * obj0 = 0 ;
16817 PyObject * obj1 = 0 ;
16818 PyObject * obj2 = 0 ;
16819 char * kwnames[] = {
16820 (char *) "self",(char *) "x",(char *) "y", NULL
16821 };
16822
16823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16825 if (!SWIG_IsOK(res1)) {
16826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16827 }
16828 arg1 = reinterpret_cast< wxImage * >(argp1);
16829 ecode2 = SWIG_AsVal_int(obj1, &val2);
16830 if (!SWIG_IsOK(ecode2)) {
16831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16832 }
16833 arg2 = static_cast< int >(val2);
16834 ecode3 = SWIG_AsVal_int(obj2, &val3);
16835 if (!SWIG_IsOK(ecode3)) {
16836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16837 }
16838 arg3 = static_cast< int >(val3);
16839 {
16840 PyThreadState* __tstate = wxPyBeginAllowThreads();
16841 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16842 wxPyEndAllowThreads(__tstate);
16843 if (PyErr_Occurred()) SWIG_fail;
16844 }
16845 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16846 return resultobj;
16847 fail:
16848 return NULL;
16849 }
16850
16851
16852 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16853 PyObject *resultobj = 0;
16854 wxImage *arg1 = (wxImage *) 0 ;
16855 bool result;
16856 void *argp1 = 0 ;
16857 int res1 = 0 ;
16858 PyObject *swig_obj[1] ;
16859
16860 if (!args) SWIG_fail;
16861 swig_obj[0] = args;
16862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16863 if (!SWIG_IsOK(res1)) {
16864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16865 }
16866 arg1 = reinterpret_cast< wxImage * >(argp1);
16867 {
16868 PyThreadState* __tstate = wxPyBeginAllowThreads();
16869 result = (bool)(arg1)->HasAlpha();
16870 wxPyEndAllowThreads(__tstate);
16871 if (PyErr_Occurred()) SWIG_fail;
16872 }
16873 {
16874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16875 }
16876 return resultobj;
16877 fail:
16878 return NULL;
16879 }
16880
16881
16882 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16883 PyObject *resultobj = 0;
16884 wxImage *arg1 = (wxImage *) 0 ;
16885 void *argp1 = 0 ;
16886 int res1 = 0 ;
16887 PyObject *swig_obj[1] ;
16888
16889 if (!args) SWIG_fail;
16890 swig_obj[0] = args;
16891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16892 if (!SWIG_IsOK(res1)) {
16893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16894 }
16895 arg1 = reinterpret_cast< wxImage * >(argp1);
16896 {
16897 PyThreadState* __tstate = wxPyBeginAllowThreads();
16898 (arg1)->InitAlpha();
16899 wxPyEndAllowThreads(__tstate);
16900 if (PyErr_Occurred()) SWIG_fail;
16901 }
16902 resultobj = SWIG_Py_Void();
16903 return resultobj;
16904 fail:
16905 return NULL;
16906 }
16907
16908
16909 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16910 PyObject *resultobj = 0;
16911 wxImage *arg1 = (wxImage *) 0 ;
16912 int arg2 ;
16913 int arg3 ;
16914 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
16915 bool result;
16916 void *argp1 = 0 ;
16917 int res1 = 0 ;
16918 int val2 ;
16919 int ecode2 = 0 ;
16920 int val3 ;
16921 int ecode3 = 0 ;
16922 unsigned char val4 ;
16923 int ecode4 = 0 ;
16924 PyObject * obj0 = 0 ;
16925 PyObject * obj1 = 0 ;
16926 PyObject * obj2 = 0 ;
16927 PyObject * obj3 = 0 ;
16928 char * kwnames[] = {
16929 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
16930 };
16931
16932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16934 if (!SWIG_IsOK(res1)) {
16935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
16936 }
16937 arg1 = reinterpret_cast< wxImage * >(argp1);
16938 ecode2 = SWIG_AsVal_int(obj1, &val2);
16939 if (!SWIG_IsOK(ecode2)) {
16940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
16941 }
16942 arg2 = static_cast< int >(val2);
16943 ecode3 = SWIG_AsVal_int(obj2, &val3);
16944 if (!SWIG_IsOK(ecode3)) {
16945 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
16946 }
16947 arg3 = static_cast< int >(val3);
16948 if (obj3) {
16949 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16950 if (!SWIG_IsOK(ecode4)) {
16951 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
16952 }
16953 arg4 = static_cast< byte >(val4);
16954 }
16955 {
16956 PyThreadState* __tstate = wxPyBeginAllowThreads();
16957 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
16958 wxPyEndAllowThreads(__tstate);
16959 if (PyErr_Occurred()) SWIG_fail;
16960 }
16961 {
16962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16963 }
16964 return resultobj;
16965 fail:
16966 return NULL;
16967 }
16968
16969
16970 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16971 PyObject *resultobj = 0;
16972 wxImage *arg1 = (wxImage *) 0 ;
16973 byte *arg2 = (byte *) 0 ;
16974 byte *arg3 = (byte *) 0 ;
16975 byte *arg4 = (byte *) 0 ;
16976 byte arg5 = (byte) 0 ;
16977 byte arg6 = (byte) 0 ;
16978 byte arg7 = (byte) 0 ;
16979 bool result;
16980 void *argp1 = 0 ;
16981 int res1 = 0 ;
16982 byte temp2 ;
16983 int res2 = SWIG_TMPOBJ ;
16984 byte temp3 ;
16985 int res3 = SWIG_TMPOBJ ;
16986 byte temp4 ;
16987 int res4 = SWIG_TMPOBJ ;
16988 unsigned char val5 ;
16989 int ecode5 = 0 ;
16990 unsigned char val6 ;
16991 int ecode6 = 0 ;
16992 unsigned char val7 ;
16993 int ecode7 = 0 ;
16994 PyObject * obj0 = 0 ;
16995 PyObject * obj1 = 0 ;
16996 PyObject * obj2 = 0 ;
16997 PyObject * obj3 = 0 ;
16998 char * kwnames[] = {
16999 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17000 };
17001
17002 arg2 = &temp2;
17003 arg3 = &temp3;
17004 arg4 = &temp4;
17005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17007 if (!SWIG_IsOK(res1)) {
17008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17009 }
17010 arg1 = reinterpret_cast< wxImage * >(argp1);
17011 if (obj1) {
17012 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17013 if (!SWIG_IsOK(ecode5)) {
17014 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17015 }
17016 arg5 = static_cast< byte >(val5);
17017 }
17018 if (obj2) {
17019 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17020 if (!SWIG_IsOK(ecode6)) {
17021 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17022 }
17023 arg6 = static_cast< byte >(val6);
17024 }
17025 if (obj3) {
17026 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17027 if (!SWIG_IsOK(ecode7)) {
17028 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17029 }
17030 arg7 = static_cast< byte >(val7);
17031 }
17032 {
17033 PyThreadState* __tstate = wxPyBeginAllowThreads();
17034 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17035 wxPyEndAllowThreads(__tstate);
17036 if (PyErr_Occurred()) SWIG_fail;
17037 }
17038 {
17039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17040 }
17041 if (SWIG_IsTmpObj(res2)) {
17042 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17043 } else {
17044 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17045 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17046 }
17047 if (SWIG_IsTmpObj(res3)) {
17048 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17049 } else {
17050 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17051 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17052 }
17053 if (SWIG_IsTmpObj(res4)) {
17054 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17055 } else {
17056 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17057 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17058 }
17059 return resultobj;
17060 fail:
17061 return NULL;
17062 }
17063
17064
17065 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17066 PyObject *resultobj = 0;
17067 wxImage *arg1 = (wxImage *) 0 ;
17068 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17069 bool result;
17070 void *argp1 = 0 ;
17071 int res1 = 0 ;
17072 unsigned char val2 ;
17073 int ecode2 = 0 ;
17074 PyObject * obj0 = 0 ;
17075 PyObject * obj1 = 0 ;
17076 char * kwnames[] = {
17077 (char *) "self",(char *) "threshold", NULL
17078 };
17079
17080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17082 if (!SWIG_IsOK(res1)) {
17083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17084 }
17085 arg1 = reinterpret_cast< wxImage * >(argp1);
17086 if (obj1) {
17087 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17088 if (!SWIG_IsOK(ecode2)) {
17089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17090 }
17091 arg2 = static_cast< byte >(val2);
17092 }
17093 {
17094 PyThreadState* __tstate = wxPyBeginAllowThreads();
17095 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17096 wxPyEndAllowThreads(__tstate);
17097 if (PyErr_Occurred()) SWIG_fail;
17098 }
17099 {
17100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17101 }
17102 return resultobj;
17103 fail:
17104 return NULL;
17105 }
17106
17107
17108 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17109 PyObject *resultobj = 0;
17110 wxImage *arg1 = (wxImage *) 0 ;
17111 byte arg2 ;
17112 byte arg3 ;
17113 byte arg4 ;
17114 bool result;
17115 void *argp1 = 0 ;
17116 int res1 = 0 ;
17117 unsigned char val2 ;
17118 int ecode2 = 0 ;
17119 unsigned char val3 ;
17120 int ecode3 = 0 ;
17121 unsigned char val4 ;
17122 int ecode4 = 0 ;
17123 PyObject * obj0 = 0 ;
17124 PyObject * obj1 = 0 ;
17125 PyObject * obj2 = 0 ;
17126 PyObject * obj3 = 0 ;
17127 char * kwnames[] = {
17128 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17129 };
17130
17131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17133 if (!SWIG_IsOK(res1)) {
17134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17135 }
17136 arg1 = reinterpret_cast< wxImage * >(argp1);
17137 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17138 if (!SWIG_IsOK(ecode2)) {
17139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17140 }
17141 arg2 = static_cast< byte >(val2);
17142 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17143 if (!SWIG_IsOK(ecode3)) {
17144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17145 }
17146 arg3 = static_cast< byte >(val3);
17147 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17148 if (!SWIG_IsOK(ecode4)) {
17149 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17150 }
17151 arg4 = static_cast< byte >(val4);
17152 {
17153 PyThreadState* __tstate = wxPyBeginAllowThreads();
17154 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17155 wxPyEndAllowThreads(__tstate);
17156 if (PyErr_Occurred()) SWIG_fail;
17157 }
17158 {
17159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17160 }
17161 return resultobj;
17162 fail:
17163 return NULL;
17164 }
17165
17166
17167 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17168 PyObject *resultobj = 0;
17169 wxImage *arg1 = (wxImage *) 0 ;
17170 wxImage *arg2 = 0 ;
17171 byte arg3 ;
17172 byte arg4 ;
17173 byte arg5 ;
17174 bool result;
17175 void *argp1 = 0 ;
17176 int res1 = 0 ;
17177 void *argp2 = 0 ;
17178 int res2 = 0 ;
17179 unsigned char val3 ;
17180 int ecode3 = 0 ;
17181 unsigned char val4 ;
17182 int ecode4 = 0 ;
17183 unsigned char val5 ;
17184 int ecode5 = 0 ;
17185 PyObject * obj0 = 0 ;
17186 PyObject * obj1 = 0 ;
17187 PyObject * obj2 = 0 ;
17188 PyObject * obj3 = 0 ;
17189 PyObject * obj4 = 0 ;
17190 char * kwnames[] = {
17191 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17192 };
17193
17194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17196 if (!SWIG_IsOK(res1)) {
17197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17198 }
17199 arg1 = reinterpret_cast< wxImage * >(argp1);
17200 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17201 if (!SWIG_IsOK(res2)) {
17202 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17203 }
17204 if (!argp2) {
17205 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17206 }
17207 arg2 = reinterpret_cast< wxImage * >(argp2);
17208 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17209 if (!SWIG_IsOK(ecode3)) {
17210 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17211 }
17212 arg3 = static_cast< byte >(val3);
17213 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17214 if (!SWIG_IsOK(ecode4)) {
17215 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17216 }
17217 arg4 = static_cast< byte >(val4);
17218 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17219 if (!SWIG_IsOK(ecode5)) {
17220 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17221 }
17222 arg5 = static_cast< byte >(val5);
17223 {
17224 PyThreadState* __tstate = wxPyBeginAllowThreads();
17225 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17226 wxPyEndAllowThreads(__tstate);
17227 if (PyErr_Occurred()) SWIG_fail;
17228 }
17229 {
17230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17231 }
17232 return resultobj;
17233 fail:
17234 return NULL;
17235 }
17236
17237
17238 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17239 PyObject *resultobj = 0;
17240 wxString *arg1 = 0 ;
17241 bool result;
17242 bool temp1 = false ;
17243 PyObject * obj0 = 0 ;
17244 char * kwnames[] = {
17245 (char *) "filename", NULL
17246 };
17247
17248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17249 {
17250 arg1 = wxString_in_helper(obj0);
17251 if (arg1 == NULL) SWIG_fail;
17252 temp1 = true;
17253 }
17254 {
17255 PyThreadState* __tstate = wxPyBeginAllowThreads();
17256 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17257 wxPyEndAllowThreads(__tstate);
17258 if (PyErr_Occurred()) SWIG_fail;
17259 }
17260 {
17261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17262 }
17263 {
17264 if (temp1)
17265 delete arg1;
17266 }
17267 return resultobj;
17268 fail:
17269 {
17270 if (temp1)
17271 delete arg1;
17272 }
17273 return NULL;
17274 }
17275
17276
17277 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17278 PyObject *resultobj = 0;
17279 wxString *arg1 = 0 ;
17280 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17281 int result;
17282 bool temp1 = false ;
17283 long val2 ;
17284 int ecode2 = 0 ;
17285 PyObject * obj0 = 0 ;
17286 PyObject * obj1 = 0 ;
17287 char * kwnames[] = {
17288 (char *) "filename",(char *) "type", NULL
17289 };
17290
17291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17292 {
17293 arg1 = wxString_in_helper(obj0);
17294 if (arg1 == NULL) SWIG_fail;
17295 temp1 = true;
17296 }
17297 if (obj1) {
17298 ecode2 = SWIG_AsVal_long(obj1, &val2);
17299 if (!SWIG_IsOK(ecode2)) {
17300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17301 }
17302 arg2 = static_cast< long >(val2);
17303 }
17304 {
17305 PyThreadState* __tstate = wxPyBeginAllowThreads();
17306 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17307 wxPyEndAllowThreads(__tstate);
17308 if (PyErr_Occurred()) SWIG_fail;
17309 }
17310 resultobj = SWIG_From_int(static_cast< int >(result));
17311 {
17312 if (temp1)
17313 delete arg1;
17314 }
17315 return resultobj;
17316 fail:
17317 {
17318 if (temp1)
17319 delete arg1;
17320 }
17321 return NULL;
17322 }
17323
17324
17325 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17326 PyObject *resultobj = 0;
17327 wxImage *arg1 = (wxImage *) 0 ;
17328 wxString *arg2 = 0 ;
17329 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17330 int arg4 = (int) -1 ;
17331 bool result;
17332 void *argp1 = 0 ;
17333 int res1 = 0 ;
17334 bool temp2 = false ;
17335 long val3 ;
17336 int ecode3 = 0 ;
17337 int val4 ;
17338 int ecode4 = 0 ;
17339 PyObject * obj0 = 0 ;
17340 PyObject * obj1 = 0 ;
17341 PyObject * obj2 = 0 ;
17342 PyObject * obj3 = 0 ;
17343 char * kwnames[] = {
17344 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17345 };
17346
17347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17349 if (!SWIG_IsOK(res1)) {
17350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17351 }
17352 arg1 = reinterpret_cast< wxImage * >(argp1);
17353 {
17354 arg2 = wxString_in_helper(obj1);
17355 if (arg2 == NULL) SWIG_fail;
17356 temp2 = true;
17357 }
17358 if (obj2) {
17359 ecode3 = SWIG_AsVal_long(obj2, &val3);
17360 if (!SWIG_IsOK(ecode3)) {
17361 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17362 }
17363 arg3 = static_cast< long >(val3);
17364 }
17365 if (obj3) {
17366 ecode4 = SWIG_AsVal_int(obj3, &val4);
17367 if (!SWIG_IsOK(ecode4)) {
17368 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17369 }
17370 arg4 = static_cast< int >(val4);
17371 }
17372 {
17373 PyThreadState* __tstate = wxPyBeginAllowThreads();
17374 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17375 wxPyEndAllowThreads(__tstate);
17376 if (PyErr_Occurred()) SWIG_fail;
17377 }
17378 {
17379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17380 }
17381 {
17382 if (temp2)
17383 delete arg2;
17384 }
17385 return resultobj;
17386 fail:
17387 {
17388 if (temp2)
17389 delete arg2;
17390 }
17391 return NULL;
17392 }
17393
17394
17395 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17396 PyObject *resultobj = 0;
17397 wxImage *arg1 = (wxImage *) 0 ;
17398 wxString *arg2 = 0 ;
17399 wxString *arg3 = 0 ;
17400 int arg4 = (int) -1 ;
17401 bool result;
17402 void *argp1 = 0 ;
17403 int res1 = 0 ;
17404 bool temp2 = false ;
17405 bool temp3 = false ;
17406 int val4 ;
17407 int ecode4 = 0 ;
17408 PyObject * obj0 = 0 ;
17409 PyObject * obj1 = 0 ;
17410 PyObject * obj2 = 0 ;
17411 PyObject * obj3 = 0 ;
17412 char * kwnames[] = {
17413 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17414 };
17415
17416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17418 if (!SWIG_IsOK(res1)) {
17419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17420 }
17421 arg1 = reinterpret_cast< wxImage * >(argp1);
17422 {
17423 arg2 = wxString_in_helper(obj1);
17424 if (arg2 == NULL) SWIG_fail;
17425 temp2 = true;
17426 }
17427 {
17428 arg3 = wxString_in_helper(obj2);
17429 if (arg3 == NULL) SWIG_fail;
17430 temp3 = true;
17431 }
17432 if (obj3) {
17433 ecode4 = SWIG_AsVal_int(obj3, &val4);
17434 if (!SWIG_IsOK(ecode4)) {
17435 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17436 }
17437 arg4 = static_cast< int >(val4);
17438 }
17439 {
17440 PyThreadState* __tstate = wxPyBeginAllowThreads();
17441 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17442 wxPyEndAllowThreads(__tstate);
17443 if (PyErr_Occurred()) SWIG_fail;
17444 }
17445 {
17446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17447 }
17448 {
17449 if (temp2)
17450 delete arg2;
17451 }
17452 {
17453 if (temp3)
17454 delete arg3;
17455 }
17456 return resultobj;
17457 fail:
17458 {
17459 if (temp2)
17460 delete arg2;
17461 }
17462 {
17463 if (temp3)
17464 delete arg3;
17465 }
17466 return NULL;
17467 }
17468
17469
17470 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17471 PyObject *resultobj = 0;
17472 wxImage *arg1 = (wxImage *) 0 ;
17473 wxString *arg2 = 0 ;
17474 int arg3 ;
17475 bool result;
17476 void *argp1 = 0 ;
17477 int res1 = 0 ;
17478 bool temp2 = false ;
17479 int val3 ;
17480 int ecode3 = 0 ;
17481 PyObject * obj0 = 0 ;
17482 PyObject * obj1 = 0 ;
17483 PyObject * obj2 = 0 ;
17484 char * kwnames[] = {
17485 (char *) "self",(char *) "name",(char *) "type", NULL
17486 };
17487
17488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17490 if (!SWIG_IsOK(res1)) {
17491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17492 }
17493 arg1 = reinterpret_cast< wxImage * >(argp1);
17494 {
17495 arg2 = wxString_in_helper(obj1);
17496 if (arg2 == NULL) SWIG_fail;
17497 temp2 = true;
17498 }
17499 ecode3 = SWIG_AsVal_int(obj2, &val3);
17500 if (!SWIG_IsOK(ecode3)) {
17501 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17502 }
17503 arg3 = static_cast< int >(val3);
17504 {
17505 PyThreadState* __tstate = wxPyBeginAllowThreads();
17506 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17507 wxPyEndAllowThreads(__tstate);
17508 if (PyErr_Occurred()) SWIG_fail;
17509 }
17510 {
17511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17512 }
17513 {
17514 if (temp2)
17515 delete arg2;
17516 }
17517 return resultobj;
17518 fail:
17519 {
17520 if (temp2)
17521 delete arg2;
17522 }
17523 return NULL;
17524 }
17525
17526
17527 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17528 PyObject *resultobj = 0;
17529 wxImage *arg1 = (wxImage *) 0 ;
17530 wxString *arg2 = 0 ;
17531 wxString *arg3 = 0 ;
17532 bool result;
17533 void *argp1 = 0 ;
17534 int res1 = 0 ;
17535 bool temp2 = false ;
17536 bool temp3 = false ;
17537 PyObject * obj0 = 0 ;
17538 PyObject * obj1 = 0 ;
17539 PyObject * obj2 = 0 ;
17540 char * kwnames[] = {
17541 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17542 };
17543
17544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17546 if (!SWIG_IsOK(res1)) {
17547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17548 }
17549 arg1 = reinterpret_cast< wxImage * >(argp1);
17550 {
17551 arg2 = wxString_in_helper(obj1);
17552 if (arg2 == NULL) SWIG_fail;
17553 temp2 = true;
17554 }
17555 {
17556 arg3 = wxString_in_helper(obj2);
17557 if (arg3 == NULL) SWIG_fail;
17558 temp3 = true;
17559 }
17560 {
17561 PyThreadState* __tstate = wxPyBeginAllowThreads();
17562 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17563 wxPyEndAllowThreads(__tstate);
17564 if (PyErr_Occurred()) SWIG_fail;
17565 }
17566 {
17567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17568 }
17569 {
17570 if (temp2)
17571 delete arg2;
17572 }
17573 {
17574 if (temp3)
17575 delete arg3;
17576 }
17577 return resultobj;
17578 fail:
17579 {
17580 if (temp2)
17581 delete arg2;
17582 }
17583 {
17584 if (temp3)
17585 delete arg3;
17586 }
17587 return NULL;
17588 }
17589
17590
17591 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17592 PyObject *resultobj = 0;
17593 wxInputStream *arg1 = 0 ;
17594 bool result;
17595 wxPyInputStream *temp1 ;
17596 bool created1 ;
17597 PyObject * obj0 = 0 ;
17598 char * kwnames[] = {
17599 (char *) "stream", NULL
17600 };
17601
17602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17603 {
17604 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17605 arg1 = temp1->m_wxis;
17606 created1 = false;
17607 } else {
17608 PyErr_Clear(); // clear the failure of the wxPyConvert above
17609 arg1 = wxPyCBInputStream_create(obj0, false);
17610 if (arg1 == NULL) {
17611 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17612 SWIG_fail;
17613 }
17614 created1 = true;
17615 }
17616 }
17617 {
17618 PyThreadState* __tstate = wxPyBeginAllowThreads();
17619 result = (bool)wxImage::CanRead(*arg1);
17620 wxPyEndAllowThreads(__tstate);
17621 if (PyErr_Occurred()) SWIG_fail;
17622 }
17623 {
17624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17625 }
17626 {
17627 if (created1) delete arg1;
17628 }
17629 return resultobj;
17630 fail:
17631 {
17632 if (created1) delete arg1;
17633 }
17634 return NULL;
17635 }
17636
17637
17638 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17639 PyObject *resultobj = 0;
17640 wxImage *arg1 = (wxImage *) 0 ;
17641 wxInputStream *arg2 = 0 ;
17642 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17643 int arg4 = (int) -1 ;
17644 bool result;
17645 void *argp1 = 0 ;
17646 int res1 = 0 ;
17647 wxPyInputStream *temp2 ;
17648 bool created2 ;
17649 long val3 ;
17650 int ecode3 = 0 ;
17651 int val4 ;
17652 int ecode4 = 0 ;
17653 PyObject * obj0 = 0 ;
17654 PyObject * obj1 = 0 ;
17655 PyObject * obj2 = 0 ;
17656 PyObject * obj3 = 0 ;
17657 char * kwnames[] = {
17658 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17659 };
17660
17661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17663 if (!SWIG_IsOK(res1)) {
17664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17665 }
17666 arg1 = reinterpret_cast< wxImage * >(argp1);
17667 {
17668 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17669 arg2 = temp2->m_wxis;
17670 created2 = false;
17671 } else {
17672 PyErr_Clear(); // clear the failure of the wxPyConvert above
17673 arg2 = wxPyCBInputStream_create(obj1, false);
17674 if (arg2 == NULL) {
17675 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17676 SWIG_fail;
17677 }
17678 created2 = true;
17679 }
17680 }
17681 if (obj2) {
17682 ecode3 = SWIG_AsVal_long(obj2, &val3);
17683 if (!SWIG_IsOK(ecode3)) {
17684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17685 }
17686 arg3 = static_cast< long >(val3);
17687 }
17688 if (obj3) {
17689 ecode4 = SWIG_AsVal_int(obj3, &val4);
17690 if (!SWIG_IsOK(ecode4)) {
17691 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17692 }
17693 arg4 = static_cast< int >(val4);
17694 }
17695 {
17696 PyThreadState* __tstate = wxPyBeginAllowThreads();
17697 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17698 wxPyEndAllowThreads(__tstate);
17699 if (PyErr_Occurred()) SWIG_fail;
17700 }
17701 {
17702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17703 }
17704 {
17705 if (created2) delete arg2;
17706 }
17707 return resultobj;
17708 fail:
17709 {
17710 if (created2) delete arg2;
17711 }
17712 return NULL;
17713 }
17714
17715
17716 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17717 PyObject *resultobj = 0;
17718 wxImage *arg1 = (wxImage *) 0 ;
17719 wxInputStream *arg2 = 0 ;
17720 wxString *arg3 = 0 ;
17721 int arg4 = (int) -1 ;
17722 bool result;
17723 void *argp1 = 0 ;
17724 int res1 = 0 ;
17725 wxPyInputStream *temp2 ;
17726 bool created2 ;
17727 bool temp3 = false ;
17728 int val4 ;
17729 int ecode4 = 0 ;
17730 PyObject * obj0 = 0 ;
17731 PyObject * obj1 = 0 ;
17732 PyObject * obj2 = 0 ;
17733 PyObject * obj3 = 0 ;
17734 char * kwnames[] = {
17735 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17736 };
17737
17738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17740 if (!SWIG_IsOK(res1)) {
17741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17742 }
17743 arg1 = reinterpret_cast< wxImage * >(argp1);
17744 {
17745 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17746 arg2 = temp2->m_wxis;
17747 created2 = false;
17748 } else {
17749 PyErr_Clear(); // clear the failure of the wxPyConvert above
17750 arg2 = wxPyCBInputStream_create(obj1, false);
17751 if (arg2 == NULL) {
17752 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17753 SWIG_fail;
17754 }
17755 created2 = true;
17756 }
17757 }
17758 {
17759 arg3 = wxString_in_helper(obj2);
17760 if (arg3 == NULL) SWIG_fail;
17761 temp3 = true;
17762 }
17763 if (obj3) {
17764 ecode4 = SWIG_AsVal_int(obj3, &val4);
17765 if (!SWIG_IsOK(ecode4)) {
17766 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17767 }
17768 arg4 = static_cast< int >(val4);
17769 }
17770 {
17771 PyThreadState* __tstate = wxPyBeginAllowThreads();
17772 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17773 wxPyEndAllowThreads(__tstate);
17774 if (PyErr_Occurred()) SWIG_fail;
17775 }
17776 {
17777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17778 }
17779 {
17780 if (created2) delete arg2;
17781 }
17782 {
17783 if (temp3)
17784 delete arg3;
17785 }
17786 return resultobj;
17787 fail:
17788 {
17789 if (created2) delete arg2;
17790 }
17791 {
17792 if (temp3)
17793 delete arg3;
17794 }
17795 return NULL;
17796 }
17797
17798
17799 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17800 PyObject *resultobj = 0;
17801 wxImage *arg1 = (wxImage *) 0 ;
17802 bool result;
17803 void *argp1 = 0 ;
17804 int res1 = 0 ;
17805 PyObject *swig_obj[1] ;
17806
17807 if (!args) SWIG_fail;
17808 swig_obj[0] = args;
17809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17810 if (!SWIG_IsOK(res1)) {
17811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
17812 }
17813 arg1 = reinterpret_cast< wxImage * >(argp1);
17814 {
17815 PyThreadState* __tstate = wxPyBeginAllowThreads();
17816 result = (bool)(arg1)->IsOk();
17817 wxPyEndAllowThreads(__tstate);
17818 if (PyErr_Occurred()) SWIG_fail;
17819 }
17820 {
17821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17822 }
17823 return resultobj;
17824 fail:
17825 return NULL;
17826 }
17827
17828
17829 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17830 PyObject *resultobj = 0;
17831 wxImage *arg1 = (wxImage *) 0 ;
17832 int result;
17833 void *argp1 = 0 ;
17834 int res1 = 0 ;
17835 PyObject *swig_obj[1] ;
17836
17837 if (!args) SWIG_fail;
17838 swig_obj[0] = args;
17839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17840 if (!SWIG_IsOK(res1)) {
17841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17842 }
17843 arg1 = reinterpret_cast< wxImage * >(argp1);
17844 {
17845 PyThreadState* __tstate = wxPyBeginAllowThreads();
17846 result = (int)(arg1)->GetWidth();
17847 wxPyEndAllowThreads(__tstate);
17848 if (PyErr_Occurred()) SWIG_fail;
17849 }
17850 resultobj = SWIG_From_int(static_cast< int >(result));
17851 return resultobj;
17852 fail:
17853 return NULL;
17854 }
17855
17856
17857 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17858 PyObject *resultobj = 0;
17859 wxImage *arg1 = (wxImage *) 0 ;
17860 int result;
17861 void *argp1 = 0 ;
17862 int res1 = 0 ;
17863 PyObject *swig_obj[1] ;
17864
17865 if (!args) SWIG_fail;
17866 swig_obj[0] = args;
17867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17868 if (!SWIG_IsOK(res1)) {
17869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17870 }
17871 arg1 = reinterpret_cast< wxImage * >(argp1);
17872 {
17873 PyThreadState* __tstate = wxPyBeginAllowThreads();
17874 result = (int)(arg1)->GetHeight();
17875 wxPyEndAllowThreads(__tstate);
17876 if (PyErr_Occurred()) SWIG_fail;
17877 }
17878 resultobj = SWIG_From_int(static_cast< int >(result));
17879 return resultobj;
17880 fail:
17881 return NULL;
17882 }
17883
17884
17885 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17886 PyObject *resultobj = 0;
17887 wxImage *arg1 = (wxImage *) 0 ;
17888 wxSize result;
17889 void *argp1 = 0 ;
17890 int res1 = 0 ;
17891 PyObject *swig_obj[1] ;
17892
17893 if (!args) SWIG_fail;
17894 swig_obj[0] = args;
17895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17896 if (!SWIG_IsOK(res1)) {
17897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
17898 }
17899 arg1 = reinterpret_cast< wxImage * >(argp1);
17900 {
17901 PyThreadState* __tstate = wxPyBeginAllowThreads();
17902 result = wxImage_GetSize(arg1);
17903 wxPyEndAllowThreads(__tstate);
17904 if (PyErr_Occurred()) SWIG_fail;
17905 }
17906 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
17907 return resultobj;
17908 fail:
17909 return NULL;
17910 }
17911
17912
17913 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17914 PyObject *resultobj = 0;
17915 wxImage *arg1 = (wxImage *) 0 ;
17916 wxRect *arg2 = 0 ;
17917 SwigValueWrapper<wxImage > result;
17918 void *argp1 = 0 ;
17919 int res1 = 0 ;
17920 wxRect temp2 ;
17921 PyObject * obj0 = 0 ;
17922 PyObject * obj1 = 0 ;
17923 char * kwnames[] = {
17924 (char *) "self",(char *) "rect", NULL
17925 };
17926
17927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
17928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17929 if (!SWIG_IsOK(res1)) {
17930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
17931 }
17932 arg1 = reinterpret_cast< wxImage * >(argp1);
17933 {
17934 arg2 = &temp2;
17935 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17936 }
17937 {
17938 PyThreadState* __tstate = wxPyBeginAllowThreads();
17939 result = (arg1)->GetSubImage((wxRect const &)*arg2);
17940 wxPyEndAllowThreads(__tstate);
17941 if (PyErr_Occurred()) SWIG_fail;
17942 }
17943 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
17944 return resultobj;
17945 fail:
17946 return NULL;
17947 }
17948
17949
17950 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17951 PyObject *resultobj = 0;
17952 wxImage *arg1 = (wxImage *) 0 ;
17953 wxSize *arg2 = 0 ;
17954 wxPoint *arg3 = 0 ;
17955 int arg4 = (int) -1 ;
17956 int arg5 = (int) -1 ;
17957 int arg6 = (int) -1 ;
17958 SwigValueWrapper<wxImage > result;
17959 void *argp1 = 0 ;
17960 int res1 = 0 ;
17961 wxSize temp2 ;
17962 wxPoint temp3 ;
17963 int val4 ;
17964 int ecode4 = 0 ;
17965 int val5 ;
17966 int ecode5 = 0 ;
17967 int val6 ;
17968 int ecode6 = 0 ;
17969 PyObject * obj0 = 0 ;
17970 PyObject * obj1 = 0 ;
17971 PyObject * obj2 = 0 ;
17972 PyObject * obj3 = 0 ;
17973 PyObject * obj4 = 0 ;
17974 PyObject * obj5 = 0 ;
17975 char * kwnames[] = {
17976 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
17977 };
17978
17979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17981 if (!SWIG_IsOK(res1)) {
17982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
17983 }
17984 arg1 = reinterpret_cast< wxImage * >(argp1);
17985 {
17986 arg2 = &temp2;
17987 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17988 }
17989 {
17990 arg3 = &temp3;
17991 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
17992 }
17993 if (obj3) {
17994 ecode4 = SWIG_AsVal_int(obj3, &val4);
17995 if (!SWIG_IsOK(ecode4)) {
17996 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
17997 }
17998 arg4 = static_cast< int >(val4);
17999 }
18000 if (obj4) {
18001 ecode5 = SWIG_AsVal_int(obj4, &val5);
18002 if (!SWIG_IsOK(ecode5)) {
18003 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18004 }
18005 arg5 = static_cast< int >(val5);
18006 }
18007 if (obj5) {
18008 ecode6 = SWIG_AsVal_int(obj5, &val6);
18009 if (!SWIG_IsOK(ecode6)) {
18010 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18011 }
18012 arg6 = static_cast< int >(val6);
18013 }
18014 {
18015 PyThreadState* __tstate = wxPyBeginAllowThreads();
18016 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18017 wxPyEndAllowThreads(__tstate);
18018 if (PyErr_Occurred()) SWIG_fail;
18019 }
18020 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18021 return resultobj;
18022 fail:
18023 return NULL;
18024 }
18025
18026
18027 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18028 PyObject *resultobj = 0;
18029 wxImage *arg1 = (wxImage *) 0 ;
18030 SwigValueWrapper<wxImage > result;
18031 void *argp1 = 0 ;
18032 int res1 = 0 ;
18033 PyObject *swig_obj[1] ;
18034
18035 if (!args) SWIG_fail;
18036 swig_obj[0] = args;
18037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18038 if (!SWIG_IsOK(res1)) {
18039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18040 }
18041 arg1 = reinterpret_cast< wxImage * >(argp1);
18042 {
18043 PyThreadState* __tstate = wxPyBeginAllowThreads();
18044 result = (arg1)->Copy();
18045 wxPyEndAllowThreads(__tstate);
18046 if (PyErr_Occurred()) SWIG_fail;
18047 }
18048 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18049 return resultobj;
18050 fail:
18051 return NULL;
18052 }
18053
18054
18055 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18056 PyObject *resultobj = 0;
18057 wxImage *arg1 = (wxImage *) 0 ;
18058 wxImage *arg2 = 0 ;
18059 int arg3 ;
18060 int arg4 ;
18061 void *argp1 = 0 ;
18062 int res1 = 0 ;
18063 void *argp2 = 0 ;
18064 int res2 = 0 ;
18065 int val3 ;
18066 int ecode3 = 0 ;
18067 int val4 ;
18068 int ecode4 = 0 ;
18069 PyObject * obj0 = 0 ;
18070 PyObject * obj1 = 0 ;
18071 PyObject * obj2 = 0 ;
18072 PyObject * obj3 = 0 ;
18073 char * kwnames[] = {
18074 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18075 };
18076
18077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18079 if (!SWIG_IsOK(res1)) {
18080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18081 }
18082 arg1 = reinterpret_cast< wxImage * >(argp1);
18083 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18084 if (!SWIG_IsOK(res2)) {
18085 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18086 }
18087 if (!argp2) {
18088 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18089 }
18090 arg2 = reinterpret_cast< wxImage * >(argp2);
18091 ecode3 = SWIG_AsVal_int(obj2, &val3);
18092 if (!SWIG_IsOK(ecode3)) {
18093 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18094 }
18095 arg3 = static_cast< int >(val3);
18096 ecode4 = SWIG_AsVal_int(obj3, &val4);
18097 if (!SWIG_IsOK(ecode4)) {
18098 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18099 }
18100 arg4 = static_cast< int >(val4);
18101 {
18102 PyThreadState* __tstate = wxPyBeginAllowThreads();
18103 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18104 wxPyEndAllowThreads(__tstate);
18105 if (PyErr_Occurred()) SWIG_fail;
18106 }
18107 resultobj = SWIG_Py_Void();
18108 return resultobj;
18109 fail:
18110 return NULL;
18111 }
18112
18113
18114 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18115 PyObject *resultobj = 0;
18116 wxImage *arg1 = (wxImage *) 0 ;
18117 PyObject *result = 0 ;
18118 void *argp1 = 0 ;
18119 int res1 = 0 ;
18120 PyObject *swig_obj[1] ;
18121
18122 if (!args) SWIG_fail;
18123 swig_obj[0] = args;
18124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18125 if (!SWIG_IsOK(res1)) {
18126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18127 }
18128 arg1 = reinterpret_cast< wxImage * >(argp1);
18129 {
18130 PyThreadState* __tstate = wxPyBeginAllowThreads();
18131 result = (PyObject *)wxImage_GetData(arg1);
18132 wxPyEndAllowThreads(__tstate);
18133 if (PyErr_Occurred()) SWIG_fail;
18134 }
18135 resultobj = result;
18136 return resultobj;
18137 fail:
18138 return NULL;
18139 }
18140
18141
18142 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18143 PyObject *resultobj = 0;
18144 wxImage *arg1 = (wxImage *) 0 ;
18145 buffer arg2 ;
18146 int arg3 ;
18147 void *argp1 = 0 ;
18148 int res1 = 0 ;
18149 Py_ssize_t temp2 ;
18150 PyObject * obj0 = 0 ;
18151 PyObject * obj1 = 0 ;
18152 char * kwnames[] = {
18153 (char *) "self",(char *) "data", NULL
18154 };
18155
18156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18158 if (!SWIG_IsOK(res1)) {
18159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18160 }
18161 arg1 = reinterpret_cast< wxImage * >(argp1);
18162 {
18163 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18164 arg3 = (int)temp2;
18165 }
18166 {
18167 PyThreadState* __tstate = wxPyBeginAllowThreads();
18168 wxImage_SetData(arg1,arg2,arg3);
18169 wxPyEndAllowThreads(__tstate);
18170 if (PyErr_Occurred()) SWIG_fail;
18171 }
18172 resultobj = SWIG_Py_Void();
18173 return resultobj;
18174 fail:
18175 return NULL;
18176 }
18177
18178
18179 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18180 PyObject *resultobj = 0;
18181 wxImage *arg1 = (wxImage *) 0 ;
18182 PyObject *result = 0 ;
18183 void *argp1 = 0 ;
18184 int res1 = 0 ;
18185 PyObject *swig_obj[1] ;
18186
18187 if (!args) SWIG_fail;
18188 swig_obj[0] = args;
18189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18190 if (!SWIG_IsOK(res1)) {
18191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18192 }
18193 arg1 = reinterpret_cast< wxImage * >(argp1);
18194 {
18195 PyThreadState* __tstate = wxPyBeginAllowThreads();
18196 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18197 wxPyEndAllowThreads(__tstate);
18198 if (PyErr_Occurred()) SWIG_fail;
18199 }
18200 resultobj = result;
18201 return resultobj;
18202 fail:
18203 return NULL;
18204 }
18205
18206
18207 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18208 PyObject *resultobj = 0;
18209 wxImage *arg1 = (wxImage *) 0 ;
18210 buffer arg2 ;
18211 int arg3 ;
18212 void *argp1 = 0 ;
18213 int res1 = 0 ;
18214 Py_ssize_t temp2 ;
18215 PyObject * obj0 = 0 ;
18216 PyObject * obj1 = 0 ;
18217 char * kwnames[] = {
18218 (char *) "self",(char *) "data", NULL
18219 };
18220
18221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18223 if (!SWIG_IsOK(res1)) {
18224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18225 }
18226 arg1 = reinterpret_cast< wxImage * >(argp1);
18227 {
18228 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18229 arg3 = (int)temp2;
18230 }
18231 {
18232 PyThreadState* __tstate = wxPyBeginAllowThreads();
18233 wxImage_SetDataBuffer(arg1,arg2,arg3);
18234 wxPyEndAllowThreads(__tstate);
18235 if (PyErr_Occurred()) SWIG_fail;
18236 }
18237 resultobj = SWIG_Py_Void();
18238 return resultobj;
18239 fail:
18240 return NULL;
18241 }
18242
18243
18244 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18245 PyObject *resultobj = 0;
18246 wxImage *arg1 = (wxImage *) 0 ;
18247 PyObject *result = 0 ;
18248 void *argp1 = 0 ;
18249 int res1 = 0 ;
18250 PyObject *swig_obj[1] ;
18251
18252 if (!args) SWIG_fail;
18253 swig_obj[0] = args;
18254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18255 if (!SWIG_IsOK(res1)) {
18256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18257 }
18258 arg1 = reinterpret_cast< wxImage * >(argp1);
18259 {
18260 PyThreadState* __tstate = wxPyBeginAllowThreads();
18261 result = (PyObject *)wxImage_GetAlphaData(arg1);
18262 wxPyEndAllowThreads(__tstate);
18263 if (PyErr_Occurred()) SWIG_fail;
18264 }
18265 resultobj = result;
18266 return resultobj;
18267 fail:
18268 return NULL;
18269 }
18270
18271
18272 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18273 PyObject *resultobj = 0;
18274 wxImage *arg1 = (wxImage *) 0 ;
18275 buffer arg2 ;
18276 int arg3 ;
18277 void *argp1 = 0 ;
18278 int res1 = 0 ;
18279 Py_ssize_t temp2 ;
18280 PyObject * obj0 = 0 ;
18281 PyObject * obj1 = 0 ;
18282 char * kwnames[] = {
18283 (char *) "self",(char *) "alpha", NULL
18284 };
18285
18286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18288 if (!SWIG_IsOK(res1)) {
18289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18290 }
18291 arg1 = reinterpret_cast< wxImage * >(argp1);
18292 {
18293 if (obj1 != Py_None) {
18294 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18295 arg3 = (int)temp2;
18296 }
18297 }
18298 {
18299 PyThreadState* __tstate = wxPyBeginAllowThreads();
18300 wxImage_SetAlphaData(arg1,arg2,arg3);
18301 wxPyEndAllowThreads(__tstate);
18302 if (PyErr_Occurred()) SWIG_fail;
18303 }
18304 resultobj = SWIG_Py_Void();
18305 return resultobj;
18306 fail:
18307 return NULL;
18308 }
18309
18310
18311 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18312 PyObject *resultobj = 0;
18313 wxImage *arg1 = (wxImage *) 0 ;
18314 PyObject *result = 0 ;
18315 void *argp1 = 0 ;
18316 int res1 = 0 ;
18317 PyObject *swig_obj[1] ;
18318
18319 if (!args) SWIG_fail;
18320 swig_obj[0] = args;
18321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18322 if (!SWIG_IsOK(res1)) {
18323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18324 }
18325 arg1 = reinterpret_cast< wxImage * >(argp1);
18326 {
18327 PyThreadState* __tstate = wxPyBeginAllowThreads();
18328 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18329 wxPyEndAllowThreads(__tstate);
18330 if (PyErr_Occurred()) SWIG_fail;
18331 }
18332 resultobj = result;
18333 return resultobj;
18334 fail:
18335 return NULL;
18336 }
18337
18338
18339 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18340 PyObject *resultobj = 0;
18341 wxImage *arg1 = (wxImage *) 0 ;
18342 buffer arg2 ;
18343 int arg3 ;
18344 void *argp1 = 0 ;
18345 int res1 = 0 ;
18346 Py_ssize_t temp2 ;
18347 PyObject * obj0 = 0 ;
18348 PyObject * obj1 = 0 ;
18349 char * kwnames[] = {
18350 (char *) "self",(char *) "alpha", NULL
18351 };
18352
18353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18355 if (!SWIG_IsOK(res1)) {
18356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18357 }
18358 arg1 = reinterpret_cast< wxImage * >(argp1);
18359 {
18360 if (obj1 != Py_None) {
18361 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18362 arg3 = (int)temp2;
18363 }
18364 }
18365 {
18366 PyThreadState* __tstate = wxPyBeginAllowThreads();
18367 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18368 wxPyEndAllowThreads(__tstate);
18369 if (PyErr_Occurred()) SWIG_fail;
18370 }
18371 resultobj = SWIG_Py_Void();
18372 return resultobj;
18373 fail:
18374 return NULL;
18375 }
18376
18377
18378 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18379 PyObject *resultobj = 0;
18380 wxImage *arg1 = (wxImage *) 0 ;
18381 byte arg2 ;
18382 byte arg3 ;
18383 byte arg4 ;
18384 void *argp1 = 0 ;
18385 int res1 = 0 ;
18386 unsigned char val2 ;
18387 int ecode2 = 0 ;
18388 unsigned char val3 ;
18389 int ecode3 = 0 ;
18390 unsigned char val4 ;
18391 int ecode4 = 0 ;
18392 PyObject * obj0 = 0 ;
18393 PyObject * obj1 = 0 ;
18394 PyObject * obj2 = 0 ;
18395 PyObject * obj3 = 0 ;
18396 char * kwnames[] = {
18397 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18398 };
18399
18400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18404 }
18405 arg1 = reinterpret_cast< wxImage * >(argp1);
18406 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18407 if (!SWIG_IsOK(ecode2)) {
18408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18409 }
18410 arg2 = static_cast< byte >(val2);
18411 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18412 if (!SWIG_IsOK(ecode3)) {
18413 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18414 }
18415 arg3 = static_cast< byte >(val3);
18416 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18417 if (!SWIG_IsOK(ecode4)) {
18418 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18419 }
18420 arg4 = static_cast< byte >(val4);
18421 {
18422 PyThreadState* __tstate = wxPyBeginAllowThreads();
18423 (arg1)->SetMaskColour(arg2,arg3,arg4);
18424 wxPyEndAllowThreads(__tstate);
18425 if (PyErr_Occurred()) SWIG_fail;
18426 }
18427 resultobj = SWIG_Py_Void();
18428 return resultobj;
18429 fail:
18430 return NULL;
18431 }
18432
18433
18434 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18435 PyObject *resultobj = 0;
18436 wxImage *arg1 = (wxImage *) 0 ;
18437 byte *arg2 = (byte *) 0 ;
18438 byte *arg3 = (byte *) 0 ;
18439 byte *arg4 = (byte *) 0 ;
18440 void *argp1 = 0 ;
18441 int res1 = 0 ;
18442 byte temp2 ;
18443 int res2 = SWIG_TMPOBJ ;
18444 byte temp3 ;
18445 int res3 = SWIG_TMPOBJ ;
18446 byte temp4 ;
18447 int res4 = SWIG_TMPOBJ ;
18448 PyObject *swig_obj[1] ;
18449
18450 arg2 = &temp2;
18451 arg3 = &temp3;
18452 arg4 = &temp4;
18453 if (!args) SWIG_fail;
18454 swig_obj[0] = args;
18455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18456 if (!SWIG_IsOK(res1)) {
18457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18458 }
18459 arg1 = reinterpret_cast< wxImage * >(argp1);
18460 {
18461 PyThreadState* __tstate = wxPyBeginAllowThreads();
18462 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18463 wxPyEndAllowThreads(__tstate);
18464 if (PyErr_Occurred()) SWIG_fail;
18465 }
18466 resultobj = SWIG_Py_Void();
18467 if (SWIG_IsTmpObj(res2)) {
18468 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18469 } else {
18470 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18471 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18472 }
18473 if (SWIG_IsTmpObj(res3)) {
18474 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18475 } else {
18476 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18477 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18478 }
18479 if (SWIG_IsTmpObj(res4)) {
18480 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18481 } else {
18482 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18483 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18484 }
18485 return resultobj;
18486 fail:
18487 return NULL;
18488 }
18489
18490
18491 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18492 PyObject *resultobj = 0;
18493 wxImage *arg1 = (wxImage *) 0 ;
18494 byte result;
18495 void *argp1 = 0 ;
18496 int res1 = 0 ;
18497 PyObject *swig_obj[1] ;
18498
18499 if (!args) SWIG_fail;
18500 swig_obj[0] = args;
18501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18502 if (!SWIG_IsOK(res1)) {
18503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18504 }
18505 arg1 = reinterpret_cast< wxImage * >(argp1);
18506 {
18507 PyThreadState* __tstate = wxPyBeginAllowThreads();
18508 result = (byte)(arg1)->GetMaskRed();
18509 wxPyEndAllowThreads(__tstate);
18510 if (PyErr_Occurred()) SWIG_fail;
18511 }
18512 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18513 return resultobj;
18514 fail:
18515 return NULL;
18516 }
18517
18518
18519 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18520 PyObject *resultobj = 0;
18521 wxImage *arg1 = (wxImage *) 0 ;
18522 byte result;
18523 void *argp1 = 0 ;
18524 int res1 = 0 ;
18525 PyObject *swig_obj[1] ;
18526
18527 if (!args) SWIG_fail;
18528 swig_obj[0] = args;
18529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18530 if (!SWIG_IsOK(res1)) {
18531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18532 }
18533 arg1 = reinterpret_cast< wxImage * >(argp1);
18534 {
18535 PyThreadState* __tstate = wxPyBeginAllowThreads();
18536 result = (byte)(arg1)->GetMaskGreen();
18537 wxPyEndAllowThreads(__tstate);
18538 if (PyErr_Occurred()) SWIG_fail;
18539 }
18540 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18541 return resultobj;
18542 fail:
18543 return NULL;
18544 }
18545
18546
18547 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18548 PyObject *resultobj = 0;
18549 wxImage *arg1 = (wxImage *) 0 ;
18550 byte result;
18551 void *argp1 = 0 ;
18552 int res1 = 0 ;
18553 PyObject *swig_obj[1] ;
18554
18555 if (!args) SWIG_fail;
18556 swig_obj[0] = args;
18557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18558 if (!SWIG_IsOK(res1)) {
18559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18560 }
18561 arg1 = reinterpret_cast< wxImage * >(argp1);
18562 {
18563 PyThreadState* __tstate = wxPyBeginAllowThreads();
18564 result = (byte)(arg1)->GetMaskBlue();
18565 wxPyEndAllowThreads(__tstate);
18566 if (PyErr_Occurred()) SWIG_fail;
18567 }
18568 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18569 return resultobj;
18570 fail:
18571 return NULL;
18572 }
18573
18574
18575 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18576 PyObject *resultobj = 0;
18577 wxImage *arg1 = (wxImage *) 0 ;
18578 bool arg2 = (bool) true ;
18579 void *argp1 = 0 ;
18580 int res1 = 0 ;
18581 bool val2 ;
18582 int ecode2 = 0 ;
18583 PyObject * obj0 = 0 ;
18584 PyObject * obj1 = 0 ;
18585 char * kwnames[] = {
18586 (char *) "self",(char *) "mask", NULL
18587 };
18588
18589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18591 if (!SWIG_IsOK(res1)) {
18592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18593 }
18594 arg1 = reinterpret_cast< wxImage * >(argp1);
18595 if (obj1) {
18596 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18597 if (!SWIG_IsOK(ecode2)) {
18598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18599 }
18600 arg2 = static_cast< bool >(val2);
18601 }
18602 {
18603 PyThreadState* __tstate = wxPyBeginAllowThreads();
18604 (arg1)->SetMask(arg2);
18605 wxPyEndAllowThreads(__tstate);
18606 if (PyErr_Occurred()) SWIG_fail;
18607 }
18608 resultobj = SWIG_Py_Void();
18609 return resultobj;
18610 fail:
18611 return NULL;
18612 }
18613
18614
18615 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18616 PyObject *resultobj = 0;
18617 wxImage *arg1 = (wxImage *) 0 ;
18618 bool result;
18619 void *argp1 = 0 ;
18620 int res1 = 0 ;
18621 PyObject *swig_obj[1] ;
18622
18623 if (!args) SWIG_fail;
18624 swig_obj[0] = args;
18625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18626 if (!SWIG_IsOK(res1)) {
18627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18628 }
18629 arg1 = reinterpret_cast< wxImage * >(argp1);
18630 {
18631 PyThreadState* __tstate = wxPyBeginAllowThreads();
18632 result = (bool)(arg1)->HasMask();
18633 wxPyEndAllowThreads(__tstate);
18634 if (PyErr_Occurred()) SWIG_fail;
18635 }
18636 {
18637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18638 }
18639 return resultobj;
18640 fail:
18641 return NULL;
18642 }
18643
18644
18645 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18646 PyObject *resultobj = 0;
18647 wxImage *arg1 = (wxImage *) 0 ;
18648 double arg2 ;
18649 wxPoint *arg3 = 0 ;
18650 bool arg4 = (bool) true ;
18651 wxPoint *arg5 = (wxPoint *) NULL ;
18652 SwigValueWrapper<wxImage > result;
18653 void *argp1 = 0 ;
18654 int res1 = 0 ;
18655 double val2 ;
18656 int ecode2 = 0 ;
18657 wxPoint temp3 ;
18658 bool val4 ;
18659 int ecode4 = 0 ;
18660 void *argp5 = 0 ;
18661 int res5 = 0 ;
18662 PyObject * obj0 = 0 ;
18663 PyObject * obj1 = 0 ;
18664 PyObject * obj2 = 0 ;
18665 PyObject * obj3 = 0 ;
18666 PyObject * obj4 = 0 ;
18667 char * kwnames[] = {
18668 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18669 };
18670
18671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18673 if (!SWIG_IsOK(res1)) {
18674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18675 }
18676 arg1 = reinterpret_cast< wxImage * >(argp1);
18677 ecode2 = SWIG_AsVal_double(obj1, &val2);
18678 if (!SWIG_IsOK(ecode2)) {
18679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18680 }
18681 arg2 = static_cast< double >(val2);
18682 {
18683 arg3 = &temp3;
18684 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18685 }
18686 if (obj3) {
18687 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18688 if (!SWIG_IsOK(ecode4)) {
18689 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18690 }
18691 arg4 = static_cast< bool >(val4);
18692 }
18693 if (obj4) {
18694 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18695 if (!SWIG_IsOK(res5)) {
18696 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
18697 }
18698 arg5 = reinterpret_cast< wxPoint * >(argp5);
18699 }
18700 {
18701 PyThreadState* __tstate = wxPyBeginAllowThreads();
18702 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18703 wxPyEndAllowThreads(__tstate);
18704 if (PyErr_Occurred()) SWIG_fail;
18705 }
18706 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18707 return resultobj;
18708 fail:
18709 return NULL;
18710 }
18711
18712
18713 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18714 PyObject *resultobj = 0;
18715 wxImage *arg1 = (wxImage *) 0 ;
18716 bool arg2 = (bool) true ;
18717 SwigValueWrapper<wxImage > result;
18718 void *argp1 = 0 ;
18719 int res1 = 0 ;
18720 bool val2 ;
18721 int ecode2 = 0 ;
18722 PyObject * obj0 = 0 ;
18723 PyObject * obj1 = 0 ;
18724 char * kwnames[] = {
18725 (char *) "self",(char *) "clockwise", NULL
18726 };
18727
18728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18730 if (!SWIG_IsOK(res1)) {
18731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18732 }
18733 arg1 = reinterpret_cast< wxImage * >(argp1);
18734 if (obj1) {
18735 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18736 if (!SWIG_IsOK(ecode2)) {
18737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18738 }
18739 arg2 = static_cast< bool >(val2);
18740 }
18741 {
18742 PyThreadState* __tstate = wxPyBeginAllowThreads();
18743 result = (arg1)->Rotate90(arg2);
18744 wxPyEndAllowThreads(__tstate);
18745 if (PyErr_Occurred()) SWIG_fail;
18746 }
18747 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18748 return resultobj;
18749 fail:
18750 return NULL;
18751 }
18752
18753
18754 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18755 PyObject *resultobj = 0;
18756 wxImage *arg1 = (wxImage *) 0 ;
18757 bool arg2 = (bool) true ;
18758 SwigValueWrapper<wxImage > result;
18759 void *argp1 = 0 ;
18760 int res1 = 0 ;
18761 bool val2 ;
18762 int ecode2 = 0 ;
18763 PyObject * obj0 = 0 ;
18764 PyObject * obj1 = 0 ;
18765 char * kwnames[] = {
18766 (char *) "self",(char *) "horizontally", NULL
18767 };
18768
18769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18771 if (!SWIG_IsOK(res1)) {
18772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18773 }
18774 arg1 = reinterpret_cast< wxImage * >(argp1);
18775 if (obj1) {
18776 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18777 if (!SWIG_IsOK(ecode2)) {
18778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18779 }
18780 arg2 = static_cast< bool >(val2);
18781 }
18782 {
18783 PyThreadState* __tstate = wxPyBeginAllowThreads();
18784 result = (arg1)->Mirror(arg2);
18785 wxPyEndAllowThreads(__tstate);
18786 if (PyErr_Occurred()) SWIG_fail;
18787 }
18788 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18789 return resultobj;
18790 fail:
18791 return NULL;
18792 }
18793
18794
18795 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18796 PyObject *resultobj = 0;
18797 wxImage *arg1 = (wxImage *) 0 ;
18798 byte arg2 ;
18799 byte arg3 ;
18800 byte arg4 ;
18801 byte arg5 ;
18802 byte arg6 ;
18803 byte arg7 ;
18804 void *argp1 = 0 ;
18805 int res1 = 0 ;
18806 unsigned char val2 ;
18807 int ecode2 = 0 ;
18808 unsigned char val3 ;
18809 int ecode3 = 0 ;
18810 unsigned char val4 ;
18811 int ecode4 = 0 ;
18812 unsigned char val5 ;
18813 int ecode5 = 0 ;
18814 unsigned char val6 ;
18815 int ecode6 = 0 ;
18816 unsigned char val7 ;
18817 int ecode7 = 0 ;
18818 PyObject * obj0 = 0 ;
18819 PyObject * obj1 = 0 ;
18820 PyObject * obj2 = 0 ;
18821 PyObject * obj3 = 0 ;
18822 PyObject * obj4 = 0 ;
18823 PyObject * obj5 = 0 ;
18824 PyObject * obj6 = 0 ;
18825 char * kwnames[] = {
18826 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18827 };
18828
18829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18831 if (!SWIG_IsOK(res1)) {
18832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18833 }
18834 arg1 = reinterpret_cast< wxImage * >(argp1);
18835 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18836 if (!SWIG_IsOK(ecode2)) {
18837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18838 }
18839 arg2 = static_cast< byte >(val2);
18840 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18841 if (!SWIG_IsOK(ecode3)) {
18842 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18843 }
18844 arg3 = static_cast< byte >(val3);
18845 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18846 if (!SWIG_IsOK(ecode4)) {
18847 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18848 }
18849 arg4 = static_cast< byte >(val4);
18850 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18851 if (!SWIG_IsOK(ecode5)) {
18852 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18853 }
18854 arg5 = static_cast< byte >(val5);
18855 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18856 if (!SWIG_IsOK(ecode6)) {
18857 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18858 }
18859 arg6 = static_cast< byte >(val6);
18860 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18861 if (!SWIG_IsOK(ecode7)) {
18862 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18863 }
18864 arg7 = static_cast< byte >(val7);
18865 {
18866 PyThreadState* __tstate = wxPyBeginAllowThreads();
18867 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18868 wxPyEndAllowThreads(__tstate);
18869 if (PyErr_Occurred()) SWIG_fail;
18870 }
18871 resultobj = SWIG_Py_Void();
18872 return resultobj;
18873 fail:
18874 return NULL;
18875 }
18876
18877
18878 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18879 PyObject *resultobj = 0;
18880 wxImage *arg1 = (wxImage *) 0 ;
18881 double arg2 = (double) 0.299 ;
18882 double arg3 = (double) 0.587 ;
18883 double arg4 = (double) 0.114 ;
18884 SwigValueWrapper<wxImage > result;
18885 void *argp1 = 0 ;
18886 int res1 = 0 ;
18887 double val2 ;
18888 int ecode2 = 0 ;
18889 double val3 ;
18890 int ecode3 = 0 ;
18891 double val4 ;
18892 int ecode4 = 0 ;
18893 PyObject * obj0 = 0 ;
18894 PyObject * obj1 = 0 ;
18895 PyObject * obj2 = 0 ;
18896 PyObject * obj3 = 0 ;
18897 char * kwnames[] = {
18898 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
18899 };
18900
18901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18903 if (!SWIG_IsOK(res1)) {
18904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
18905 }
18906 arg1 = reinterpret_cast< wxImage * >(argp1);
18907 if (obj1) {
18908 ecode2 = SWIG_AsVal_double(obj1, &val2);
18909 if (!SWIG_IsOK(ecode2)) {
18910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
18911 }
18912 arg2 = static_cast< double >(val2);
18913 }
18914 if (obj2) {
18915 ecode3 = SWIG_AsVal_double(obj2, &val3);
18916 if (!SWIG_IsOK(ecode3)) {
18917 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
18918 }
18919 arg3 = static_cast< double >(val3);
18920 }
18921 if (obj3) {
18922 ecode4 = SWIG_AsVal_double(obj3, &val4);
18923 if (!SWIG_IsOK(ecode4)) {
18924 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
18925 }
18926 arg4 = static_cast< double >(val4);
18927 }
18928 {
18929 PyThreadState* __tstate = wxPyBeginAllowThreads();
18930 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
18931 wxPyEndAllowThreads(__tstate);
18932 if (PyErr_Occurred()) SWIG_fail;
18933 }
18934 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18935 return resultobj;
18936 fail:
18937 return NULL;
18938 }
18939
18940
18941 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18942 PyObject *resultobj = 0;
18943 wxImage *arg1 = (wxImage *) 0 ;
18944 byte arg2 ;
18945 byte arg3 ;
18946 byte arg4 ;
18947 SwigValueWrapper<wxImage > result;
18948 void *argp1 = 0 ;
18949 int res1 = 0 ;
18950 unsigned char val2 ;
18951 int ecode2 = 0 ;
18952 unsigned char val3 ;
18953 int ecode3 = 0 ;
18954 unsigned char val4 ;
18955 int ecode4 = 0 ;
18956 PyObject * obj0 = 0 ;
18957 PyObject * obj1 = 0 ;
18958 PyObject * obj2 = 0 ;
18959 PyObject * obj3 = 0 ;
18960 char * kwnames[] = {
18961 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18962 };
18963
18964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18966 if (!SWIG_IsOK(res1)) {
18967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
18968 }
18969 arg1 = reinterpret_cast< wxImage * >(argp1);
18970 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18971 if (!SWIG_IsOK(ecode2)) {
18972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
18973 }
18974 arg2 = static_cast< byte >(val2);
18975 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18976 if (!SWIG_IsOK(ecode3)) {
18977 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
18978 }
18979 arg3 = static_cast< byte >(val3);
18980 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18981 if (!SWIG_IsOK(ecode4)) {
18982 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
18983 }
18984 arg4 = static_cast< byte >(val4);
18985 {
18986 PyThreadState* __tstate = wxPyBeginAllowThreads();
18987 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
18988 wxPyEndAllowThreads(__tstate);
18989 if (PyErr_Occurred()) SWIG_fail;
18990 }
18991 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18992 return resultobj;
18993 fail:
18994 return NULL;
18995 }
18996
18997
18998 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18999 PyObject *resultobj = 0;
19000 wxImage *arg1 = (wxImage *) 0 ;
19001 wxString *arg2 = 0 ;
19002 wxString *arg3 = 0 ;
19003 void *argp1 = 0 ;
19004 int res1 = 0 ;
19005 bool temp2 = false ;
19006 bool temp3 = false ;
19007 PyObject * obj0 = 0 ;
19008 PyObject * obj1 = 0 ;
19009 PyObject * obj2 = 0 ;
19010 char * kwnames[] = {
19011 (char *) "self",(char *) "name",(char *) "value", NULL
19012 };
19013
19014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19016 if (!SWIG_IsOK(res1)) {
19017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19018 }
19019 arg1 = reinterpret_cast< wxImage * >(argp1);
19020 {
19021 arg2 = wxString_in_helper(obj1);
19022 if (arg2 == NULL) SWIG_fail;
19023 temp2 = true;
19024 }
19025 {
19026 arg3 = wxString_in_helper(obj2);
19027 if (arg3 == NULL) SWIG_fail;
19028 temp3 = true;
19029 }
19030 {
19031 PyThreadState* __tstate = wxPyBeginAllowThreads();
19032 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19033 wxPyEndAllowThreads(__tstate);
19034 if (PyErr_Occurred()) SWIG_fail;
19035 }
19036 resultobj = SWIG_Py_Void();
19037 {
19038 if (temp2)
19039 delete arg2;
19040 }
19041 {
19042 if (temp3)
19043 delete arg3;
19044 }
19045 return resultobj;
19046 fail:
19047 {
19048 if (temp2)
19049 delete arg2;
19050 }
19051 {
19052 if (temp3)
19053 delete arg3;
19054 }
19055 return NULL;
19056 }
19057
19058
19059 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19060 PyObject *resultobj = 0;
19061 wxImage *arg1 = (wxImage *) 0 ;
19062 wxString *arg2 = 0 ;
19063 int arg3 ;
19064 void *argp1 = 0 ;
19065 int res1 = 0 ;
19066 bool temp2 = false ;
19067 int val3 ;
19068 int ecode3 = 0 ;
19069 PyObject * obj0 = 0 ;
19070 PyObject * obj1 = 0 ;
19071 PyObject * obj2 = 0 ;
19072 char * kwnames[] = {
19073 (char *) "self",(char *) "name",(char *) "value", NULL
19074 };
19075
19076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19078 if (!SWIG_IsOK(res1)) {
19079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19080 }
19081 arg1 = reinterpret_cast< wxImage * >(argp1);
19082 {
19083 arg2 = wxString_in_helper(obj1);
19084 if (arg2 == NULL) SWIG_fail;
19085 temp2 = true;
19086 }
19087 ecode3 = SWIG_AsVal_int(obj2, &val3);
19088 if (!SWIG_IsOK(ecode3)) {
19089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19090 }
19091 arg3 = static_cast< int >(val3);
19092 {
19093 PyThreadState* __tstate = wxPyBeginAllowThreads();
19094 (arg1)->SetOption((wxString const &)*arg2,arg3);
19095 wxPyEndAllowThreads(__tstate);
19096 if (PyErr_Occurred()) SWIG_fail;
19097 }
19098 resultobj = SWIG_Py_Void();
19099 {
19100 if (temp2)
19101 delete arg2;
19102 }
19103 return resultobj;
19104 fail:
19105 {
19106 if (temp2)
19107 delete arg2;
19108 }
19109 return NULL;
19110 }
19111
19112
19113 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19114 PyObject *resultobj = 0;
19115 wxImage *arg1 = (wxImage *) 0 ;
19116 wxString *arg2 = 0 ;
19117 wxString result;
19118 void *argp1 = 0 ;
19119 int res1 = 0 ;
19120 bool temp2 = false ;
19121 PyObject * obj0 = 0 ;
19122 PyObject * obj1 = 0 ;
19123 char * kwnames[] = {
19124 (char *) "self",(char *) "name", NULL
19125 };
19126
19127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19129 if (!SWIG_IsOK(res1)) {
19130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19131 }
19132 arg1 = reinterpret_cast< wxImage * >(argp1);
19133 {
19134 arg2 = wxString_in_helper(obj1);
19135 if (arg2 == NULL) SWIG_fail;
19136 temp2 = true;
19137 }
19138 {
19139 PyThreadState* __tstate = wxPyBeginAllowThreads();
19140 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19141 wxPyEndAllowThreads(__tstate);
19142 if (PyErr_Occurred()) SWIG_fail;
19143 }
19144 {
19145 #if wxUSE_UNICODE
19146 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19147 #else
19148 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19149 #endif
19150 }
19151 {
19152 if (temp2)
19153 delete arg2;
19154 }
19155 return resultobj;
19156 fail:
19157 {
19158 if (temp2)
19159 delete arg2;
19160 }
19161 return NULL;
19162 }
19163
19164
19165 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19166 PyObject *resultobj = 0;
19167 wxImage *arg1 = (wxImage *) 0 ;
19168 wxString *arg2 = 0 ;
19169 int result;
19170 void *argp1 = 0 ;
19171 int res1 = 0 ;
19172 bool temp2 = false ;
19173 PyObject * obj0 = 0 ;
19174 PyObject * obj1 = 0 ;
19175 char * kwnames[] = {
19176 (char *) "self",(char *) "name", NULL
19177 };
19178
19179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19181 if (!SWIG_IsOK(res1)) {
19182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19183 }
19184 arg1 = reinterpret_cast< wxImage * >(argp1);
19185 {
19186 arg2 = wxString_in_helper(obj1);
19187 if (arg2 == NULL) SWIG_fail;
19188 temp2 = true;
19189 }
19190 {
19191 PyThreadState* __tstate = wxPyBeginAllowThreads();
19192 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19193 wxPyEndAllowThreads(__tstate);
19194 if (PyErr_Occurred()) SWIG_fail;
19195 }
19196 resultobj = SWIG_From_int(static_cast< int >(result));
19197 {
19198 if (temp2)
19199 delete arg2;
19200 }
19201 return resultobj;
19202 fail:
19203 {
19204 if (temp2)
19205 delete arg2;
19206 }
19207 return NULL;
19208 }
19209
19210
19211 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19212 PyObject *resultobj = 0;
19213 wxImage *arg1 = (wxImage *) 0 ;
19214 wxString *arg2 = 0 ;
19215 bool result;
19216 void *argp1 = 0 ;
19217 int res1 = 0 ;
19218 bool temp2 = false ;
19219 PyObject * obj0 = 0 ;
19220 PyObject * obj1 = 0 ;
19221 char * kwnames[] = {
19222 (char *) "self",(char *) "name", NULL
19223 };
19224
19225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19227 if (!SWIG_IsOK(res1)) {
19228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19229 }
19230 arg1 = reinterpret_cast< wxImage * >(argp1);
19231 {
19232 arg2 = wxString_in_helper(obj1);
19233 if (arg2 == NULL) SWIG_fail;
19234 temp2 = true;
19235 }
19236 {
19237 PyThreadState* __tstate = wxPyBeginAllowThreads();
19238 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19239 wxPyEndAllowThreads(__tstate);
19240 if (PyErr_Occurred()) SWIG_fail;
19241 }
19242 {
19243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19244 }
19245 {
19246 if (temp2)
19247 delete arg2;
19248 }
19249 return resultobj;
19250 fail:
19251 {
19252 if (temp2)
19253 delete arg2;
19254 }
19255 return NULL;
19256 }
19257
19258
19259 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19260 PyObject *resultobj = 0;
19261 wxImage *arg1 = (wxImage *) 0 ;
19262 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19263 unsigned long result;
19264 void *argp1 = 0 ;
19265 int res1 = 0 ;
19266 unsigned long val2 ;
19267 int ecode2 = 0 ;
19268 PyObject * obj0 = 0 ;
19269 PyObject * obj1 = 0 ;
19270 char * kwnames[] = {
19271 (char *) "self",(char *) "stopafter", NULL
19272 };
19273
19274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19276 if (!SWIG_IsOK(res1)) {
19277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19278 }
19279 arg1 = reinterpret_cast< wxImage * >(argp1);
19280 if (obj1) {
19281 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19282 if (!SWIG_IsOK(ecode2)) {
19283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19284 }
19285 arg2 = static_cast< unsigned long >(val2);
19286 }
19287 {
19288 PyThreadState* __tstate = wxPyBeginAllowThreads();
19289 result = (unsigned long)(arg1)->CountColours(arg2);
19290 wxPyEndAllowThreads(__tstate);
19291 if (PyErr_Occurred()) SWIG_fail;
19292 }
19293 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19294 return resultobj;
19295 fail:
19296 return NULL;
19297 }
19298
19299
19300 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19301 PyObject *resultobj = 0;
19302 wxImage *arg1 = (wxImage *) 0 ;
19303 wxImageHistogram *arg2 = 0 ;
19304 unsigned long result;
19305 void *argp1 = 0 ;
19306 int res1 = 0 ;
19307 void *argp2 = 0 ;
19308 int res2 = 0 ;
19309 PyObject * obj0 = 0 ;
19310 PyObject * obj1 = 0 ;
19311 char * kwnames[] = {
19312 (char *) "self",(char *) "h", NULL
19313 };
19314
19315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19317 if (!SWIG_IsOK(res1)) {
19318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19319 }
19320 arg1 = reinterpret_cast< wxImage * >(argp1);
19321 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19322 if (!SWIG_IsOK(res2)) {
19323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19324 }
19325 if (!argp2) {
19326 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19327 }
19328 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19329 {
19330 PyThreadState* __tstate = wxPyBeginAllowThreads();
19331 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19332 wxPyEndAllowThreads(__tstate);
19333 if (PyErr_Occurred()) SWIG_fail;
19334 }
19335 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19336 return resultobj;
19337 fail:
19338 return NULL;
19339 }
19340
19341
19342 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19343 PyObject *resultobj = 0;
19344 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19345 void *argp1 = 0 ;
19346 int res1 = 0 ;
19347 PyObject * obj0 = 0 ;
19348 char * kwnames[] = {
19349 (char *) "handler", NULL
19350 };
19351
19352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19354 if (!SWIG_IsOK(res1)) {
19355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19356 }
19357 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19358 {
19359 PyThreadState* __tstate = wxPyBeginAllowThreads();
19360 wxImage::AddHandler(arg1);
19361 wxPyEndAllowThreads(__tstate);
19362 if (PyErr_Occurred()) SWIG_fail;
19363 }
19364 resultobj = SWIG_Py_Void();
19365 return resultobj;
19366 fail:
19367 return NULL;
19368 }
19369
19370
19371 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19372 PyObject *resultobj = 0;
19373 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19374 void *argp1 = 0 ;
19375 int res1 = 0 ;
19376 PyObject * obj0 = 0 ;
19377 char * kwnames[] = {
19378 (char *) "handler", NULL
19379 };
19380
19381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19383 if (!SWIG_IsOK(res1)) {
19384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19385 }
19386 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19387 {
19388 PyThreadState* __tstate = wxPyBeginAllowThreads();
19389 wxImage::InsertHandler(arg1);
19390 wxPyEndAllowThreads(__tstate);
19391 if (PyErr_Occurred()) SWIG_fail;
19392 }
19393 resultobj = SWIG_Py_Void();
19394 return resultobj;
19395 fail:
19396 return NULL;
19397 }
19398
19399
19400 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19401 PyObject *resultobj = 0;
19402 wxString *arg1 = 0 ;
19403 bool result;
19404 bool temp1 = false ;
19405 PyObject * obj0 = 0 ;
19406 char * kwnames[] = {
19407 (char *) "name", NULL
19408 };
19409
19410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19411 {
19412 arg1 = wxString_in_helper(obj0);
19413 if (arg1 == NULL) SWIG_fail;
19414 temp1 = true;
19415 }
19416 {
19417 PyThreadState* __tstate = wxPyBeginAllowThreads();
19418 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19419 wxPyEndAllowThreads(__tstate);
19420 if (PyErr_Occurred()) SWIG_fail;
19421 }
19422 {
19423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19424 }
19425 {
19426 if (temp1)
19427 delete arg1;
19428 }
19429 return resultobj;
19430 fail:
19431 {
19432 if (temp1)
19433 delete arg1;
19434 }
19435 return NULL;
19436 }
19437
19438
19439 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19440 PyObject *resultobj = 0;
19441 PyObject *result = 0 ;
19442
19443 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19444 {
19445 PyThreadState* __tstate = wxPyBeginAllowThreads();
19446 result = (PyObject *)wxImage_GetHandlers();
19447 wxPyEndAllowThreads(__tstate);
19448 if (PyErr_Occurred()) SWIG_fail;
19449 }
19450 resultobj = result;
19451 return resultobj;
19452 fail:
19453 return NULL;
19454 }
19455
19456
19457 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19458 PyObject *resultobj = 0;
19459 wxString result;
19460
19461 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19462 {
19463 PyThreadState* __tstate = wxPyBeginAllowThreads();
19464 result = wxImage::GetImageExtWildcard();
19465 wxPyEndAllowThreads(__tstate);
19466 if (PyErr_Occurred()) SWIG_fail;
19467 }
19468 {
19469 #if wxUSE_UNICODE
19470 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19471 #else
19472 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19473 #endif
19474 }
19475 return resultobj;
19476 fail:
19477 return NULL;
19478 }
19479
19480
19481 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19482 PyObject *resultobj = 0;
19483 wxImage *arg1 = (wxImage *) 0 ;
19484 int arg2 = (int) -1 ;
19485 wxBitmap result;
19486 void *argp1 = 0 ;
19487 int res1 = 0 ;
19488 int val2 ;
19489 int ecode2 = 0 ;
19490 PyObject * obj0 = 0 ;
19491 PyObject * obj1 = 0 ;
19492 char * kwnames[] = {
19493 (char *) "self",(char *) "depth", NULL
19494 };
19495
19496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19498 if (!SWIG_IsOK(res1)) {
19499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19500 }
19501 arg1 = reinterpret_cast< wxImage * >(argp1);
19502 if (obj1) {
19503 ecode2 = SWIG_AsVal_int(obj1, &val2);
19504 if (!SWIG_IsOK(ecode2)) {
19505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19506 }
19507 arg2 = static_cast< int >(val2);
19508 }
19509 {
19510 if (!wxPyCheckForApp()) SWIG_fail;
19511 PyThreadState* __tstate = wxPyBeginAllowThreads();
19512 result = wxImage_ConvertToBitmap(arg1,arg2);
19513 wxPyEndAllowThreads(__tstate);
19514 if (PyErr_Occurred()) SWIG_fail;
19515 }
19516 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19517 return resultobj;
19518 fail:
19519 return NULL;
19520 }
19521
19522
19523 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19524 PyObject *resultobj = 0;
19525 wxImage *arg1 = (wxImage *) 0 ;
19526 byte arg2 ;
19527 byte arg3 ;
19528 byte arg4 ;
19529 wxBitmap result;
19530 void *argp1 = 0 ;
19531 int res1 = 0 ;
19532 unsigned char val2 ;
19533 int ecode2 = 0 ;
19534 unsigned char val3 ;
19535 int ecode3 = 0 ;
19536 unsigned char val4 ;
19537 int ecode4 = 0 ;
19538 PyObject * obj0 = 0 ;
19539 PyObject * obj1 = 0 ;
19540 PyObject * obj2 = 0 ;
19541 PyObject * obj3 = 0 ;
19542 char * kwnames[] = {
19543 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19544 };
19545
19546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19548 if (!SWIG_IsOK(res1)) {
19549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19550 }
19551 arg1 = reinterpret_cast< wxImage * >(argp1);
19552 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19553 if (!SWIG_IsOK(ecode2)) {
19554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19555 }
19556 arg2 = static_cast< byte >(val2);
19557 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19558 if (!SWIG_IsOK(ecode3)) {
19559 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19560 }
19561 arg3 = static_cast< byte >(val3);
19562 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19563 if (!SWIG_IsOK(ecode4)) {
19564 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19565 }
19566 arg4 = static_cast< byte >(val4);
19567 {
19568 if (!wxPyCheckForApp()) SWIG_fail;
19569 PyThreadState* __tstate = wxPyBeginAllowThreads();
19570 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19571 wxPyEndAllowThreads(__tstate);
19572 if (PyErr_Occurred()) SWIG_fail;
19573 }
19574 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19575 return resultobj;
19576 fail:
19577 return NULL;
19578 }
19579
19580
19581 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19582 PyObject *resultobj = 0;
19583 wxImage *arg1 = (wxImage *) 0 ;
19584 double arg2 ;
19585 void *argp1 = 0 ;
19586 int res1 = 0 ;
19587 double val2 ;
19588 int ecode2 = 0 ;
19589 PyObject * obj0 = 0 ;
19590 PyObject * obj1 = 0 ;
19591 char * kwnames[] = {
19592 (char *) "self",(char *) "angle", NULL
19593 };
19594
19595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19597 if (!SWIG_IsOK(res1)) {
19598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19599 }
19600 arg1 = reinterpret_cast< wxImage * >(argp1);
19601 ecode2 = SWIG_AsVal_double(obj1, &val2);
19602 if (!SWIG_IsOK(ecode2)) {
19603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19604 }
19605 arg2 = static_cast< double >(val2);
19606 {
19607 PyThreadState* __tstate = wxPyBeginAllowThreads();
19608 (arg1)->RotateHue(arg2);
19609 wxPyEndAllowThreads(__tstate);
19610 if (PyErr_Occurred()) SWIG_fail;
19611 }
19612 resultobj = SWIG_Py_Void();
19613 return resultobj;
19614 fail:
19615 return NULL;
19616 }
19617
19618
19619 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19620 PyObject *resultobj = 0;
19621 wxImage_RGBValue arg1 ;
19622 wxImage_HSVValue result;
19623 void *argp1 ;
19624 int res1 = 0 ;
19625 PyObject * obj0 = 0 ;
19626 char * kwnames[] = {
19627 (char *) "rgb", NULL
19628 };
19629
19630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19631 {
19632 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19633 if (!SWIG_IsOK(res1)) {
19634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19635 }
19636 if (!argp1) {
19637 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19638 } else {
19639 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19640 arg1 = *temp;
19641 if (SWIG_IsNewObj(res1)) delete temp;
19642 }
19643 }
19644 {
19645 PyThreadState* __tstate = wxPyBeginAllowThreads();
19646 result = wxImage::RGBtoHSV(arg1);
19647 wxPyEndAllowThreads(__tstate);
19648 if (PyErr_Occurred()) SWIG_fail;
19649 }
19650 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19651 return resultobj;
19652 fail:
19653 return NULL;
19654 }
19655
19656
19657 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19658 PyObject *resultobj = 0;
19659 wxImage_HSVValue arg1 ;
19660 wxImage_RGBValue result;
19661 void *argp1 ;
19662 int res1 = 0 ;
19663 PyObject * obj0 = 0 ;
19664 char * kwnames[] = {
19665 (char *) "hsv", NULL
19666 };
19667
19668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19669 {
19670 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19671 if (!SWIG_IsOK(res1)) {
19672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19673 }
19674 if (!argp1) {
19675 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19676 } else {
19677 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19678 arg1 = *temp;
19679 if (SWIG_IsNewObj(res1)) delete temp;
19680 }
19681 }
19682 {
19683 PyThreadState* __tstate = wxPyBeginAllowThreads();
19684 result = wxImage::HSVtoRGB(arg1);
19685 wxPyEndAllowThreads(__tstate);
19686 if (PyErr_Occurred()) SWIG_fail;
19687 }
19688 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19689 return resultobj;
19690 fail:
19691 return NULL;
19692 }
19693
19694
19695 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19696 PyObject *obj;
19697 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19698 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19699 return SWIG_Py_Void();
19700 }
19701
19702 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19703 return SWIG_Python_InitShadowInstance(args);
19704 }
19705
19706 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19707 PyObject *resultobj = 0;
19708 int arg1 ;
19709 int arg2 ;
19710 buffer arg3 ;
19711 int arg4 ;
19712 buffer arg5 = (buffer) NULL ;
19713 int arg6 = (int) 0 ;
19714 wxImage *result = 0 ;
19715 int val1 ;
19716 int ecode1 = 0 ;
19717 int val2 ;
19718 int ecode2 = 0 ;
19719 Py_ssize_t temp3 ;
19720 Py_ssize_t temp5 ;
19721 PyObject * obj0 = 0 ;
19722 PyObject * obj1 = 0 ;
19723 PyObject * obj2 = 0 ;
19724 PyObject * obj3 = 0 ;
19725 char * kwnames[] = {
19726 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19727 };
19728
19729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19730 ecode1 = SWIG_AsVal_int(obj0, &val1);
19731 if (!SWIG_IsOK(ecode1)) {
19732 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19733 }
19734 arg1 = static_cast< int >(val1);
19735 ecode2 = SWIG_AsVal_int(obj1, &val2);
19736 if (!SWIG_IsOK(ecode2)) {
19737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19738 }
19739 arg2 = static_cast< int >(val2);
19740 {
19741 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19742 arg4 = (int)temp3;
19743 }
19744 if (obj3) {
19745 {
19746 if (obj3 != Py_None) {
19747 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19748 arg6 = (int)temp5;
19749 }
19750 }
19751 }
19752 {
19753 PyThreadState* __tstate = wxPyBeginAllowThreads();
19754 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19755 wxPyEndAllowThreads(__tstate);
19756 if (PyErr_Occurred()) SWIG_fail;
19757 }
19758 {
19759 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19760 }
19761 return resultobj;
19762 fail:
19763 return NULL;
19764 }
19765
19766
19767 SWIGINTERN int NullImage_set(PyObject *) {
19768 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19769 return 1;
19770 }
19771
19772
19773 SWIGINTERN PyObject *NullImage_get(void) {
19774 PyObject *pyobj = 0;
19775
19776 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19777 return pyobj;
19778 }
19779
19780
19781 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19782 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19783 return 1;
19784 }
19785
19786
19787 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19788 PyObject *pyobj = 0;
19789
19790 {
19791 #if wxUSE_UNICODE
19792 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19793 #else
19794 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19795 #endif
19796 }
19797 return pyobj;
19798 }
19799
19800
19801 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19802 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19803 return 1;
19804 }
19805
19806
19807 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19808 PyObject *pyobj = 0;
19809
19810 {
19811 #if wxUSE_UNICODE
19812 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19813 #else
19814 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19815 #endif
19816 }
19817 return pyobj;
19818 }
19819
19820
19821 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19822 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19823 return 1;
19824 }
19825
19826
19827 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19828 PyObject *pyobj = 0;
19829
19830 {
19831 #if wxUSE_UNICODE
19832 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19833 #else
19834 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19835 #endif
19836 }
19837 return pyobj;
19838 }
19839
19840
19841 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19842 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19843 return 1;
19844 }
19845
19846
19847 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19848 PyObject *pyobj = 0;
19849
19850 {
19851 #if wxUSE_UNICODE
19852 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19853 #else
19854 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19855 #endif
19856 }
19857 return pyobj;
19858 }
19859
19860
19861 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19862 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19863 return 1;
19864 }
19865
19866
19867 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19868 PyObject *pyobj = 0;
19869
19870 {
19871 #if wxUSE_UNICODE
19872 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19873 #else
19874 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19875 #endif
19876 }
19877 return pyobj;
19878 }
19879
19880
19881 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
19882 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
19883 return 1;
19884 }
19885
19886
19887 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
19888 PyObject *pyobj = 0;
19889
19890 {
19891 #if wxUSE_UNICODE
19892 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19893 #else
19894 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19895 #endif
19896 }
19897 return pyobj;
19898 }
19899
19900
19901 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
19902 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
19903 return 1;
19904 }
19905
19906
19907 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
19908 PyObject *pyobj = 0;
19909
19910 {
19911 #if wxUSE_UNICODE
19912 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19913 #else
19914 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19915 #endif
19916 }
19917 return pyobj;
19918 }
19919
19920
19921 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
19922 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
19923 return 1;
19924 }
19925
19926
19927 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
19928 PyObject *pyobj = 0;
19929
19930 {
19931 #if wxUSE_UNICODE
19932 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19933 #else
19934 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19935 #endif
19936 }
19937 return pyobj;
19938 }
19939
19940
19941 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
19942 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
19943 return 1;
19944 }
19945
19946
19947 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
19948 PyObject *pyobj = 0;
19949
19950 {
19951 #if wxUSE_UNICODE
19952 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
19953 #else
19954 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
19955 #endif
19956 }
19957 return pyobj;
19958 }
19959
19960
19961 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
19962 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
19963 return 1;
19964 }
19965
19966
19967 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
19968 PyObject *pyobj = 0;
19969
19970 {
19971 #if wxUSE_UNICODE
19972 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
19973 #else
19974 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
19975 #endif
19976 }
19977 return pyobj;
19978 }
19979
19980
19981 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
19982 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
19983 return 1;
19984 }
19985
19986
19987 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
19988 PyObject *pyobj = 0;
19989
19990 {
19991 #if wxUSE_UNICODE
19992 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
19993 #else
19994 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
19995 #endif
19996 }
19997 return pyobj;
19998 }
19999
20000
20001 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20002 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20003 return 1;
20004 }
20005
20006
20007 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20008 PyObject *pyobj = 0;
20009
20010 {
20011 #if wxUSE_UNICODE
20012 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20013 #else
20014 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20015 #endif
20016 }
20017 return pyobj;
20018 }
20019
20020
20021 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20022 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20023 return 1;
20024 }
20025
20026
20027 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20028 PyObject *pyobj = 0;
20029
20030 {
20031 #if wxUSE_UNICODE
20032 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20033 #else
20034 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20035 #endif
20036 }
20037 return pyobj;
20038 }
20039
20040
20041 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20042 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20043 return 1;
20044 }
20045
20046
20047 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20048 PyObject *pyobj = 0;
20049
20050 {
20051 #if wxUSE_UNICODE
20052 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20053 #else
20054 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20055 #endif
20056 }
20057 return pyobj;
20058 }
20059
20060
20061 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20062 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20063 return 1;
20064 }
20065
20066
20067 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20068 PyObject *pyobj = 0;
20069
20070 {
20071 #if wxUSE_UNICODE
20072 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20073 #else
20074 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20075 #endif
20076 }
20077 return pyobj;
20078 }
20079
20080
20081 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20082 PyObject *resultobj = 0;
20083 wxBMPHandler *result = 0 ;
20084
20085 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20086 {
20087 PyThreadState* __tstate = wxPyBeginAllowThreads();
20088 result = (wxBMPHandler *)new wxBMPHandler();
20089 wxPyEndAllowThreads(__tstate);
20090 if (PyErr_Occurred()) SWIG_fail;
20091 }
20092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20093 return resultobj;
20094 fail:
20095 return NULL;
20096 }
20097
20098
20099 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20100 PyObject *obj;
20101 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20102 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20103 return SWIG_Py_Void();
20104 }
20105
20106 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20107 return SWIG_Python_InitShadowInstance(args);
20108 }
20109
20110 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20111 PyObject *resultobj = 0;
20112 wxICOHandler *result = 0 ;
20113
20114 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20115 {
20116 PyThreadState* __tstate = wxPyBeginAllowThreads();
20117 result = (wxICOHandler *)new wxICOHandler();
20118 wxPyEndAllowThreads(__tstate);
20119 if (PyErr_Occurred()) SWIG_fail;
20120 }
20121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20122 return resultobj;
20123 fail:
20124 return NULL;
20125 }
20126
20127
20128 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20129 PyObject *obj;
20130 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20131 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20132 return SWIG_Py_Void();
20133 }
20134
20135 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20136 return SWIG_Python_InitShadowInstance(args);
20137 }
20138
20139 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20140 PyObject *resultobj = 0;
20141 wxCURHandler *result = 0 ;
20142
20143 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20144 {
20145 PyThreadState* __tstate = wxPyBeginAllowThreads();
20146 result = (wxCURHandler *)new wxCURHandler();
20147 wxPyEndAllowThreads(__tstate);
20148 if (PyErr_Occurred()) SWIG_fail;
20149 }
20150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20151 return resultobj;
20152 fail:
20153 return NULL;
20154 }
20155
20156
20157 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20158 PyObject *obj;
20159 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20160 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20161 return SWIG_Py_Void();
20162 }
20163
20164 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20165 return SWIG_Python_InitShadowInstance(args);
20166 }
20167
20168 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20169 PyObject *resultobj = 0;
20170 wxANIHandler *result = 0 ;
20171
20172 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20173 {
20174 PyThreadState* __tstate = wxPyBeginAllowThreads();
20175 result = (wxANIHandler *)new wxANIHandler();
20176 wxPyEndAllowThreads(__tstate);
20177 if (PyErr_Occurred()) SWIG_fail;
20178 }
20179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20180 return resultobj;
20181 fail:
20182 return NULL;
20183 }
20184
20185
20186 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20187 PyObject *obj;
20188 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20189 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20190 return SWIG_Py_Void();
20191 }
20192
20193 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20194 return SWIG_Python_InitShadowInstance(args);
20195 }
20196
20197 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20198 PyObject *resultobj = 0;
20199 wxPNGHandler *result = 0 ;
20200
20201 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20202 {
20203 PyThreadState* __tstate = wxPyBeginAllowThreads();
20204 result = (wxPNGHandler *)new wxPNGHandler();
20205 wxPyEndAllowThreads(__tstate);
20206 if (PyErr_Occurred()) SWIG_fail;
20207 }
20208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20209 return resultobj;
20210 fail:
20211 return NULL;
20212 }
20213
20214
20215 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20216 PyObject *obj;
20217 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20218 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20219 return SWIG_Py_Void();
20220 }
20221
20222 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20223 return SWIG_Python_InitShadowInstance(args);
20224 }
20225
20226 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20227 PyObject *resultobj = 0;
20228 wxGIFHandler *result = 0 ;
20229
20230 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20231 {
20232 PyThreadState* __tstate = wxPyBeginAllowThreads();
20233 result = (wxGIFHandler *)new wxGIFHandler();
20234 wxPyEndAllowThreads(__tstate);
20235 if (PyErr_Occurred()) SWIG_fail;
20236 }
20237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20238 return resultobj;
20239 fail:
20240 return NULL;
20241 }
20242
20243
20244 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20245 PyObject *obj;
20246 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20247 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20248 return SWIG_Py_Void();
20249 }
20250
20251 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20252 return SWIG_Python_InitShadowInstance(args);
20253 }
20254
20255 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20256 PyObject *resultobj = 0;
20257 wxPCXHandler *result = 0 ;
20258
20259 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20260 {
20261 PyThreadState* __tstate = wxPyBeginAllowThreads();
20262 result = (wxPCXHandler *)new wxPCXHandler();
20263 wxPyEndAllowThreads(__tstate);
20264 if (PyErr_Occurred()) SWIG_fail;
20265 }
20266 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20267 return resultobj;
20268 fail:
20269 return NULL;
20270 }
20271
20272
20273 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20274 PyObject *obj;
20275 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20276 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20277 return SWIG_Py_Void();
20278 }
20279
20280 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20281 return SWIG_Python_InitShadowInstance(args);
20282 }
20283
20284 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20285 PyObject *resultobj = 0;
20286 wxJPEGHandler *result = 0 ;
20287
20288 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20289 {
20290 PyThreadState* __tstate = wxPyBeginAllowThreads();
20291 result = (wxJPEGHandler *)new wxJPEGHandler();
20292 wxPyEndAllowThreads(__tstate);
20293 if (PyErr_Occurred()) SWIG_fail;
20294 }
20295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20296 return resultobj;
20297 fail:
20298 return NULL;
20299 }
20300
20301
20302 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20303 PyObject *obj;
20304 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20305 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20306 return SWIG_Py_Void();
20307 }
20308
20309 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20310 return SWIG_Python_InitShadowInstance(args);
20311 }
20312
20313 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20314 PyObject *resultobj = 0;
20315 wxPNMHandler *result = 0 ;
20316
20317 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20318 {
20319 PyThreadState* __tstate = wxPyBeginAllowThreads();
20320 result = (wxPNMHandler *)new wxPNMHandler();
20321 wxPyEndAllowThreads(__tstate);
20322 if (PyErr_Occurred()) SWIG_fail;
20323 }
20324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20325 return resultobj;
20326 fail:
20327 return NULL;
20328 }
20329
20330
20331 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20332 PyObject *obj;
20333 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20334 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20335 return SWIG_Py_Void();
20336 }
20337
20338 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20339 return SWIG_Python_InitShadowInstance(args);
20340 }
20341
20342 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20343 PyObject *resultobj = 0;
20344 wxXPMHandler *result = 0 ;
20345
20346 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20347 {
20348 PyThreadState* __tstate = wxPyBeginAllowThreads();
20349 result = (wxXPMHandler *)new wxXPMHandler();
20350 wxPyEndAllowThreads(__tstate);
20351 if (PyErr_Occurred()) SWIG_fail;
20352 }
20353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20354 return resultobj;
20355 fail:
20356 return NULL;
20357 }
20358
20359
20360 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20361 PyObject *obj;
20362 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20363 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20364 return SWIG_Py_Void();
20365 }
20366
20367 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20368 return SWIG_Python_InitShadowInstance(args);
20369 }
20370
20371 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20372 PyObject *resultobj = 0;
20373 wxTIFFHandler *result = 0 ;
20374
20375 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20376 {
20377 PyThreadState* __tstate = wxPyBeginAllowThreads();
20378 result = (wxTIFFHandler *)new wxTIFFHandler();
20379 wxPyEndAllowThreads(__tstate);
20380 if (PyErr_Occurred()) SWIG_fail;
20381 }
20382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20383 return resultobj;
20384 fail:
20385 return NULL;
20386 }
20387
20388
20389 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20390 PyObject *obj;
20391 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20392 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20393 return SWIG_Py_Void();
20394 }
20395
20396 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20397 return SWIG_Python_InitShadowInstance(args);
20398 }
20399
20400 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20401 PyObject *resultobj = 0;
20402 wxImage *arg1 = 0 ;
20403 wxImage *arg2 = 0 ;
20404 int arg3 = (int) 236 ;
20405 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20406 bool result;
20407 void *argp1 = 0 ;
20408 int res1 = 0 ;
20409 void *argp2 = 0 ;
20410 int res2 = 0 ;
20411 int val3 ;
20412 int ecode3 = 0 ;
20413 int val4 ;
20414 int ecode4 = 0 ;
20415 PyObject * obj0 = 0 ;
20416 PyObject * obj1 = 0 ;
20417 PyObject * obj2 = 0 ;
20418 PyObject * obj3 = 0 ;
20419 char * kwnames[] = {
20420 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20421 };
20422
20423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20424 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20425 if (!SWIG_IsOK(res1)) {
20426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20427 }
20428 if (!argp1) {
20429 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20430 }
20431 arg1 = reinterpret_cast< wxImage * >(argp1);
20432 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20433 if (!SWIG_IsOK(res2)) {
20434 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20435 }
20436 if (!argp2) {
20437 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20438 }
20439 arg2 = reinterpret_cast< wxImage * >(argp2);
20440 if (obj2) {
20441 ecode3 = SWIG_AsVal_int(obj2, &val3);
20442 if (!SWIG_IsOK(ecode3)) {
20443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20444 }
20445 arg3 = static_cast< int >(val3);
20446 }
20447 if (obj3) {
20448 ecode4 = SWIG_AsVal_int(obj3, &val4);
20449 if (!SWIG_IsOK(ecode4)) {
20450 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20451 }
20452 arg4 = static_cast< int >(val4);
20453 }
20454 {
20455 PyThreadState* __tstate = wxPyBeginAllowThreads();
20456 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20457 wxPyEndAllowThreads(__tstate);
20458 if (PyErr_Occurred()) SWIG_fail;
20459 }
20460 {
20461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20462 }
20463 return resultobj;
20464 fail:
20465 return NULL;
20466 }
20467
20468
20469 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20470 PyObject *obj;
20471 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20472 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20473 return SWIG_Py_Void();
20474 }
20475
20476 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20477 PyObject *resultobj = 0;
20478 wxEvtHandler *result = 0 ;
20479
20480 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20481 {
20482 PyThreadState* __tstate = wxPyBeginAllowThreads();
20483 result = (wxEvtHandler *)new wxEvtHandler();
20484 wxPyEndAllowThreads(__tstate);
20485 if (PyErr_Occurred()) SWIG_fail;
20486 }
20487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20488 return resultobj;
20489 fail:
20490 return NULL;
20491 }
20492
20493
20494 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20495 PyObject *resultobj = 0;
20496 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20497 wxEvtHandler *result = 0 ;
20498 void *argp1 = 0 ;
20499 int res1 = 0 ;
20500 PyObject *swig_obj[1] ;
20501
20502 if (!args) SWIG_fail;
20503 swig_obj[0] = args;
20504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20505 if (!SWIG_IsOK(res1)) {
20506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20507 }
20508 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20509 {
20510 PyThreadState* __tstate = wxPyBeginAllowThreads();
20511 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20512 wxPyEndAllowThreads(__tstate);
20513 if (PyErr_Occurred()) SWIG_fail;
20514 }
20515 {
20516 resultobj = wxPyMake_wxObject(result, 0);
20517 }
20518 return resultobj;
20519 fail:
20520 return NULL;
20521 }
20522
20523
20524 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20525 PyObject *resultobj = 0;
20526 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20527 wxEvtHandler *result = 0 ;
20528 void *argp1 = 0 ;
20529 int res1 = 0 ;
20530 PyObject *swig_obj[1] ;
20531
20532 if (!args) SWIG_fail;
20533 swig_obj[0] = args;
20534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20535 if (!SWIG_IsOK(res1)) {
20536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20537 }
20538 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20539 {
20540 PyThreadState* __tstate = wxPyBeginAllowThreads();
20541 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20542 wxPyEndAllowThreads(__tstate);
20543 if (PyErr_Occurred()) SWIG_fail;
20544 }
20545 {
20546 resultobj = wxPyMake_wxObject(result, 0);
20547 }
20548 return resultobj;
20549 fail:
20550 return NULL;
20551 }
20552
20553
20554 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20555 PyObject *resultobj = 0;
20556 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20557 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20558 void *argp1 = 0 ;
20559 int res1 = 0 ;
20560 void *argp2 = 0 ;
20561 int res2 = 0 ;
20562 PyObject * obj0 = 0 ;
20563 PyObject * obj1 = 0 ;
20564 char * kwnames[] = {
20565 (char *) "self",(char *) "handler", NULL
20566 };
20567
20568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20570 if (!SWIG_IsOK(res1)) {
20571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20572 }
20573 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20574 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20575 if (!SWIG_IsOK(res2)) {
20576 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20577 }
20578 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20579 {
20580 PyThreadState* __tstate = wxPyBeginAllowThreads();
20581 (arg1)->SetNextHandler(arg2);
20582 wxPyEndAllowThreads(__tstate);
20583 if (PyErr_Occurred()) SWIG_fail;
20584 }
20585 resultobj = SWIG_Py_Void();
20586 return resultobj;
20587 fail:
20588 return NULL;
20589 }
20590
20591
20592 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20593 PyObject *resultobj = 0;
20594 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20595 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20596 void *argp1 = 0 ;
20597 int res1 = 0 ;
20598 void *argp2 = 0 ;
20599 int res2 = 0 ;
20600 PyObject * obj0 = 0 ;
20601 PyObject * obj1 = 0 ;
20602 char * kwnames[] = {
20603 (char *) "self",(char *) "handler", NULL
20604 };
20605
20606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20608 if (!SWIG_IsOK(res1)) {
20609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20610 }
20611 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20612 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20613 if (!SWIG_IsOK(res2)) {
20614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20615 }
20616 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20617 {
20618 PyThreadState* __tstate = wxPyBeginAllowThreads();
20619 (arg1)->SetPreviousHandler(arg2);
20620 wxPyEndAllowThreads(__tstate);
20621 if (PyErr_Occurred()) SWIG_fail;
20622 }
20623 resultobj = SWIG_Py_Void();
20624 return resultobj;
20625 fail:
20626 return NULL;
20627 }
20628
20629
20630 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20631 PyObject *resultobj = 0;
20632 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20633 bool result;
20634 void *argp1 = 0 ;
20635 int res1 = 0 ;
20636 PyObject *swig_obj[1] ;
20637
20638 if (!args) SWIG_fail;
20639 swig_obj[0] = args;
20640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20641 if (!SWIG_IsOK(res1)) {
20642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20643 }
20644 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20645 {
20646 PyThreadState* __tstate = wxPyBeginAllowThreads();
20647 result = (bool)(arg1)->GetEvtHandlerEnabled();
20648 wxPyEndAllowThreads(__tstate);
20649 if (PyErr_Occurred()) SWIG_fail;
20650 }
20651 {
20652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20653 }
20654 return resultobj;
20655 fail:
20656 return NULL;
20657 }
20658
20659
20660 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20661 PyObject *resultobj = 0;
20662 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20663 bool arg2 ;
20664 void *argp1 = 0 ;
20665 int res1 = 0 ;
20666 bool val2 ;
20667 int ecode2 = 0 ;
20668 PyObject * obj0 = 0 ;
20669 PyObject * obj1 = 0 ;
20670 char * kwnames[] = {
20671 (char *) "self",(char *) "enabled", NULL
20672 };
20673
20674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20676 if (!SWIG_IsOK(res1)) {
20677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20678 }
20679 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20680 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20681 if (!SWIG_IsOK(ecode2)) {
20682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20683 }
20684 arg2 = static_cast< bool >(val2);
20685 {
20686 PyThreadState* __tstate = wxPyBeginAllowThreads();
20687 (arg1)->SetEvtHandlerEnabled(arg2);
20688 wxPyEndAllowThreads(__tstate);
20689 if (PyErr_Occurred()) SWIG_fail;
20690 }
20691 resultobj = SWIG_Py_Void();
20692 return resultobj;
20693 fail:
20694 return NULL;
20695 }
20696
20697
20698 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20699 PyObject *resultobj = 0;
20700 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20701 wxEvent *arg2 = 0 ;
20702 bool result;
20703 void *argp1 = 0 ;
20704 int res1 = 0 ;
20705 void *argp2 = 0 ;
20706 int res2 = 0 ;
20707 PyObject * obj0 = 0 ;
20708 PyObject * obj1 = 0 ;
20709 char * kwnames[] = {
20710 (char *) "self",(char *) "event", NULL
20711 };
20712
20713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20715 if (!SWIG_IsOK(res1)) {
20716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20717 }
20718 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20719 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20720 if (!SWIG_IsOK(res2)) {
20721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20722 }
20723 if (!argp2) {
20724 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20725 }
20726 arg2 = reinterpret_cast< wxEvent * >(argp2);
20727 {
20728 PyThreadState* __tstate = wxPyBeginAllowThreads();
20729 result = (bool)(arg1)->ProcessEvent(*arg2);
20730 wxPyEndAllowThreads(__tstate);
20731 if (PyErr_Occurred()) SWIG_fail;
20732 }
20733 {
20734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20735 }
20736 return resultobj;
20737 fail:
20738 return NULL;
20739 }
20740
20741
20742 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20743 PyObject *resultobj = 0;
20744 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20745 wxEvent *arg2 = 0 ;
20746 void *argp1 = 0 ;
20747 int res1 = 0 ;
20748 void *argp2 = 0 ;
20749 int res2 = 0 ;
20750 PyObject * obj0 = 0 ;
20751 PyObject * obj1 = 0 ;
20752 char * kwnames[] = {
20753 (char *) "self",(char *) "event", NULL
20754 };
20755
20756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20758 if (!SWIG_IsOK(res1)) {
20759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20760 }
20761 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20762 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20763 if (!SWIG_IsOK(res2)) {
20764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20765 }
20766 if (!argp2) {
20767 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20768 }
20769 arg2 = reinterpret_cast< wxEvent * >(argp2);
20770 {
20771 PyThreadState* __tstate = wxPyBeginAllowThreads();
20772 (arg1)->AddPendingEvent(*arg2);
20773 wxPyEndAllowThreads(__tstate);
20774 if (PyErr_Occurred()) SWIG_fail;
20775 }
20776 resultobj = SWIG_Py_Void();
20777 return resultobj;
20778 fail:
20779 return NULL;
20780 }
20781
20782
20783 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20784 PyObject *resultobj = 0;
20785 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20786 void *argp1 = 0 ;
20787 int res1 = 0 ;
20788 PyObject *swig_obj[1] ;
20789
20790 if (!args) SWIG_fail;
20791 swig_obj[0] = args;
20792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20793 if (!SWIG_IsOK(res1)) {
20794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20795 }
20796 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20797 {
20798 PyThreadState* __tstate = wxPyBeginAllowThreads();
20799 (arg1)->ProcessPendingEvents();
20800 wxPyEndAllowThreads(__tstate);
20801 if (PyErr_Occurred()) SWIG_fail;
20802 }
20803 resultobj = SWIG_Py_Void();
20804 return resultobj;
20805 fail:
20806 return NULL;
20807 }
20808
20809
20810 SWIGINTERN PyObject *_wrap_EvtHandler_AllowReentrance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20811 PyObject *resultobj = 0;
20812 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20813 bool arg2 = (bool) true ;
20814 void *argp1 = 0 ;
20815 int res1 = 0 ;
20816 bool val2 ;
20817 int ecode2 = 0 ;
20818 PyObject * obj0 = 0 ;
20819 PyObject * obj1 = 0 ;
20820 char * kwnames[] = {
20821 (char *) "self",(char *) "allow", NULL
20822 };
20823
20824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EvtHandler_AllowReentrance",kwnames,&obj0,&obj1)) SWIG_fail;
20825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20826 if (!SWIG_IsOK(res1)) {
20827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20828 }
20829 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20830 if (obj1) {
20831 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20832 if (!SWIG_IsOK(ecode2)) {
20833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "2"" of type '" "bool""'");
20834 }
20835 arg2 = static_cast< bool >(val2);
20836 }
20837 {
20838 PyThreadState* __tstate = wxPyBeginAllowThreads();
20839 (arg1)->AllowReentrance(arg2);
20840 wxPyEndAllowThreads(__tstate);
20841 if (PyErr_Occurred()) SWIG_fail;
20842 }
20843 resultobj = SWIG_Py_Void();
20844 return resultobj;
20845 fail:
20846 return NULL;
20847 }
20848
20849
20850 SWIGINTERN PyObject *_wrap_EvtHandler_IsReentranceAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20851 PyObject *resultobj = 0;
20852 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20853 bool result;
20854 void *argp1 = 0 ;
20855 int res1 = 0 ;
20856 PyObject *swig_obj[1] ;
20857
20858 if (!args) SWIG_fail;
20859 swig_obj[0] = args;
20860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20861 if (!SWIG_IsOK(res1)) {
20862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsReentranceAllowed" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20863 }
20864 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20865 {
20866 PyThreadState* __tstate = wxPyBeginAllowThreads();
20867 result = (bool)(arg1)->IsReentranceAllowed();
20868 wxPyEndAllowThreads(__tstate);
20869 if (PyErr_Occurred()) SWIG_fail;
20870 }
20871 {
20872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20873 }
20874 return resultobj;
20875 fail:
20876 return NULL;
20877 }
20878
20879
20880 SWIGINTERN PyObject *_wrap_EvtHandler_IsEventHandlingInProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20881 PyObject *resultobj = 0;
20882 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20883 bool result;
20884 void *argp1 = 0 ;
20885 int res1 = 0 ;
20886 PyObject *swig_obj[1] ;
20887
20888 if (!args) SWIG_fail;
20889 swig_obj[0] = args;
20890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20891 if (!SWIG_IsOK(res1)) {
20892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsEventHandlingInProgress" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20893 }
20894 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20895 {
20896 PyThreadState* __tstate = wxPyBeginAllowThreads();
20897 result = (bool)(arg1)->IsEventHandlingInProgress();
20898 wxPyEndAllowThreads(__tstate);
20899 if (PyErr_Occurred()) SWIG_fail;
20900 }
20901 {
20902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20903 }
20904 return resultobj;
20905 fail:
20906 return NULL;
20907 }
20908
20909
20910 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20911 PyObject *resultobj = 0;
20912 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20913 int arg2 ;
20914 int arg3 ;
20915 int arg4 ;
20916 PyObject *arg5 = (PyObject *) 0 ;
20917 void *argp1 = 0 ;
20918 int res1 = 0 ;
20919 int val2 ;
20920 int ecode2 = 0 ;
20921 int val3 ;
20922 int ecode3 = 0 ;
20923 int val4 ;
20924 int ecode4 = 0 ;
20925 PyObject * obj0 = 0 ;
20926 PyObject * obj1 = 0 ;
20927 PyObject * obj2 = 0 ;
20928 PyObject * obj3 = 0 ;
20929 PyObject * obj4 = 0 ;
20930 char * kwnames[] = {
20931 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20932 };
20933
20934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20936 if (!SWIG_IsOK(res1)) {
20937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20938 }
20939 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20940 ecode2 = SWIG_AsVal_int(obj1, &val2);
20941 if (!SWIG_IsOK(ecode2)) {
20942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
20943 }
20944 arg2 = static_cast< int >(val2);
20945 ecode3 = SWIG_AsVal_int(obj2, &val3);
20946 if (!SWIG_IsOK(ecode3)) {
20947 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
20948 }
20949 arg3 = static_cast< int >(val3);
20950 ecode4 = SWIG_AsVal_int(obj3, &val4);
20951 if (!SWIG_IsOK(ecode4)) {
20952 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
20953 }
20954 arg4 = static_cast< int >(val4);
20955 arg5 = obj4;
20956 {
20957 PyThreadState* __tstate = wxPyBeginAllowThreads();
20958 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
20959 wxPyEndAllowThreads(__tstate);
20960 if (PyErr_Occurred()) SWIG_fail;
20961 }
20962 resultobj = SWIG_Py_Void();
20963 return resultobj;
20964 fail:
20965 return NULL;
20966 }
20967
20968
20969 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20970 PyObject *resultobj = 0;
20971 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20972 int arg2 ;
20973 int arg3 = (int) -1 ;
20974 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
20975 bool result;
20976 void *argp1 = 0 ;
20977 int res1 = 0 ;
20978 int val2 ;
20979 int ecode2 = 0 ;
20980 int val3 ;
20981 int ecode3 = 0 ;
20982 int val4 ;
20983 int ecode4 = 0 ;
20984 PyObject * obj0 = 0 ;
20985 PyObject * obj1 = 0 ;
20986 PyObject * obj2 = 0 ;
20987 PyObject * obj3 = 0 ;
20988 char * kwnames[] = {
20989 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
20990 };
20991
20992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20994 if (!SWIG_IsOK(res1)) {
20995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20996 }
20997 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20998 ecode2 = SWIG_AsVal_int(obj1, &val2);
20999 if (!SWIG_IsOK(ecode2)) {
21000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
21001 }
21002 arg2 = static_cast< int >(val2);
21003 if (obj2) {
21004 ecode3 = SWIG_AsVal_int(obj2, &val3);
21005 if (!SWIG_IsOK(ecode3)) {
21006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
21007 }
21008 arg3 = static_cast< int >(val3);
21009 }
21010 if (obj3) {
21011 ecode4 = SWIG_AsVal_int(obj3, &val4);
21012 if (!SWIG_IsOK(ecode4)) {
21013 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
21014 }
21015 arg4 = static_cast< wxEventType >(val4);
21016 }
21017 {
21018 PyThreadState* __tstate = wxPyBeginAllowThreads();
21019 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
21020 wxPyEndAllowThreads(__tstate);
21021 if (PyErr_Occurred()) SWIG_fail;
21022 }
21023 {
21024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21025 }
21026 return resultobj;
21027 fail:
21028 return NULL;
21029 }
21030
21031
21032 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21033 PyObject *resultobj = 0;
21034 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21035 PyObject *arg2 = (PyObject *) 0 ;
21036 bool arg3 = (bool) true ;
21037 void *argp1 = 0 ;
21038 int res1 = 0 ;
21039 bool val3 ;
21040 int ecode3 = 0 ;
21041 PyObject * obj0 = 0 ;
21042 PyObject * obj1 = 0 ;
21043 PyObject * obj2 = 0 ;
21044 char * kwnames[] = {
21045 (char *) "self",(char *) "_self",(char *) "incref", NULL
21046 };
21047
21048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21050 if (!SWIG_IsOK(res1)) {
21051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21052 }
21053 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21054 arg2 = obj1;
21055 if (obj2) {
21056 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21057 if (!SWIG_IsOK(ecode3)) {
21058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21059 }
21060 arg3 = static_cast< bool >(val3);
21061 }
21062 {
21063 PyThreadState* __tstate = wxPyBeginAllowThreads();
21064 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21065 wxPyEndAllowThreads(__tstate);
21066 if (PyErr_Occurred()) SWIG_fail;
21067 }
21068 resultobj = SWIG_Py_Void();
21069 return resultobj;
21070 fail:
21071 return NULL;
21072 }
21073
21074
21075 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21076 PyObject *obj;
21077 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21078 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21079 return SWIG_Py_Void();
21080 }
21081
21082 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21083 return SWIG_Python_InitShadowInstance(args);
21084 }
21085
21086 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21087 PyObject *resultobj = 0;
21088 wxEventType result;
21089
21090 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21091 {
21092 PyThreadState* __tstate = wxPyBeginAllowThreads();
21093 result = (wxEventType)wxNewEventType();
21094 wxPyEndAllowThreads(__tstate);
21095 if (PyErr_Occurred()) SWIG_fail;
21096 }
21097 resultobj = SWIG_From_int(static_cast< int >(result));
21098 return resultobj;
21099 fail:
21100 return NULL;
21101 }
21102
21103
21104 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21105 PyObject *resultobj = 0;
21106 wxEvent *arg1 = (wxEvent *) 0 ;
21107 void *argp1 = 0 ;
21108 int res1 = 0 ;
21109 PyObject *swig_obj[1] ;
21110
21111 if (!args) SWIG_fail;
21112 swig_obj[0] = args;
21113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21114 if (!SWIG_IsOK(res1)) {
21115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21116 }
21117 arg1 = reinterpret_cast< wxEvent * >(argp1);
21118 {
21119 PyThreadState* __tstate = wxPyBeginAllowThreads();
21120 delete arg1;
21121
21122 wxPyEndAllowThreads(__tstate);
21123 if (PyErr_Occurred()) SWIG_fail;
21124 }
21125 resultobj = SWIG_Py_Void();
21126 return resultobj;
21127 fail:
21128 return NULL;
21129 }
21130
21131
21132 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21133 PyObject *resultobj = 0;
21134 wxEvent *arg1 = (wxEvent *) 0 ;
21135 wxEventType arg2 ;
21136 void *argp1 = 0 ;
21137 int res1 = 0 ;
21138 int val2 ;
21139 int ecode2 = 0 ;
21140 PyObject * obj0 = 0 ;
21141 PyObject * obj1 = 0 ;
21142 char * kwnames[] = {
21143 (char *) "self",(char *) "typ", NULL
21144 };
21145
21146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21148 if (!SWIG_IsOK(res1)) {
21149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21150 }
21151 arg1 = reinterpret_cast< wxEvent * >(argp1);
21152 ecode2 = SWIG_AsVal_int(obj1, &val2);
21153 if (!SWIG_IsOK(ecode2)) {
21154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21155 }
21156 arg2 = static_cast< wxEventType >(val2);
21157 {
21158 PyThreadState* __tstate = wxPyBeginAllowThreads();
21159 (arg1)->SetEventType(arg2);
21160 wxPyEndAllowThreads(__tstate);
21161 if (PyErr_Occurred()) SWIG_fail;
21162 }
21163 resultobj = SWIG_Py_Void();
21164 return resultobj;
21165 fail:
21166 return NULL;
21167 }
21168
21169
21170 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21171 PyObject *resultobj = 0;
21172 wxEvent *arg1 = (wxEvent *) 0 ;
21173 wxEventType result;
21174 void *argp1 = 0 ;
21175 int res1 = 0 ;
21176 PyObject *swig_obj[1] ;
21177
21178 if (!args) SWIG_fail;
21179 swig_obj[0] = args;
21180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21181 if (!SWIG_IsOK(res1)) {
21182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21183 }
21184 arg1 = reinterpret_cast< wxEvent * >(argp1);
21185 {
21186 PyThreadState* __tstate = wxPyBeginAllowThreads();
21187 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21188 wxPyEndAllowThreads(__tstate);
21189 if (PyErr_Occurred()) SWIG_fail;
21190 }
21191 resultobj = SWIG_From_int(static_cast< int >(result));
21192 return resultobj;
21193 fail:
21194 return NULL;
21195 }
21196
21197
21198 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21199 PyObject *resultobj = 0;
21200 wxEvent *arg1 = (wxEvent *) 0 ;
21201 wxObject *result = 0 ;
21202 void *argp1 = 0 ;
21203 int res1 = 0 ;
21204 PyObject *swig_obj[1] ;
21205
21206 if (!args) SWIG_fail;
21207 swig_obj[0] = args;
21208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21209 if (!SWIG_IsOK(res1)) {
21210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21211 }
21212 arg1 = reinterpret_cast< wxEvent * >(argp1);
21213 {
21214 PyThreadState* __tstate = wxPyBeginAllowThreads();
21215 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21216 wxPyEndAllowThreads(__tstate);
21217 if (PyErr_Occurred()) SWIG_fail;
21218 }
21219 {
21220 resultobj = wxPyMake_wxObject(result, (bool)0);
21221 }
21222 return resultobj;
21223 fail:
21224 return NULL;
21225 }
21226
21227
21228 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21229 PyObject *resultobj = 0;
21230 wxEvent *arg1 = (wxEvent *) 0 ;
21231 wxObject *arg2 = (wxObject *) 0 ;
21232 void *argp1 = 0 ;
21233 int res1 = 0 ;
21234 void *argp2 = 0 ;
21235 int res2 = 0 ;
21236 PyObject * obj0 = 0 ;
21237 PyObject * obj1 = 0 ;
21238 char * kwnames[] = {
21239 (char *) "self",(char *) "obj", NULL
21240 };
21241
21242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21244 if (!SWIG_IsOK(res1)) {
21245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21246 }
21247 arg1 = reinterpret_cast< wxEvent * >(argp1);
21248 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21249 if (!SWIG_IsOK(res2)) {
21250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21251 }
21252 arg2 = reinterpret_cast< wxObject * >(argp2);
21253 {
21254 PyThreadState* __tstate = wxPyBeginAllowThreads();
21255 (arg1)->SetEventObject(arg2);
21256 wxPyEndAllowThreads(__tstate);
21257 if (PyErr_Occurred()) SWIG_fail;
21258 }
21259 resultobj = SWIG_Py_Void();
21260 return resultobj;
21261 fail:
21262 return NULL;
21263 }
21264
21265
21266 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21267 PyObject *resultobj = 0;
21268 wxEvent *arg1 = (wxEvent *) 0 ;
21269 long result;
21270 void *argp1 = 0 ;
21271 int res1 = 0 ;
21272 PyObject *swig_obj[1] ;
21273
21274 if (!args) SWIG_fail;
21275 swig_obj[0] = args;
21276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21277 if (!SWIG_IsOK(res1)) {
21278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21279 }
21280 arg1 = reinterpret_cast< wxEvent * >(argp1);
21281 {
21282 PyThreadState* __tstate = wxPyBeginAllowThreads();
21283 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21284 wxPyEndAllowThreads(__tstate);
21285 if (PyErr_Occurred()) SWIG_fail;
21286 }
21287 resultobj = SWIG_From_long(static_cast< long >(result));
21288 return resultobj;
21289 fail:
21290 return NULL;
21291 }
21292
21293
21294 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21295 PyObject *resultobj = 0;
21296 wxEvent *arg1 = (wxEvent *) 0 ;
21297 long arg2 = (long) 0 ;
21298 void *argp1 = 0 ;
21299 int res1 = 0 ;
21300 long val2 ;
21301 int ecode2 = 0 ;
21302 PyObject * obj0 = 0 ;
21303 PyObject * obj1 = 0 ;
21304 char * kwnames[] = {
21305 (char *) "self",(char *) "ts", NULL
21306 };
21307
21308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21310 if (!SWIG_IsOK(res1)) {
21311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21312 }
21313 arg1 = reinterpret_cast< wxEvent * >(argp1);
21314 if (obj1) {
21315 ecode2 = SWIG_AsVal_long(obj1, &val2);
21316 if (!SWIG_IsOK(ecode2)) {
21317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21318 }
21319 arg2 = static_cast< long >(val2);
21320 }
21321 {
21322 PyThreadState* __tstate = wxPyBeginAllowThreads();
21323 (arg1)->SetTimestamp(arg2);
21324 wxPyEndAllowThreads(__tstate);
21325 if (PyErr_Occurred()) SWIG_fail;
21326 }
21327 resultobj = SWIG_Py_Void();
21328 return resultobj;
21329 fail:
21330 return NULL;
21331 }
21332
21333
21334 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21335 PyObject *resultobj = 0;
21336 wxEvent *arg1 = (wxEvent *) 0 ;
21337 int result;
21338 void *argp1 = 0 ;
21339 int res1 = 0 ;
21340 PyObject *swig_obj[1] ;
21341
21342 if (!args) SWIG_fail;
21343 swig_obj[0] = args;
21344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21345 if (!SWIG_IsOK(res1)) {
21346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21347 }
21348 arg1 = reinterpret_cast< wxEvent * >(argp1);
21349 {
21350 PyThreadState* __tstate = wxPyBeginAllowThreads();
21351 result = (int)((wxEvent const *)arg1)->GetId();
21352 wxPyEndAllowThreads(__tstate);
21353 if (PyErr_Occurred()) SWIG_fail;
21354 }
21355 resultobj = SWIG_From_int(static_cast< int >(result));
21356 return resultobj;
21357 fail:
21358 return NULL;
21359 }
21360
21361
21362 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21363 PyObject *resultobj = 0;
21364 wxEvent *arg1 = (wxEvent *) 0 ;
21365 int arg2 ;
21366 void *argp1 = 0 ;
21367 int res1 = 0 ;
21368 int val2 ;
21369 int ecode2 = 0 ;
21370 PyObject * obj0 = 0 ;
21371 PyObject * obj1 = 0 ;
21372 char * kwnames[] = {
21373 (char *) "self",(char *) "Id", NULL
21374 };
21375
21376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21378 if (!SWIG_IsOK(res1)) {
21379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21380 }
21381 arg1 = reinterpret_cast< wxEvent * >(argp1);
21382 ecode2 = SWIG_AsVal_int(obj1, &val2);
21383 if (!SWIG_IsOK(ecode2)) {
21384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21385 }
21386 arg2 = static_cast< int >(val2);
21387 {
21388 PyThreadState* __tstate = wxPyBeginAllowThreads();
21389 (arg1)->SetId(arg2);
21390 wxPyEndAllowThreads(__tstate);
21391 if (PyErr_Occurred()) SWIG_fail;
21392 }
21393 resultobj = SWIG_Py_Void();
21394 return resultobj;
21395 fail:
21396 return NULL;
21397 }
21398
21399
21400 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21401 PyObject *resultobj = 0;
21402 wxEvent *arg1 = (wxEvent *) 0 ;
21403 bool result;
21404 void *argp1 = 0 ;
21405 int res1 = 0 ;
21406 PyObject *swig_obj[1] ;
21407
21408 if (!args) SWIG_fail;
21409 swig_obj[0] = args;
21410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21411 if (!SWIG_IsOK(res1)) {
21412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21413 }
21414 arg1 = reinterpret_cast< wxEvent * >(argp1);
21415 {
21416 PyThreadState* __tstate = wxPyBeginAllowThreads();
21417 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21418 wxPyEndAllowThreads(__tstate);
21419 if (PyErr_Occurred()) SWIG_fail;
21420 }
21421 {
21422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21423 }
21424 return resultobj;
21425 fail:
21426 return NULL;
21427 }
21428
21429
21430 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21431 PyObject *resultobj = 0;
21432 wxEvent *arg1 = (wxEvent *) 0 ;
21433 bool arg2 = (bool) true ;
21434 void *argp1 = 0 ;
21435 int res1 = 0 ;
21436 bool val2 ;
21437 int ecode2 = 0 ;
21438 PyObject * obj0 = 0 ;
21439 PyObject * obj1 = 0 ;
21440 char * kwnames[] = {
21441 (char *) "self",(char *) "skip", NULL
21442 };
21443
21444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21446 if (!SWIG_IsOK(res1)) {
21447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21448 }
21449 arg1 = reinterpret_cast< wxEvent * >(argp1);
21450 if (obj1) {
21451 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21452 if (!SWIG_IsOK(ecode2)) {
21453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21454 }
21455 arg2 = static_cast< bool >(val2);
21456 }
21457 {
21458 PyThreadState* __tstate = wxPyBeginAllowThreads();
21459 (arg1)->Skip(arg2);
21460 wxPyEndAllowThreads(__tstate);
21461 if (PyErr_Occurred()) SWIG_fail;
21462 }
21463 resultobj = SWIG_Py_Void();
21464 return resultobj;
21465 fail:
21466 return NULL;
21467 }
21468
21469
21470 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21471 PyObject *resultobj = 0;
21472 wxEvent *arg1 = (wxEvent *) 0 ;
21473 bool result;
21474 void *argp1 = 0 ;
21475 int res1 = 0 ;
21476 PyObject *swig_obj[1] ;
21477
21478 if (!args) SWIG_fail;
21479 swig_obj[0] = args;
21480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21481 if (!SWIG_IsOK(res1)) {
21482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21483 }
21484 arg1 = reinterpret_cast< wxEvent * >(argp1);
21485 {
21486 PyThreadState* __tstate = wxPyBeginAllowThreads();
21487 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21488 wxPyEndAllowThreads(__tstate);
21489 if (PyErr_Occurred()) SWIG_fail;
21490 }
21491 {
21492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21493 }
21494 return resultobj;
21495 fail:
21496 return NULL;
21497 }
21498
21499
21500 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21501 PyObject *resultobj = 0;
21502 wxEvent *arg1 = (wxEvent *) 0 ;
21503 bool result;
21504 void *argp1 = 0 ;
21505 int res1 = 0 ;
21506 PyObject *swig_obj[1] ;
21507
21508 if (!args) SWIG_fail;
21509 swig_obj[0] = args;
21510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21511 if (!SWIG_IsOK(res1)) {
21512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21513 }
21514 arg1 = reinterpret_cast< wxEvent * >(argp1);
21515 {
21516 PyThreadState* __tstate = wxPyBeginAllowThreads();
21517 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21518 wxPyEndAllowThreads(__tstate);
21519 if (PyErr_Occurred()) SWIG_fail;
21520 }
21521 {
21522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21523 }
21524 return resultobj;
21525 fail:
21526 return NULL;
21527 }
21528
21529
21530 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21531 PyObject *resultobj = 0;
21532 wxEvent *arg1 = (wxEvent *) 0 ;
21533 int result;
21534 void *argp1 = 0 ;
21535 int res1 = 0 ;
21536 PyObject *swig_obj[1] ;
21537
21538 if (!args) SWIG_fail;
21539 swig_obj[0] = args;
21540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21541 if (!SWIG_IsOK(res1)) {
21542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21543 }
21544 arg1 = reinterpret_cast< wxEvent * >(argp1);
21545 {
21546 PyThreadState* __tstate = wxPyBeginAllowThreads();
21547 result = (int)(arg1)->StopPropagation();
21548 wxPyEndAllowThreads(__tstate);
21549 if (PyErr_Occurred()) SWIG_fail;
21550 }
21551 resultobj = SWIG_From_int(static_cast< int >(result));
21552 return resultobj;
21553 fail:
21554 return NULL;
21555 }
21556
21557
21558 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21559 PyObject *resultobj = 0;
21560 wxEvent *arg1 = (wxEvent *) 0 ;
21561 int arg2 ;
21562 void *argp1 = 0 ;
21563 int res1 = 0 ;
21564 int val2 ;
21565 int ecode2 = 0 ;
21566 PyObject * obj0 = 0 ;
21567 PyObject * obj1 = 0 ;
21568 char * kwnames[] = {
21569 (char *) "self",(char *) "propagationLevel", NULL
21570 };
21571
21572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21574 if (!SWIG_IsOK(res1)) {
21575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21576 }
21577 arg1 = reinterpret_cast< wxEvent * >(argp1);
21578 ecode2 = SWIG_AsVal_int(obj1, &val2);
21579 if (!SWIG_IsOK(ecode2)) {
21580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21581 }
21582 arg2 = static_cast< int >(val2);
21583 {
21584 PyThreadState* __tstate = wxPyBeginAllowThreads();
21585 (arg1)->ResumePropagation(arg2);
21586 wxPyEndAllowThreads(__tstate);
21587 if (PyErr_Occurred()) SWIG_fail;
21588 }
21589 resultobj = SWIG_Py_Void();
21590 return resultobj;
21591 fail:
21592 return NULL;
21593 }
21594
21595
21596 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21597 PyObject *resultobj = 0;
21598 wxEvent *arg1 = (wxEvent *) 0 ;
21599 wxEvent *result = 0 ;
21600 void *argp1 = 0 ;
21601 int res1 = 0 ;
21602 PyObject *swig_obj[1] ;
21603
21604 if (!args) SWIG_fail;
21605 swig_obj[0] = args;
21606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21607 if (!SWIG_IsOK(res1)) {
21608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21609 }
21610 arg1 = reinterpret_cast< wxEvent * >(argp1);
21611 {
21612 PyThreadState* __tstate = wxPyBeginAllowThreads();
21613 result = (wxEvent *)(arg1)->Clone();
21614 wxPyEndAllowThreads(__tstate);
21615 if (PyErr_Occurred()) SWIG_fail;
21616 }
21617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21618 return resultobj;
21619 fail:
21620 return NULL;
21621 }
21622
21623
21624 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21625 PyObject *obj;
21626 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21627 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21628 return SWIG_Py_Void();
21629 }
21630
21631 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21632 PyObject *resultobj = 0;
21633 wxEvent *arg1 = 0 ;
21634 wxPropagationDisabler *result = 0 ;
21635 void *argp1 = 0 ;
21636 int res1 = 0 ;
21637 PyObject * obj0 = 0 ;
21638 char * kwnames[] = {
21639 (char *) "event", NULL
21640 };
21641
21642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21643 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21644 if (!SWIG_IsOK(res1)) {
21645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21646 }
21647 if (!argp1) {
21648 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21649 }
21650 arg1 = reinterpret_cast< wxEvent * >(argp1);
21651 {
21652 PyThreadState* __tstate = wxPyBeginAllowThreads();
21653 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21654 wxPyEndAllowThreads(__tstate);
21655 if (PyErr_Occurred()) SWIG_fail;
21656 }
21657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21658 return resultobj;
21659 fail:
21660 return NULL;
21661 }
21662
21663
21664 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21665 PyObject *resultobj = 0;
21666 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21667 void *argp1 = 0 ;
21668 int res1 = 0 ;
21669 PyObject *swig_obj[1] ;
21670
21671 if (!args) SWIG_fail;
21672 swig_obj[0] = args;
21673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21674 if (!SWIG_IsOK(res1)) {
21675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21676 }
21677 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21678 {
21679 PyThreadState* __tstate = wxPyBeginAllowThreads();
21680 delete arg1;
21681
21682 wxPyEndAllowThreads(__tstate);
21683 if (PyErr_Occurred()) SWIG_fail;
21684 }
21685 resultobj = SWIG_Py_Void();
21686 return resultobj;
21687 fail:
21688 return NULL;
21689 }
21690
21691
21692 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21693 PyObject *obj;
21694 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21695 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21696 return SWIG_Py_Void();
21697 }
21698
21699 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21700 return SWIG_Python_InitShadowInstance(args);
21701 }
21702
21703 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21704 PyObject *resultobj = 0;
21705 wxEvent *arg1 = 0 ;
21706 wxPropagateOnce *result = 0 ;
21707 void *argp1 = 0 ;
21708 int res1 = 0 ;
21709 PyObject * obj0 = 0 ;
21710 char * kwnames[] = {
21711 (char *) "event", NULL
21712 };
21713
21714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21715 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21716 if (!SWIG_IsOK(res1)) {
21717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21718 }
21719 if (!argp1) {
21720 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21721 }
21722 arg1 = reinterpret_cast< wxEvent * >(argp1);
21723 {
21724 PyThreadState* __tstate = wxPyBeginAllowThreads();
21725 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21726 wxPyEndAllowThreads(__tstate);
21727 if (PyErr_Occurred()) SWIG_fail;
21728 }
21729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21730 return resultobj;
21731 fail:
21732 return NULL;
21733 }
21734
21735
21736 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21737 PyObject *resultobj = 0;
21738 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21739 void *argp1 = 0 ;
21740 int res1 = 0 ;
21741 PyObject *swig_obj[1] ;
21742
21743 if (!args) SWIG_fail;
21744 swig_obj[0] = args;
21745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21746 if (!SWIG_IsOK(res1)) {
21747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21748 }
21749 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21750 {
21751 PyThreadState* __tstate = wxPyBeginAllowThreads();
21752 delete arg1;
21753
21754 wxPyEndAllowThreads(__tstate);
21755 if (PyErr_Occurred()) SWIG_fail;
21756 }
21757 resultobj = SWIG_Py_Void();
21758 return resultobj;
21759 fail:
21760 return NULL;
21761 }
21762
21763
21764 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21765 PyObject *obj;
21766 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21767 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21768 return SWIG_Py_Void();
21769 }
21770
21771 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21772 return SWIG_Python_InitShadowInstance(args);
21773 }
21774
21775 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21776 PyObject *resultobj = 0;
21777 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21778 int arg2 = (int) 0 ;
21779 wxCommandEvent *result = 0 ;
21780 int val1 ;
21781 int ecode1 = 0 ;
21782 int val2 ;
21783 int ecode2 = 0 ;
21784 PyObject * obj0 = 0 ;
21785 PyObject * obj1 = 0 ;
21786 char * kwnames[] = {
21787 (char *) "commandType",(char *) "winid", NULL
21788 };
21789
21790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21791 if (obj0) {
21792 ecode1 = SWIG_AsVal_int(obj0, &val1);
21793 if (!SWIG_IsOK(ecode1)) {
21794 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21795 }
21796 arg1 = static_cast< wxEventType >(val1);
21797 }
21798 if (obj1) {
21799 ecode2 = SWIG_AsVal_int(obj1, &val2);
21800 if (!SWIG_IsOK(ecode2)) {
21801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21802 }
21803 arg2 = static_cast< int >(val2);
21804 }
21805 {
21806 PyThreadState* __tstate = wxPyBeginAllowThreads();
21807 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21808 wxPyEndAllowThreads(__tstate);
21809 if (PyErr_Occurred()) SWIG_fail;
21810 }
21811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21812 return resultobj;
21813 fail:
21814 return NULL;
21815 }
21816
21817
21818 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21819 PyObject *resultobj = 0;
21820 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21821 int result;
21822 void *argp1 = 0 ;
21823 int res1 = 0 ;
21824 PyObject *swig_obj[1] ;
21825
21826 if (!args) SWIG_fail;
21827 swig_obj[0] = args;
21828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21829 if (!SWIG_IsOK(res1)) {
21830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21831 }
21832 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21833 {
21834 PyThreadState* __tstate = wxPyBeginAllowThreads();
21835 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21836 wxPyEndAllowThreads(__tstate);
21837 if (PyErr_Occurred()) SWIG_fail;
21838 }
21839 resultobj = SWIG_From_int(static_cast< int >(result));
21840 return resultobj;
21841 fail:
21842 return NULL;
21843 }
21844
21845
21846 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21847 PyObject *resultobj = 0;
21848 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21849 wxString *arg2 = 0 ;
21850 void *argp1 = 0 ;
21851 int res1 = 0 ;
21852 bool temp2 = false ;
21853 PyObject * obj0 = 0 ;
21854 PyObject * obj1 = 0 ;
21855 char * kwnames[] = {
21856 (char *) "self",(char *) "s", NULL
21857 };
21858
21859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21861 if (!SWIG_IsOK(res1)) {
21862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21863 }
21864 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21865 {
21866 arg2 = wxString_in_helper(obj1);
21867 if (arg2 == NULL) SWIG_fail;
21868 temp2 = true;
21869 }
21870 {
21871 PyThreadState* __tstate = wxPyBeginAllowThreads();
21872 (arg1)->SetString((wxString const &)*arg2);
21873 wxPyEndAllowThreads(__tstate);
21874 if (PyErr_Occurred()) SWIG_fail;
21875 }
21876 resultobj = SWIG_Py_Void();
21877 {
21878 if (temp2)
21879 delete arg2;
21880 }
21881 return resultobj;
21882 fail:
21883 {
21884 if (temp2)
21885 delete arg2;
21886 }
21887 return NULL;
21888 }
21889
21890
21891 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21892 PyObject *resultobj = 0;
21893 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21894 wxString result;
21895 void *argp1 = 0 ;
21896 int res1 = 0 ;
21897 PyObject *swig_obj[1] ;
21898
21899 if (!args) SWIG_fail;
21900 swig_obj[0] = args;
21901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21902 if (!SWIG_IsOK(res1)) {
21903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21904 }
21905 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21906 {
21907 PyThreadState* __tstate = wxPyBeginAllowThreads();
21908 result = ((wxCommandEvent const *)arg1)->GetString();
21909 wxPyEndAllowThreads(__tstate);
21910 if (PyErr_Occurred()) SWIG_fail;
21911 }
21912 {
21913 #if wxUSE_UNICODE
21914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21915 #else
21916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21917 #endif
21918 }
21919 return resultobj;
21920 fail:
21921 return NULL;
21922 }
21923
21924
21925 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21926 PyObject *resultobj = 0;
21927 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21928 bool result;
21929 void *argp1 = 0 ;
21930 int res1 = 0 ;
21931 PyObject *swig_obj[1] ;
21932
21933 if (!args) SWIG_fail;
21934 swig_obj[0] = args;
21935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21936 if (!SWIG_IsOK(res1)) {
21937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21938 }
21939 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21940 {
21941 PyThreadState* __tstate = wxPyBeginAllowThreads();
21942 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
21943 wxPyEndAllowThreads(__tstate);
21944 if (PyErr_Occurred()) SWIG_fail;
21945 }
21946 {
21947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21948 }
21949 return resultobj;
21950 fail:
21951 return NULL;
21952 }
21953
21954
21955 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21956 PyObject *resultobj = 0;
21957 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21958 bool result;
21959 void *argp1 = 0 ;
21960 int res1 = 0 ;
21961 PyObject *swig_obj[1] ;
21962
21963 if (!args) SWIG_fail;
21964 swig_obj[0] = args;
21965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21966 if (!SWIG_IsOK(res1)) {
21967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21968 }
21969 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21970 {
21971 PyThreadState* __tstate = wxPyBeginAllowThreads();
21972 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
21973 wxPyEndAllowThreads(__tstate);
21974 if (PyErr_Occurred()) SWIG_fail;
21975 }
21976 {
21977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21978 }
21979 return resultobj;
21980 fail:
21981 return NULL;
21982 }
21983
21984
21985 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21986 PyObject *resultobj = 0;
21987 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21988 long arg2 ;
21989 void *argp1 = 0 ;
21990 int res1 = 0 ;
21991 long val2 ;
21992 int ecode2 = 0 ;
21993 PyObject * obj0 = 0 ;
21994 PyObject * obj1 = 0 ;
21995 char * kwnames[] = {
21996 (char *) "self",(char *) "extraLong", NULL
21997 };
21998
21999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
22000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22001 if (!SWIG_IsOK(res1)) {
22002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22003 }
22004 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22005 ecode2 = SWIG_AsVal_long(obj1, &val2);
22006 if (!SWIG_IsOK(ecode2)) {
22007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
22008 }
22009 arg2 = static_cast< long >(val2);
22010 {
22011 PyThreadState* __tstate = wxPyBeginAllowThreads();
22012 (arg1)->SetExtraLong(arg2);
22013 wxPyEndAllowThreads(__tstate);
22014 if (PyErr_Occurred()) SWIG_fail;
22015 }
22016 resultobj = SWIG_Py_Void();
22017 return resultobj;
22018 fail:
22019 return NULL;
22020 }
22021
22022
22023 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22024 PyObject *resultobj = 0;
22025 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22026 long result;
22027 void *argp1 = 0 ;
22028 int res1 = 0 ;
22029 PyObject *swig_obj[1] ;
22030
22031 if (!args) SWIG_fail;
22032 swig_obj[0] = args;
22033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22034 if (!SWIG_IsOK(res1)) {
22035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22036 }
22037 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22038 {
22039 PyThreadState* __tstate = wxPyBeginAllowThreads();
22040 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22041 wxPyEndAllowThreads(__tstate);
22042 if (PyErr_Occurred()) SWIG_fail;
22043 }
22044 resultobj = SWIG_From_long(static_cast< long >(result));
22045 return resultobj;
22046 fail:
22047 return NULL;
22048 }
22049
22050
22051 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22052 PyObject *resultobj = 0;
22053 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22054 int arg2 ;
22055 void *argp1 = 0 ;
22056 int res1 = 0 ;
22057 int val2 ;
22058 int ecode2 = 0 ;
22059 PyObject * obj0 = 0 ;
22060 PyObject * obj1 = 0 ;
22061 char * kwnames[] = {
22062 (char *) "self",(char *) "i", NULL
22063 };
22064
22065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22067 if (!SWIG_IsOK(res1)) {
22068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22069 }
22070 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22071 ecode2 = SWIG_AsVal_int(obj1, &val2);
22072 if (!SWIG_IsOK(ecode2)) {
22073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22074 }
22075 arg2 = static_cast< int >(val2);
22076 {
22077 PyThreadState* __tstate = wxPyBeginAllowThreads();
22078 (arg1)->SetInt(arg2);
22079 wxPyEndAllowThreads(__tstate);
22080 if (PyErr_Occurred()) SWIG_fail;
22081 }
22082 resultobj = SWIG_Py_Void();
22083 return resultobj;
22084 fail:
22085 return NULL;
22086 }
22087
22088
22089 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22090 PyObject *resultobj = 0;
22091 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22092 int result;
22093 void *argp1 = 0 ;
22094 int res1 = 0 ;
22095 PyObject *swig_obj[1] ;
22096
22097 if (!args) SWIG_fail;
22098 swig_obj[0] = args;
22099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22100 if (!SWIG_IsOK(res1)) {
22101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22102 }
22103 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22104 {
22105 PyThreadState* __tstate = wxPyBeginAllowThreads();
22106 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22107 wxPyEndAllowThreads(__tstate);
22108 if (PyErr_Occurred()) SWIG_fail;
22109 }
22110 resultobj = SWIG_From_int(static_cast< int >(result));
22111 return resultobj;
22112 fail:
22113 return NULL;
22114 }
22115
22116
22117 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22118 PyObject *resultobj = 0;
22119 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22120 PyObject *result = 0 ;
22121 void *argp1 = 0 ;
22122 int res1 = 0 ;
22123 PyObject *swig_obj[1] ;
22124
22125 if (!args) SWIG_fail;
22126 swig_obj[0] = args;
22127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22128 if (!SWIG_IsOK(res1)) {
22129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22130 }
22131 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22132 {
22133 PyThreadState* __tstate = wxPyBeginAllowThreads();
22134 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22135 wxPyEndAllowThreads(__tstate);
22136 if (PyErr_Occurred()) SWIG_fail;
22137 }
22138 resultobj = result;
22139 return resultobj;
22140 fail:
22141 return NULL;
22142 }
22143
22144
22145 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22146 PyObject *resultobj = 0;
22147 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22148 PyObject *arg2 = (PyObject *) 0 ;
22149 void *argp1 = 0 ;
22150 int res1 = 0 ;
22151 PyObject * obj0 = 0 ;
22152 PyObject * obj1 = 0 ;
22153 char * kwnames[] = {
22154 (char *) "self",(char *) "clientData", NULL
22155 };
22156
22157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22159 if (!SWIG_IsOK(res1)) {
22160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22161 }
22162 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22163 arg2 = obj1;
22164 {
22165 PyThreadState* __tstate = wxPyBeginAllowThreads();
22166 wxCommandEvent_SetClientData(arg1,arg2);
22167 wxPyEndAllowThreads(__tstate);
22168 if (PyErr_Occurred()) SWIG_fail;
22169 }
22170 resultobj = SWIG_Py_Void();
22171 return resultobj;
22172 fail:
22173 return NULL;
22174 }
22175
22176
22177 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22178 PyObject *resultobj = 0;
22179 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22180 wxEvent *result = 0 ;
22181 void *argp1 = 0 ;
22182 int res1 = 0 ;
22183 PyObject *swig_obj[1] ;
22184
22185 if (!args) SWIG_fail;
22186 swig_obj[0] = args;
22187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22188 if (!SWIG_IsOK(res1)) {
22189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22190 }
22191 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22192 {
22193 PyThreadState* __tstate = wxPyBeginAllowThreads();
22194 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22195 wxPyEndAllowThreads(__tstate);
22196 if (PyErr_Occurred()) SWIG_fail;
22197 }
22198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22199 return resultobj;
22200 fail:
22201 return NULL;
22202 }
22203
22204
22205 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22206 PyObject *obj;
22207 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22208 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22209 return SWIG_Py_Void();
22210 }
22211
22212 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22213 return SWIG_Python_InitShadowInstance(args);
22214 }
22215
22216 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22217 PyObject *resultobj = 0;
22218 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22219 int arg2 = (int) 0 ;
22220 wxNotifyEvent *result = 0 ;
22221 int val1 ;
22222 int ecode1 = 0 ;
22223 int val2 ;
22224 int ecode2 = 0 ;
22225 PyObject * obj0 = 0 ;
22226 PyObject * obj1 = 0 ;
22227 char * kwnames[] = {
22228 (char *) "commandType",(char *) "winid", NULL
22229 };
22230
22231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22232 if (obj0) {
22233 ecode1 = SWIG_AsVal_int(obj0, &val1);
22234 if (!SWIG_IsOK(ecode1)) {
22235 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22236 }
22237 arg1 = static_cast< wxEventType >(val1);
22238 }
22239 if (obj1) {
22240 ecode2 = SWIG_AsVal_int(obj1, &val2);
22241 if (!SWIG_IsOK(ecode2)) {
22242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22243 }
22244 arg2 = static_cast< int >(val2);
22245 }
22246 {
22247 PyThreadState* __tstate = wxPyBeginAllowThreads();
22248 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22249 wxPyEndAllowThreads(__tstate);
22250 if (PyErr_Occurred()) SWIG_fail;
22251 }
22252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22253 return resultobj;
22254 fail:
22255 return NULL;
22256 }
22257
22258
22259 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22260 PyObject *resultobj = 0;
22261 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22262 void *argp1 = 0 ;
22263 int res1 = 0 ;
22264 PyObject *swig_obj[1] ;
22265
22266 if (!args) SWIG_fail;
22267 swig_obj[0] = args;
22268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22269 if (!SWIG_IsOK(res1)) {
22270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22271 }
22272 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22273 {
22274 PyThreadState* __tstate = wxPyBeginAllowThreads();
22275 (arg1)->Veto();
22276 wxPyEndAllowThreads(__tstate);
22277 if (PyErr_Occurred()) SWIG_fail;
22278 }
22279 resultobj = SWIG_Py_Void();
22280 return resultobj;
22281 fail:
22282 return NULL;
22283 }
22284
22285
22286 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22287 PyObject *resultobj = 0;
22288 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22289 void *argp1 = 0 ;
22290 int res1 = 0 ;
22291 PyObject *swig_obj[1] ;
22292
22293 if (!args) SWIG_fail;
22294 swig_obj[0] = args;
22295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22296 if (!SWIG_IsOK(res1)) {
22297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22298 }
22299 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22300 {
22301 PyThreadState* __tstate = wxPyBeginAllowThreads();
22302 (arg1)->Allow();
22303 wxPyEndAllowThreads(__tstate);
22304 if (PyErr_Occurred()) SWIG_fail;
22305 }
22306 resultobj = SWIG_Py_Void();
22307 return resultobj;
22308 fail:
22309 return NULL;
22310 }
22311
22312
22313 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22314 PyObject *resultobj = 0;
22315 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22316 bool result;
22317 void *argp1 = 0 ;
22318 int res1 = 0 ;
22319 PyObject *swig_obj[1] ;
22320
22321 if (!args) SWIG_fail;
22322 swig_obj[0] = args;
22323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22324 if (!SWIG_IsOK(res1)) {
22325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22326 }
22327 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22328 {
22329 PyThreadState* __tstate = wxPyBeginAllowThreads();
22330 result = (bool)(arg1)->IsAllowed();
22331 wxPyEndAllowThreads(__tstate);
22332 if (PyErr_Occurred()) SWIG_fail;
22333 }
22334 {
22335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22336 }
22337 return resultobj;
22338 fail:
22339 return NULL;
22340 }
22341
22342
22343 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22344 PyObject *obj;
22345 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22346 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22347 return SWIG_Py_Void();
22348 }
22349
22350 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22351 return SWIG_Python_InitShadowInstance(args);
22352 }
22353
22354 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22355 PyObject *resultobj = 0;
22356 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22357 int arg2 = (int) 0 ;
22358 int arg3 = (int) 0 ;
22359 int arg4 = (int) 0 ;
22360 wxScrollEvent *result = 0 ;
22361 int val1 ;
22362 int ecode1 = 0 ;
22363 int val2 ;
22364 int ecode2 = 0 ;
22365 int val3 ;
22366 int ecode3 = 0 ;
22367 int val4 ;
22368 int ecode4 = 0 ;
22369 PyObject * obj0 = 0 ;
22370 PyObject * obj1 = 0 ;
22371 PyObject * obj2 = 0 ;
22372 PyObject * obj3 = 0 ;
22373 char * kwnames[] = {
22374 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22375 };
22376
22377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22378 if (obj0) {
22379 ecode1 = SWIG_AsVal_int(obj0, &val1);
22380 if (!SWIG_IsOK(ecode1)) {
22381 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22382 }
22383 arg1 = static_cast< wxEventType >(val1);
22384 }
22385 if (obj1) {
22386 ecode2 = SWIG_AsVal_int(obj1, &val2);
22387 if (!SWIG_IsOK(ecode2)) {
22388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22389 }
22390 arg2 = static_cast< int >(val2);
22391 }
22392 if (obj2) {
22393 ecode3 = SWIG_AsVal_int(obj2, &val3);
22394 if (!SWIG_IsOK(ecode3)) {
22395 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22396 }
22397 arg3 = static_cast< int >(val3);
22398 }
22399 if (obj3) {
22400 ecode4 = SWIG_AsVal_int(obj3, &val4);
22401 if (!SWIG_IsOK(ecode4)) {
22402 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22403 }
22404 arg4 = static_cast< int >(val4);
22405 }
22406 {
22407 PyThreadState* __tstate = wxPyBeginAllowThreads();
22408 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22409 wxPyEndAllowThreads(__tstate);
22410 if (PyErr_Occurred()) SWIG_fail;
22411 }
22412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22413 return resultobj;
22414 fail:
22415 return NULL;
22416 }
22417
22418
22419 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22420 PyObject *resultobj = 0;
22421 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22422 int result;
22423 void *argp1 = 0 ;
22424 int res1 = 0 ;
22425 PyObject *swig_obj[1] ;
22426
22427 if (!args) SWIG_fail;
22428 swig_obj[0] = args;
22429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22430 if (!SWIG_IsOK(res1)) {
22431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22432 }
22433 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22434 {
22435 PyThreadState* __tstate = wxPyBeginAllowThreads();
22436 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22437 wxPyEndAllowThreads(__tstate);
22438 if (PyErr_Occurred()) SWIG_fail;
22439 }
22440 resultobj = SWIG_From_int(static_cast< int >(result));
22441 return resultobj;
22442 fail:
22443 return NULL;
22444 }
22445
22446
22447 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22448 PyObject *resultobj = 0;
22449 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22450 int result;
22451 void *argp1 = 0 ;
22452 int res1 = 0 ;
22453 PyObject *swig_obj[1] ;
22454
22455 if (!args) SWIG_fail;
22456 swig_obj[0] = args;
22457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22458 if (!SWIG_IsOK(res1)) {
22459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22460 }
22461 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22462 {
22463 PyThreadState* __tstate = wxPyBeginAllowThreads();
22464 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22465 wxPyEndAllowThreads(__tstate);
22466 if (PyErr_Occurred()) SWIG_fail;
22467 }
22468 resultobj = SWIG_From_int(static_cast< int >(result));
22469 return resultobj;
22470 fail:
22471 return NULL;
22472 }
22473
22474
22475 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22476 PyObject *resultobj = 0;
22477 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22478 int arg2 ;
22479 void *argp1 = 0 ;
22480 int res1 = 0 ;
22481 int val2 ;
22482 int ecode2 = 0 ;
22483 PyObject * obj0 = 0 ;
22484 PyObject * obj1 = 0 ;
22485 char * kwnames[] = {
22486 (char *) "self",(char *) "orient", NULL
22487 };
22488
22489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22491 if (!SWIG_IsOK(res1)) {
22492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22493 }
22494 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22495 ecode2 = SWIG_AsVal_int(obj1, &val2);
22496 if (!SWIG_IsOK(ecode2)) {
22497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22498 }
22499 arg2 = static_cast< int >(val2);
22500 {
22501 PyThreadState* __tstate = wxPyBeginAllowThreads();
22502 (arg1)->SetOrientation(arg2);
22503 wxPyEndAllowThreads(__tstate);
22504 if (PyErr_Occurred()) SWIG_fail;
22505 }
22506 resultobj = SWIG_Py_Void();
22507 return resultobj;
22508 fail:
22509 return NULL;
22510 }
22511
22512
22513 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22514 PyObject *resultobj = 0;
22515 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22516 int arg2 ;
22517 void *argp1 = 0 ;
22518 int res1 = 0 ;
22519 int val2 ;
22520 int ecode2 = 0 ;
22521 PyObject * obj0 = 0 ;
22522 PyObject * obj1 = 0 ;
22523 char * kwnames[] = {
22524 (char *) "self",(char *) "pos", NULL
22525 };
22526
22527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22529 if (!SWIG_IsOK(res1)) {
22530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22531 }
22532 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22533 ecode2 = SWIG_AsVal_int(obj1, &val2);
22534 if (!SWIG_IsOK(ecode2)) {
22535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22536 }
22537 arg2 = static_cast< int >(val2);
22538 {
22539 PyThreadState* __tstate = wxPyBeginAllowThreads();
22540 (arg1)->SetPosition(arg2);
22541 wxPyEndAllowThreads(__tstate);
22542 if (PyErr_Occurred()) SWIG_fail;
22543 }
22544 resultobj = SWIG_Py_Void();
22545 return resultobj;
22546 fail:
22547 return NULL;
22548 }
22549
22550
22551 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22552 PyObject *obj;
22553 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22554 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22555 return SWIG_Py_Void();
22556 }
22557
22558 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22559 return SWIG_Python_InitShadowInstance(args);
22560 }
22561
22562 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22563 PyObject *resultobj = 0;
22564 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22565 int arg2 = (int) 0 ;
22566 int arg3 = (int) 0 ;
22567 wxScrollWinEvent *result = 0 ;
22568 int val1 ;
22569 int ecode1 = 0 ;
22570 int val2 ;
22571 int ecode2 = 0 ;
22572 int val3 ;
22573 int ecode3 = 0 ;
22574 PyObject * obj0 = 0 ;
22575 PyObject * obj1 = 0 ;
22576 PyObject * obj2 = 0 ;
22577 char * kwnames[] = {
22578 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22579 };
22580
22581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22582 if (obj0) {
22583 ecode1 = SWIG_AsVal_int(obj0, &val1);
22584 if (!SWIG_IsOK(ecode1)) {
22585 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22586 }
22587 arg1 = static_cast< wxEventType >(val1);
22588 }
22589 if (obj1) {
22590 ecode2 = SWIG_AsVal_int(obj1, &val2);
22591 if (!SWIG_IsOK(ecode2)) {
22592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22593 }
22594 arg2 = static_cast< int >(val2);
22595 }
22596 if (obj2) {
22597 ecode3 = SWIG_AsVal_int(obj2, &val3);
22598 if (!SWIG_IsOK(ecode3)) {
22599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22600 }
22601 arg3 = static_cast< int >(val3);
22602 }
22603 {
22604 PyThreadState* __tstate = wxPyBeginAllowThreads();
22605 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22606 wxPyEndAllowThreads(__tstate);
22607 if (PyErr_Occurred()) SWIG_fail;
22608 }
22609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22610 return resultobj;
22611 fail:
22612 return NULL;
22613 }
22614
22615
22616 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22617 PyObject *resultobj = 0;
22618 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22619 int result;
22620 void *argp1 = 0 ;
22621 int res1 = 0 ;
22622 PyObject *swig_obj[1] ;
22623
22624 if (!args) SWIG_fail;
22625 swig_obj[0] = args;
22626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22627 if (!SWIG_IsOK(res1)) {
22628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22629 }
22630 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22631 {
22632 PyThreadState* __tstate = wxPyBeginAllowThreads();
22633 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22634 wxPyEndAllowThreads(__tstate);
22635 if (PyErr_Occurred()) SWIG_fail;
22636 }
22637 resultobj = SWIG_From_int(static_cast< int >(result));
22638 return resultobj;
22639 fail:
22640 return NULL;
22641 }
22642
22643
22644 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22645 PyObject *resultobj = 0;
22646 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22647 int result;
22648 void *argp1 = 0 ;
22649 int res1 = 0 ;
22650 PyObject *swig_obj[1] ;
22651
22652 if (!args) SWIG_fail;
22653 swig_obj[0] = args;
22654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22655 if (!SWIG_IsOK(res1)) {
22656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22657 }
22658 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22659 {
22660 PyThreadState* __tstate = wxPyBeginAllowThreads();
22661 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22662 wxPyEndAllowThreads(__tstate);
22663 if (PyErr_Occurred()) SWIG_fail;
22664 }
22665 resultobj = SWIG_From_int(static_cast< int >(result));
22666 return resultobj;
22667 fail:
22668 return NULL;
22669 }
22670
22671
22672 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22673 PyObject *resultobj = 0;
22674 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22675 int arg2 ;
22676 void *argp1 = 0 ;
22677 int res1 = 0 ;
22678 int val2 ;
22679 int ecode2 = 0 ;
22680 PyObject * obj0 = 0 ;
22681 PyObject * obj1 = 0 ;
22682 char * kwnames[] = {
22683 (char *) "self",(char *) "orient", NULL
22684 };
22685
22686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22688 if (!SWIG_IsOK(res1)) {
22689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22690 }
22691 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22692 ecode2 = SWIG_AsVal_int(obj1, &val2);
22693 if (!SWIG_IsOK(ecode2)) {
22694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22695 }
22696 arg2 = static_cast< int >(val2);
22697 {
22698 PyThreadState* __tstate = wxPyBeginAllowThreads();
22699 (arg1)->SetOrientation(arg2);
22700 wxPyEndAllowThreads(__tstate);
22701 if (PyErr_Occurred()) SWIG_fail;
22702 }
22703 resultobj = SWIG_Py_Void();
22704 return resultobj;
22705 fail:
22706 return NULL;
22707 }
22708
22709
22710 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22711 PyObject *resultobj = 0;
22712 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22713 int arg2 ;
22714 void *argp1 = 0 ;
22715 int res1 = 0 ;
22716 int val2 ;
22717 int ecode2 = 0 ;
22718 PyObject * obj0 = 0 ;
22719 PyObject * obj1 = 0 ;
22720 char * kwnames[] = {
22721 (char *) "self",(char *) "pos", NULL
22722 };
22723
22724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22726 if (!SWIG_IsOK(res1)) {
22727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22728 }
22729 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22730 ecode2 = SWIG_AsVal_int(obj1, &val2);
22731 if (!SWIG_IsOK(ecode2)) {
22732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22733 }
22734 arg2 = static_cast< int >(val2);
22735 {
22736 PyThreadState* __tstate = wxPyBeginAllowThreads();
22737 (arg1)->SetPosition(arg2);
22738 wxPyEndAllowThreads(__tstate);
22739 if (PyErr_Occurred()) SWIG_fail;
22740 }
22741 resultobj = SWIG_Py_Void();
22742 return resultobj;
22743 fail:
22744 return NULL;
22745 }
22746
22747
22748 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22749 PyObject *obj;
22750 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22751 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22752 return SWIG_Py_Void();
22753 }
22754
22755 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22756 return SWIG_Python_InitShadowInstance(args);
22757 }
22758
22759 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22760 PyObject *resultobj = 0;
22761 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22762 wxMouseEvent *result = 0 ;
22763 int val1 ;
22764 int ecode1 = 0 ;
22765 PyObject * obj0 = 0 ;
22766 char * kwnames[] = {
22767 (char *) "mouseType", NULL
22768 };
22769
22770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22771 if (obj0) {
22772 ecode1 = SWIG_AsVal_int(obj0, &val1);
22773 if (!SWIG_IsOK(ecode1)) {
22774 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22775 }
22776 arg1 = static_cast< wxEventType >(val1);
22777 }
22778 {
22779 PyThreadState* __tstate = wxPyBeginAllowThreads();
22780 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22781 wxPyEndAllowThreads(__tstate);
22782 if (PyErr_Occurred()) SWIG_fail;
22783 }
22784 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22785 return resultobj;
22786 fail:
22787 return NULL;
22788 }
22789
22790
22791 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22792 PyObject *resultobj = 0;
22793 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22794 bool result;
22795 void *argp1 = 0 ;
22796 int res1 = 0 ;
22797 PyObject *swig_obj[1] ;
22798
22799 if (!args) SWIG_fail;
22800 swig_obj[0] = args;
22801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22802 if (!SWIG_IsOK(res1)) {
22803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22804 }
22805 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22806 {
22807 PyThreadState* __tstate = wxPyBeginAllowThreads();
22808 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22809 wxPyEndAllowThreads(__tstate);
22810 if (PyErr_Occurred()) SWIG_fail;
22811 }
22812 {
22813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22814 }
22815 return resultobj;
22816 fail:
22817 return NULL;
22818 }
22819
22820
22821 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22822 PyObject *resultobj = 0;
22823 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22824 int arg2 = (int) wxMOUSE_BTN_ANY ;
22825 bool result;
22826 void *argp1 = 0 ;
22827 int res1 = 0 ;
22828 int val2 ;
22829 int ecode2 = 0 ;
22830 PyObject * obj0 = 0 ;
22831 PyObject * obj1 = 0 ;
22832 char * kwnames[] = {
22833 (char *) "self",(char *) "but", NULL
22834 };
22835
22836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22838 if (!SWIG_IsOK(res1)) {
22839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22840 }
22841 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22842 if (obj1) {
22843 ecode2 = SWIG_AsVal_int(obj1, &val2);
22844 if (!SWIG_IsOK(ecode2)) {
22845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22846 }
22847 arg2 = static_cast< int >(val2);
22848 }
22849 {
22850 PyThreadState* __tstate = wxPyBeginAllowThreads();
22851 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22852 wxPyEndAllowThreads(__tstate);
22853 if (PyErr_Occurred()) SWIG_fail;
22854 }
22855 {
22856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22857 }
22858 return resultobj;
22859 fail:
22860 return NULL;
22861 }
22862
22863
22864 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22865 PyObject *resultobj = 0;
22866 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22867 int arg2 = (int) wxMOUSE_BTN_ANY ;
22868 bool result;
22869 void *argp1 = 0 ;
22870 int res1 = 0 ;
22871 int val2 ;
22872 int ecode2 = 0 ;
22873 PyObject * obj0 = 0 ;
22874 PyObject * obj1 = 0 ;
22875 char * kwnames[] = {
22876 (char *) "self",(char *) "but", NULL
22877 };
22878
22879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22881 if (!SWIG_IsOK(res1)) {
22882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22883 }
22884 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22885 if (obj1) {
22886 ecode2 = SWIG_AsVal_int(obj1, &val2);
22887 if (!SWIG_IsOK(ecode2)) {
22888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22889 }
22890 arg2 = static_cast< int >(val2);
22891 }
22892 {
22893 PyThreadState* __tstate = wxPyBeginAllowThreads();
22894 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22895 wxPyEndAllowThreads(__tstate);
22896 if (PyErr_Occurred()) SWIG_fail;
22897 }
22898 {
22899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22900 }
22901 return resultobj;
22902 fail:
22903 return NULL;
22904 }
22905
22906
22907 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22908 PyObject *resultobj = 0;
22909 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22910 int arg2 = (int) wxMOUSE_BTN_ANY ;
22911 bool result;
22912 void *argp1 = 0 ;
22913 int res1 = 0 ;
22914 int val2 ;
22915 int ecode2 = 0 ;
22916 PyObject * obj0 = 0 ;
22917 PyObject * obj1 = 0 ;
22918 char * kwnames[] = {
22919 (char *) "self",(char *) "but", NULL
22920 };
22921
22922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22924 if (!SWIG_IsOK(res1)) {
22925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22926 }
22927 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22928 if (obj1) {
22929 ecode2 = SWIG_AsVal_int(obj1, &val2);
22930 if (!SWIG_IsOK(ecode2)) {
22931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22932 }
22933 arg2 = static_cast< int >(val2);
22934 }
22935 {
22936 PyThreadState* __tstate = wxPyBeginAllowThreads();
22937 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22938 wxPyEndAllowThreads(__tstate);
22939 if (PyErr_Occurred()) SWIG_fail;
22940 }
22941 {
22942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22943 }
22944 return resultobj;
22945 fail:
22946 return NULL;
22947 }
22948
22949
22950 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22951 PyObject *resultobj = 0;
22952 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22953 int arg2 ;
22954 bool result;
22955 void *argp1 = 0 ;
22956 int res1 = 0 ;
22957 int val2 ;
22958 int ecode2 = 0 ;
22959 PyObject * obj0 = 0 ;
22960 PyObject * obj1 = 0 ;
22961 char * kwnames[] = {
22962 (char *) "self",(char *) "button", NULL
22963 };
22964
22965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
22966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22967 if (!SWIG_IsOK(res1)) {
22968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22969 }
22970 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22971 ecode2 = SWIG_AsVal_int(obj1, &val2);
22972 if (!SWIG_IsOK(ecode2)) {
22973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
22974 }
22975 arg2 = static_cast< int >(val2);
22976 {
22977 PyThreadState* __tstate = wxPyBeginAllowThreads();
22978 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
22979 wxPyEndAllowThreads(__tstate);
22980 if (PyErr_Occurred()) SWIG_fail;
22981 }
22982 {
22983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22984 }
22985 return resultobj;
22986 fail:
22987 return NULL;
22988 }
22989
22990
22991 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22992 PyObject *resultobj = 0;
22993 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22994 int arg2 ;
22995 bool result;
22996 void *argp1 = 0 ;
22997 int res1 = 0 ;
22998 int val2 ;
22999 int ecode2 = 0 ;
23000 PyObject * obj0 = 0 ;
23001 PyObject * obj1 = 0 ;
23002 char * kwnames[] = {
23003 (char *) "self",(char *) "but", NULL
23004 };
23005
23006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
23007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23008 if (!SWIG_IsOK(res1)) {
23009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23010 }
23011 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23012 ecode2 = SWIG_AsVal_int(obj1, &val2);
23013 if (!SWIG_IsOK(ecode2)) {
23014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
23015 }
23016 arg2 = static_cast< int >(val2);
23017 {
23018 PyThreadState* __tstate = wxPyBeginAllowThreads();
23019 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
23020 wxPyEndAllowThreads(__tstate);
23021 if (PyErr_Occurred()) SWIG_fail;
23022 }
23023 {
23024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23025 }
23026 return resultobj;
23027 fail:
23028 return NULL;
23029 }
23030
23031
23032 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23033 PyObject *resultobj = 0;
23034 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23035 int result;
23036 void *argp1 = 0 ;
23037 int res1 = 0 ;
23038 PyObject *swig_obj[1] ;
23039
23040 if (!args) SWIG_fail;
23041 swig_obj[0] = args;
23042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23043 if (!SWIG_IsOK(res1)) {
23044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23045 }
23046 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23047 {
23048 PyThreadState* __tstate = wxPyBeginAllowThreads();
23049 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23050 wxPyEndAllowThreads(__tstate);
23051 if (PyErr_Occurred()) SWIG_fail;
23052 }
23053 resultobj = SWIG_From_int(static_cast< int >(result));
23054 return resultobj;
23055 fail:
23056 return NULL;
23057 }
23058
23059
23060 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23061 PyObject *resultobj = 0;
23062 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23063 bool result;
23064 void *argp1 = 0 ;
23065 int res1 = 0 ;
23066 PyObject *swig_obj[1] ;
23067
23068 if (!args) SWIG_fail;
23069 swig_obj[0] = args;
23070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23071 if (!SWIG_IsOK(res1)) {
23072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23073 }
23074 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23075 {
23076 PyThreadState* __tstate = wxPyBeginAllowThreads();
23077 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23078 wxPyEndAllowThreads(__tstate);
23079 if (PyErr_Occurred()) SWIG_fail;
23080 }
23081 {
23082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23083 }
23084 return resultobj;
23085 fail:
23086 return NULL;
23087 }
23088
23089
23090 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23091 PyObject *resultobj = 0;
23092 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23093 bool result;
23094 void *argp1 = 0 ;
23095 int res1 = 0 ;
23096 PyObject *swig_obj[1] ;
23097
23098 if (!args) SWIG_fail;
23099 swig_obj[0] = args;
23100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23101 if (!SWIG_IsOK(res1)) {
23102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23103 }
23104 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23105 {
23106 PyThreadState* __tstate = wxPyBeginAllowThreads();
23107 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23108 wxPyEndAllowThreads(__tstate);
23109 if (PyErr_Occurred()) SWIG_fail;
23110 }
23111 {
23112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23113 }
23114 return resultobj;
23115 fail:
23116 return NULL;
23117 }
23118
23119
23120 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23121 PyObject *resultobj = 0;
23122 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23123 bool result;
23124 void *argp1 = 0 ;
23125 int res1 = 0 ;
23126 PyObject *swig_obj[1] ;
23127
23128 if (!args) SWIG_fail;
23129 swig_obj[0] = args;
23130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23131 if (!SWIG_IsOK(res1)) {
23132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23133 }
23134 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23135 {
23136 PyThreadState* __tstate = wxPyBeginAllowThreads();
23137 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23138 wxPyEndAllowThreads(__tstate);
23139 if (PyErr_Occurred()) SWIG_fail;
23140 }
23141 {
23142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23143 }
23144 return resultobj;
23145 fail:
23146 return NULL;
23147 }
23148
23149
23150 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23151 PyObject *resultobj = 0;
23152 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23153 bool result;
23154 void *argp1 = 0 ;
23155 int res1 = 0 ;
23156 PyObject *swig_obj[1] ;
23157
23158 if (!args) SWIG_fail;
23159 swig_obj[0] = args;
23160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23161 if (!SWIG_IsOK(res1)) {
23162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23163 }
23164 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23165 {
23166 PyThreadState* __tstate = wxPyBeginAllowThreads();
23167 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23168 wxPyEndAllowThreads(__tstate);
23169 if (PyErr_Occurred()) SWIG_fail;
23170 }
23171 {
23172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23173 }
23174 return resultobj;
23175 fail:
23176 return NULL;
23177 }
23178
23179
23180 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23181 PyObject *resultobj = 0;
23182 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23183 bool result;
23184 void *argp1 = 0 ;
23185 int res1 = 0 ;
23186 PyObject *swig_obj[1] ;
23187
23188 if (!args) SWIG_fail;
23189 swig_obj[0] = args;
23190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23191 if (!SWIG_IsOK(res1)) {
23192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23193 }
23194 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23195 {
23196 PyThreadState* __tstate = wxPyBeginAllowThreads();
23197 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23198 wxPyEndAllowThreads(__tstate);
23199 if (PyErr_Occurred()) SWIG_fail;
23200 }
23201 {
23202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23203 }
23204 return resultobj;
23205 fail:
23206 return NULL;
23207 }
23208
23209
23210 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23211 PyObject *resultobj = 0;
23212 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23213 bool result;
23214 void *argp1 = 0 ;
23215 int res1 = 0 ;
23216 PyObject *swig_obj[1] ;
23217
23218 if (!args) SWIG_fail;
23219 swig_obj[0] = args;
23220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23221 if (!SWIG_IsOK(res1)) {
23222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23223 }
23224 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23225 {
23226 PyThreadState* __tstate = wxPyBeginAllowThreads();
23227 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23228 wxPyEndAllowThreads(__tstate);
23229 if (PyErr_Occurred()) SWIG_fail;
23230 }
23231 {
23232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23233 }
23234 return resultobj;
23235 fail:
23236 return NULL;
23237 }
23238
23239
23240 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23241 PyObject *resultobj = 0;
23242 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23243 bool result;
23244 void *argp1 = 0 ;
23245 int res1 = 0 ;
23246 PyObject *swig_obj[1] ;
23247
23248 if (!args) SWIG_fail;
23249 swig_obj[0] = args;
23250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23251 if (!SWIG_IsOK(res1)) {
23252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23253 }
23254 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23255 {
23256 PyThreadState* __tstate = wxPyBeginAllowThreads();
23257 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23258 wxPyEndAllowThreads(__tstate);
23259 if (PyErr_Occurred()) SWIG_fail;
23260 }
23261 {
23262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23263 }
23264 return resultobj;
23265 fail:
23266 return NULL;
23267 }
23268
23269
23270 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23271 PyObject *resultobj = 0;
23272 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23273 bool result;
23274 void *argp1 = 0 ;
23275 int res1 = 0 ;
23276 PyObject *swig_obj[1] ;
23277
23278 if (!args) SWIG_fail;
23279 swig_obj[0] = args;
23280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23281 if (!SWIG_IsOK(res1)) {
23282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23283 }
23284 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23285 {
23286 PyThreadState* __tstate = wxPyBeginAllowThreads();
23287 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23288 wxPyEndAllowThreads(__tstate);
23289 if (PyErr_Occurred()) SWIG_fail;
23290 }
23291 {
23292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23293 }
23294 return resultobj;
23295 fail:
23296 return NULL;
23297 }
23298
23299
23300 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23301 PyObject *resultobj = 0;
23302 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23303 bool result;
23304 void *argp1 = 0 ;
23305 int res1 = 0 ;
23306 PyObject *swig_obj[1] ;
23307
23308 if (!args) SWIG_fail;
23309 swig_obj[0] = args;
23310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23311 if (!SWIG_IsOK(res1)) {
23312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23313 }
23314 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23315 {
23316 PyThreadState* __tstate = wxPyBeginAllowThreads();
23317 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23318 wxPyEndAllowThreads(__tstate);
23319 if (PyErr_Occurred()) SWIG_fail;
23320 }
23321 {
23322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23323 }
23324 return resultobj;
23325 fail:
23326 return NULL;
23327 }
23328
23329
23330 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23331 PyObject *resultobj = 0;
23332 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23333 bool result;
23334 void *argp1 = 0 ;
23335 int res1 = 0 ;
23336 PyObject *swig_obj[1] ;
23337
23338 if (!args) SWIG_fail;
23339 swig_obj[0] = args;
23340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23341 if (!SWIG_IsOK(res1)) {
23342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23343 }
23344 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23345 {
23346 PyThreadState* __tstate = wxPyBeginAllowThreads();
23347 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23348 wxPyEndAllowThreads(__tstate);
23349 if (PyErr_Occurred()) SWIG_fail;
23350 }
23351 {
23352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23353 }
23354 return resultobj;
23355 fail:
23356 return NULL;
23357 }
23358
23359
23360 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23361 PyObject *resultobj = 0;
23362 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23363 bool result;
23364 void *argp1 = 0 ;
23365 int res1 = 0 ;
23366 PyObject *swig_obj[1] ;
23367
23368 if (!args) SWIG_fail;
23369 swig_obj[0] = args;
23370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23371 if (!SWIG_IsOK(res1)) {
23372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23373 }
23374 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23375 {
23376 PyThreadState* __tstate = wxPyBeginAllowThreads();
23377 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23378 wxPyEndAllowThreads(__tstate);
23379 if (PyErr_Occurred()) SWIG_fail;
23380 }
23381 {
23382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23383 }
23384 return resultobj;
23385 fail:
23386 return NULL;
23387 }
23388
23389
23390 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23391 PyObject *resultobj = 0;
23392 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23393 bool result;
23394 void *argp1 = 0 ;
23395 int res1 = 0 ;
23396 PyObject *swig_obj[1] ;
23397
23398 if (!args) SWIG_fail;
23399 swig_obj[0] = args;
23400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23401 if (!SWIG_IsOK(res1)) {
23402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23403 }
23404 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23405 {
23406 PyThreadState* __tstate = wxPyBeginAllowThreads();
23407 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23408 wxPyEndAllowThreads(__tstate);
23409 if (PyErr_Occurred()) SWIG_fail;
23410 }
23411 {
23412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23413 }
23414 return resultobj;
23415 fail:
23416 return NULL;
23417 }
23418
23419
23420 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23421 PyObject *resultobj = 0;
23422 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23423 bool result;
23424 void *argp1 = 0 ;
23425 int res1 = 0 ;
23426 PyObject *swig_obj[1] ;
23427
23428 if (!args) SWIG_fail;
23429 swig_obj[0] = args;
23430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23431 if (!SWIG_IsOK(res1)) {
23432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23433 }
23434 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23435 {
23436 PyThreadState* __tstate = wxPyBeginAllowThreads();
23437 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23438 wxPyEndAllowThreads(__tstate);
23439 if (PyErr_Occurred()) SWIG_fail;
23440 }
23441 {
23442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23443 }
23444 return resultobj;
23445 fail:
23446 return NULL;
23447 }
23448
23449
23450 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23451 PyObject *resultobj = 0;
23452 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23453 bool result;
23454 void *argp1 = 0 ;
23455 int res1 = 0 ;
23456 PyObject *swig_obj[1] ;
23457
23458 if (!args) SWIG_fail;
23459 swig_obj[0] = args;
23460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23461 if (!SWIG_IsOK(res1)) {
23462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23463 }
23464 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23465 {
23466 PyThreadState* __tstate = wxPyBeginAllowThreads();
23467 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23468 wxPyEndAllowThreads(__tstate);
23469 if (PyErr_Occurred()) SWIG_fail;
23470 }
23471 {
23472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23473 }
23474 return resultobj;
23475 fail:
23476 return NULL;
23477 }
23478
23479
23480 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23481 PyObject *resultobj = 0;
23482 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23483 bool result;
23484 void *argp1 = 0 ;
23485 int res1 = 0 ;
23486 PyObject *swig_obj[1] ;
23487
23488 if (!args) SWIG_fail;
23489 swig_obj[0] = args;
23490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23491 if (!SWIG_IsOK(res1)) {
23492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23493 }
23494 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23495 {
23496 PyThreadState* __tstate = wxPyBeginAllowThreads();
23497 result = (bool)(arg1)->LeftIsDown();
23498 wxPyEndAllowThreads(__tstate);
23499 if (PyErr_Occurred()) SWIG_fail;
23500 }
23501 {
23502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23503 }
23504 return resultobj;
23505 fail:
23506 return NULL;
23507 }
23508
23509
23510 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23511 PyObject *resultobj = 0;
23512 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23513 bool result;
23514 void *argp1 = 0 ;
23515 int res1 = 0 ;
23516 PyObject *swig_obj[1] ;
23517
23518 if (!args) SWIG_fail;
23519 swig_obj[0] = args;
23520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23521 if (!SWIG_IsOK(res1)) {
23522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23523 }
23524 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23525 {
23526 PyThreadState* __tstate = wxPyBeginAllowThreads();
23527 result = (bool)(arg1)->MiddleIsDown();
23528 wxPyEndAllowThreads(__tstate);
23529 if (PyErr_Occurred()) SWIG_fail;
23530 }
23531 {
23532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23533 }
23534 return resultobj;
23535 fail:
23536 return NULL;
23537 }
23538
23539
23540 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23541 PyObject *resultobj = 0;
23542 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23543 bool result;
23544 void *argp1 = 0 ;
23545 int res1 = 0 ;
23546 PyObject *swig_obj[1] ;
23547
23548 if (!args) SWIG_fail;
23549 swig_obj[0] = args;
23550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23551 if (!SWIG_IsOK(res1)) {
23552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23553 }
23554 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23555 {
23556 PyThreadState* __tstate = wxPyBeginAllowThreads();
23557 result = (bool)(arg1)->RightIsDown();
23558 wxPyEndAllowThreads(__tstate);
23559 if (PyErr_Occurred()) SWIG_fail;
23560 }
23561 {
23562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23563 }
23564 return resultobj;
23565 fail:
23566 return NULL;
23567 }
23568
23569
23570 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23571 PyObject *resultobj = 0;
23572 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23573 bool result;
23574 void *argp1 = 0 ;
23575 int res1 = 0 ;
23576 PyObject *swig_obj[1] ;
23577
23578 if (!args) SWIG_fail;
23579 swig_obj[0] = args;
23580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23581 if (!SWIG_IsOK(res1)) {
23582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23583 }
23584 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23585 {
23586 PyThreadState* __tstate = wxPyBeginAllowThreads();
23587 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23588 wxPyEndAllowThreads(__tstate);
23589 if (PyErr_Occurred()) SWIG_fail;
23590 }
23591 {
23592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23593 }
23594 return resultobj;
23595 fail:
23596 return NULL;
23597 }
23598
23599
23600 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23601 PyObject *resultobj = 0;
23602 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23603 bool result;
23604 void *argp1 = 0 ;
23605 int res1 = 0 ;
23606 PyObject *swig_obj[1] ;
23607
23608 if (!args) SWIG_fail;
23609 swig_obj[0] = args;
23610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23611 if (!SWIG_IsOK(res1)) {
23612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23613 }
23614 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23615 {
23616 PyThreadState* __tstate = wxPyBeginAllowThreads();
23617 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23618 wxPyEndAllowThreads(__tstate);
23619 if (PyErr_Occurred()) SWIG_fail;
23620 }
23621 {
23622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23623 }
23624 return resultobj;
23625 fail:
23626 return NULL;
23627 }
23628
23629
23630 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23631 PyObject *resultobj = 0;
23632 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23633 bool result;
23634 void *argp1 = 0 ;
23635 int res1 = 0 ;
23636 PyObject *swig_obj[1] ;
23637
23638 if (!args) SWIG_fail;
23639 swig_obj[0] = args;
23640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23641 if (!SWIG_IsOK(res1)) {
23642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23643 }
23644 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23645 {
23646 PyThreadState* __tstate = wxPyBeginAllowThreads();
23647 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23648 wxPyEndAllowThreads(__tstate);
23649 if (PyErr_Occurred()) SWIG_fail;
23650 }
23651 {
23652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23653 }
23654 return resultobj;
23655 fail:
23656 return NULL;
23657 }
23658
23659
23660 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23661 PyObject *resultobj = 0;
23662 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23663 bool result;
23664 void *argp1 = 0 ;
23665 int res1 = 0 ;
23666 PyObject *swig_obj[1] ;
23667
23668 if (!args) SWIG_fail;
23669 swig_obj[0] = args;
23670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23671 if (!SWIG_IsOK(res1)) {
23672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23673 }
23674 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23675 {
23676 PyThreadState* __tstate = wxPyBeginAllowThreads();
23677 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23678 wxPyEndAllowThreads(__tstate);
23679 if (PyErr_Occurred()) SWIG_fail;
23680 }
23681 {
23682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23683 }
23684 return resultobj;
23685 fail:
23686 return NULL;
23687 }
23688
23689
23690 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23691 PyObject *resultobj = 0;
23692 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23693 wxPoint result;
23694 void *argp1 = 0 ;
23695 int res1 = 0 ;
23696 PyObject *swig_obj[1] ;
23697
23698 if (!args) SWIG_fail;
23699 swig_obj[0] = args;
23700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23701 if (!SWIG_IsOK(res1)) {
23702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23703 }
23704 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23705 {
23706 PyThreadState* __tstate = wxPyBeginAllowThreads();
23707 result = (arg1)->GetPosition();
23708 wxPyEndAllowThreads(__tstate);
23709 if (PyErr_Occurred()) SWIG_fail;
23710 }
23711 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23712 return resultobj;
23713 fail:
23714 return NULL;
23715 }
23716
23717
23718 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23719 PyObject *resultobj = 0;
23720 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23721 long *arg2 = (long *) 0 ;
23722 long *arg3 = (long *) 0 ;
23723 void *argp1 = 0 ;
23724 int res1 = 0 ;
23725 long temp2 ;
23726 int res2 = SWIG_TMPOBJ ;
23727 long temp3 ;
23728 int res3 = SWIG_TMPOBJ ;
23729 PyObject *swig_obj[1] ;
23730
23731 arg2 = &temp2;
23732 arg3 = &temp3;
23733 if (!args) SWIG_fail;
23734 swig_obj[0] = args;
23735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23736 if (!SWIG_IsOK(res1)) {
23737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23738 }
23739 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23740 {
23741 PyThreadState* __tstate = wxPyBeginAllowThreads();
23742 (arg1)->GetPosition(arg2,arg3);
23743 wxPyEndAllowThreads(__tstate);
23744 if (PyErr_Occurred()) SWIG_fail;
23745 }
23746 resultobj = SWIG_Py_Void();
23747 if (SWIG_IsTmpObj(res2)) {
23748 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23749 } else {
23750 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23751 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23752 }
23753 if (SWIG_IsTmpObj(res3)) {
23754 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23755 } else {
23756 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23757 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23758 }
23759 return resultobj;
23760 fail:
23761 return NULL;
23762 }
23763
23764
23765 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23766 PyObject *resultobj = 0;
23767 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23768 wxDC *arg2 = 0 ;
23769 wxPoint result;
23770 void *argp1 = 0 ;
23771 int res1 = 0 ;
23772 void *argp2 = 0 ;
23773 int res2 = 0 ;
23774 PyObject * obj0 = 0 ;
23775 PyObject * obj1 = 0 ;
23776 char * kwnames[] = {
23777 (char *) "self",(char *) "dc", NULL
23778 };
23779
23780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23782 if (!SWIG_IsOK(res1)) {
23783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23784 }
23785 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23786 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23787 if (!SWIG_IsOK(res2)) {
23788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23789 }
23790 if (!argp2) {
23791 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23792 }
23793 arg2 = reinterpret_cast< wxDC * >(argp2);
23794 {
23795 PyThreadState* __tstate = wxPyBeginAllowThreads();
23796 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23797 wxPyEndAllowThreads(__tstate);
23798 if (PyErr_Occurred()) SWIG_fail;
23799 }
23800 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23801 return resultobj;
23802 fail:
23803 return NULL;
23804 }
23805
23806
23807 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23808 PyObject *resultobj = 0;
23809 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23810 int result;
23811 void *argp1 = 0 ;
23812 int res1 = 0 ;
23813 PyObject *swig_obj[1] ;
23814
23815 if (!args) SWIG_fail;
23816 swig_obj[0] = args;
23817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23818 if (!SWIG_IsOK(res1)) {
23819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23820 }
23821 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23822 {
23823 PyThreadState* __tstate = wxPyBeginAllowThreads();
23824 result = (int)((wxMouseEvent const *)arg1)->GetX();
23825 wxPyEndAllowThreads(__tstate);
23826 if (PyErr_Occurred()) SWIG_fail;
23827 }
23828 resultobj = SWIG_From_int(static_cast< int >(result));
23829 return resultobj;
23830 fail:
23831 return NULL;
23832 }
23833
23834
23835 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23836 PyObject *resultobj = 0;
23837 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23838 int result;
23839 void *argp1 = 0 ;
23840 int res1 = 0 ;
23841 PyObject *swig_obj[1] ;
23842
23843 if (!args) SWIG_fail;
23844 swig_obj[0] = args;
23845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23846 if (!SWIG_IsOK(res1)) {
23847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23848 }
23849 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23850 {
23851 PyThreadState* __tstate = wxPyBeginAllowThreads();
23852 result = (int)((wxMouseEvent const *)arg1)->GetY();
23853 wxPyEndAllowThreads(__tstate);
23854 if (PyErr_Occurred()) SWIG_fail;
23855 }
23856 resultobj = SWIG_From_int(static_cast< int >(result));
23857 return resultobj;
23858 fail:
23859 return NULL;
23860 }
23861
23862
23863 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23864 PyObject *resultobj = 0;
23865 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23866 int result;
23867 void *argp1 = 0 ;
23868 int res1 = 0 ;
23869 PyObject *swig_obj[1] ;
23870
23871 if (!args) SWIG_fail;
23872 swig_obj[0] = args;
23873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23874 if (!SWIG_IsOK(res1)) {
23875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23876 }
23877 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23878 {
23879 PyThreadState* __tstate = wxPyBeginAllowThreads();
23880 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23881 wxPyEndAllowThreads(__tstate);
23882 if (PyErr_Occurred()) SWIG_fail;
23883 }
23884 resultobj = SWIG_From_int(static_cast< int >(result));
23885 return resultobj;
23886 fail:
23887 return NULL;
23888 }
23889
23890
23891 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23892 PyObject *resultobj = 0;
23893 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23894 int result;
23895 void *argp1 = 0 ;
23896 int res1 = 0 ;
23897 PyObject *swig_obj[1] ;
23898
23899 if (!args) SWIG_fail;
23900 swig_obj[0] = args;
23901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23902 if (!SWIG_IsOK(res1)) {
23903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23904 }
23905 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23906 {
23907 PyThreadState* __tstate = wxPyBeginAllowThreads();
23908 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23909 wxPyEndAllowThreads(__tstate);
23910 if (PyErr_Occurred()) SWIG_fail;
23911 }
23912 resultobj = SWIG_From_int(static_cast< int >(result));
23913 return resultobj;
23914 fail:
23915 return NULL;
23916 }
23917
23918
23919 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23920 PyObject *resultobj = 0;
23921 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23922 int result;
23923 void *argp1 = 0 ;
23924 int res1 = 0 ;
23925 PyObject *swig_obj[1] ;
23926
23927 if (!args) SWIG_fail;
23928 swig_obj[0] = args;
23929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23930 if (!SWIG_IsOK(res1)) {
23931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23932 }
23933 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23934 {
23935 PyThreadState* __tstate = wxPyBeginAllowThreads();
23936 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
23937 wxPyEndAllowThreads(__tstate);
23938 if (PyErr_Occurred()) SWIG_fail;
23939 }
23940 resultobj = SWIG_From_int(static_cast< int >(result));
23941 return resultobj;
23942 fail:
23943 return NULL;
23944 }
23945
23946
23947 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23948 PyObject *resultobj = 0;
23949 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23950 bool result;
23951 void *argp1 = 0 ;
23952 int res1 = 0 ;
23953 PyObject *swig_obj[1] ;
23954
23955 if (!args) SWIG_fail;
23956 swig_obj[0] = args;
23957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23958 if (!SWIG_IsOK(res1)) {
23959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23960 }
23961 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23962 {
23963 PyThreadState* __tstate = wxPyBeginAllowThreads();
23964 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
23965 wxPyEndAllowThreads(__tstate);
23966 if (PyErr_Occurred()) SWIG_fail;
23967 }
23968 {
23969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23970 }
23971 return resultobj;
23972 fail:
23973 return NULL;
23974 }
23975
23976
23977 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23978 PyObject *resultobj = 0;
23979 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23980 int arg2 ;
23981 void *argp1 = 0 ;
23982 int res1 = 0 ;
23983 int val2 ;
23984 int ecode2 = 0 ;
23985 PyObject *swig_obj[2] ;
23986
23987 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23989 if (!SWIG_IsOK(res1)) {
23990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23991 }
23992 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23993 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23994 if (!SWIG_IsOK(ecode2)) {
23995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23996 }
23997 arg2 = static_cast< int >(val2);
23998 if (arg1) (arg1)->m_x = arg2;
23999
24000 resultobj = SWIG_Py_Void();
24001 return resultobj;
24002 fail:
24003 return NULL;
24004 }
24005
24006
24007 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24008 PyObject *resultobj = 0;
24009 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24010 int result;
24011 void *argp1 = 0 ;
24012 int res1 = 0 ;
24013 PyObject *swig_obj[1] ;
24014
24015 if (!args) SWIG_fail;
24016 swig_obj[0] = args;
24017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24018 if (!SWIG_IsOK(res1)) {
24019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24020 }
24021 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24022 result = (int) ((arg1)->m_x);
24023 resultobj = SWIG_From_int(static_cast< int >(result));
24024 return resultobj;
24025 fail:
24026 return NULL;
24027 }
24028
24029
24030 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24031 PyObject *resultobj = 0;
24032 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24033 int arg2 ;
24034 void *argp1 = 0 ;
24035 int res1 = 0 ;
24036 int val2 ;
24037 int ecode2 = 0 ;
24038 PyObject *swig_obj[2] ;
24039
24040 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24042 if (!SWIG_IsOK(res1)) {
24043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24044 }
24045 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24046 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24047 if (!SWIG_IsOK(ecode2)) {
24048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24049 }
24050 arg2 = static_cast< int >(val2);
24051 if (arg1) (arg1)->m_y = arg2;
24052
24053 resultobj = SWIG_Py_Void();
24054 return resultobj;
24055 fail:
24056 return NULL;
24057 }
24058
24059
24060 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24061 PyObject *resultobj = 0;
24062 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24063 int result;
24064 void *argp1 = 0 ;
24065 int res1 = 0 ;
24066 PyObject *swig_obj[1] ;
24067
24068 if (!args) SWIG_fail;
24069 swig_obj[0] = args;
24070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24071 if (!SWIG_IsOK(res1)) {
24072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24073 }
24074 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24075 result = (int) ((arg1)->m_y);
24076 resultobj = SWIG_From_int(static_cast< int >(result));
24077 return resultobj;
24078 fail:
24079 return NULL;
24080 }
24081
24082
24083 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24084 PyObject *resultobj = 0;
24085 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24086 bool arg2 ;
24087 void *argp1 = 0 ;
24088 int res1 = 0 ;
24089 bool val2 ;
24090 int ecode2 = 0 ;
24091 PyObject *swig_obj[2] ;
24092
24093 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24095 if (!SWIG_IsOK(res1)) {
24096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24097 }
24098 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24099 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24100 if (!SWIG_IsOK(ecode2)) {
24101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24102 }
24103 arg2 = static_cast< bool >(val2);
24104 if (arg1) (arg1)->m_leftDown = arg2;
24105
24106 resultobj = SWIG_Py_Void();
24107 return resultobj;
24108 fail:
24109 return NULL;
24110 }
24111
24112
24113 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24114 PyObject *resultobj = 0;
24115 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24116 bool result;
24117 void *argp1 = 0 ;
24118 int res1 = 0 ;
24119 PyObject *swig_obj[1] ;
24120
24121 if (!args) SWIG_fail;
24122 swig_obj[0] = args;
24123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24124 if (!SWIG_IsOK(res1)) {
24125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24126 }
24127 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24128 result = (bool) ((arg1)->m_leftDown);
24129 {
24130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24131 }
24132 return resultobj;
24133 fail:
24134 return NULL;
24135 }
24136
24137
24138 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24139 PyObject *resultobj = 0;
24140 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24141 bool arg2 ;
24142 void *argp1 = 0 ;
24143 int res1 = 0 ;
24144 bool val2 ;
24145 int ecode2 = 0 ;
24146 PyObject *swig_obj[2] ;
24147
24148 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24150 if (!SWIG_IsOK(res1)) {
24151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24152 }
24153 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24154 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24155 if (!SWIG_IsOK(ecode2)) {
24156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24157 }
24158 arg2 = static_cast< bool >(val2);
24159 if (arg1) (arg1)->m_middleDown = arg2;
24160
24161 resultobj = SWIG_Py_Void();
24162 return resultobj;
24163 fail:
24164 return NULL;
24165 }
24166
24167
24168 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24169 PyObject *resultobj = 0;
24170 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24171 bool result;
24172 void *argp1 = 0 ;
24173 int res1 = 0 ;
24174 PyObject *swig_obj[1] ;
24175
24176 if (!args) SWIG_fail;
24177 swig_obj[0] = args;
24178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24179 if (!SWIG_IsOK(res1)) {
24180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24181 }
24182 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24183 result = (bool) ((arg1)->m_middleDown);
24184 {
24185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24186 }
24187 return resultobj;
24188 fail:
24189 return NULL;
24190 }
24191
24192
24193 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24194 PyObject *resultobj = 0;
24195 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24196 bool arg2 ;
24197 void *argp1 = 0 ;
24198 int res1 = 0 ;
24199 bool val2 ;
24200 int ecode2 = 0 ;
24201 PyObject *swig_obj[2] ;
24202
24203 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24205 if (!SWIG_IsOK(res1)) {
24206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24207 }
24208 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24209 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24210 if (!SWIG_IsOK(ecode2)) {
24211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24212 }
24213 arg2 = static_cast< bool >(val2);
24214 if (arg1) (arg1)->m_rightDown = arg2;
24215
24216 resultobj = SWIG_Py_Void();
24217 return resultobj;
24218 fail:
24219 return NULL;
24220 }
24221
24222
24223 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24224 PyObject *resultobj = 0;
24225 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24226 bool result;
24227 void *argp1 = 0 ;
24228 int res1 = 0 ;
24229 PyObject *swig_obj[1] ;
24230
24231 if (!args) SWIG_fail;
24232 swig_obj[0] = args;
24233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24234 if (!SWIG_IsOK(res1)) {
24235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24236 }
24237 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24238 result = (bool) ((arg1)->m_rightDown);
24239 {
24240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24241 }
24242 return resultobj;
24243 fail:
24244 return NULL;
24245 }
24246
24247
24248 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24249 PyObject *resultobj = 0;
24250 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24251 bool arg2 ;
24252 void *argp1 = 0 ;
24253 int res1 = 0 ;
24254 bool val2 ;
24255 int ecode2 = 0 ;
24256 PyObject *swig_obj[2] ;
24257
24258 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24260 if (!SWIG_IsOK(res1)) {
24261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24262 }
24263 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24264 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24265 if (!SWIG_IsOK(ecode2)) {
24266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24267 }
24268 arg2 = static_cast< bool >(val2);
24269 if (arg1) (arg1)->m_controlDown = arg2;
24270
24271 resultobj = SWIG_Py_Void();
24272 return resultobj;
24273 fail:
24274 return NULL;
24275 }
24276
24277
24278 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24279 PyObject *resultobj = 0;
24280 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24281 bool result;
24282 void *argp1 = 0 ;
24283 int res1 = 0 ;
24284 PyObject *swig_obj[1] ;
24285
24286 if (!args) SWIG_fail;
24287 swig_obj[0] = args;
24288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24289 if (!SWIG_IsOK(res1)) {
24290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24291 }
24292 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24293 result = (bool) ((arg1)->m_controlDown);
24294 {
24295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24296 }
24297 return resultobj;
24298 fail:
24299 return NULL;
24300 }
24301
24302
24303 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24304 PyObject *resultobj = 0;
24305 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24306 bool arg2 ;
24307 void *argp1 = 0 ;
24308 int res1 = 0 ;
24309 bool val2 ;
24310 int ecode2 = 0 ;
24311 PyObject *swig_obj[2] ;
24312
24313 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24315 if (!SWIG_IsOK(res1)) {
24316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24317 }
24318 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24319 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24320 if (!SWIG_IsOK(ecode2)) {
24321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24322 }
24323 arg2 = static_cast< bool >(val2);
24324 if (arg1) (arg1)->m_shiftDown = arg2;
24325
24326 resultobj = SWIG_Py_Void();
24327 return resultobj;
24328 fail:
24329 return NULL;
24330 }
24331
24332
24333 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24334 PyObject *resultobj = 0;
24335 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24336 bool result;
24337 void *argp1 = 0 ;
24338 int res1 = 0 ;
24339 PyObject *swig_obj[1] ;
24340
24341 if (!args) SWIG_fail;
24342 swig_obj[0] = args;
24343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24344 if (!SWIG_IsOK(res1)) {
24345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24346 }
24347 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24348 result = (bool) ((arg1)->m_shiftDown);
24349 {
24350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24351 }
24352 return resultobj;
24353 fail:
24354 return NULL;
24355 }
24356
24357
24358 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24359 PyObject *resultobj = 0;
24360 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24361 bool arg2 ;
24362 void *argp1 = 0 ;
24363 int res1 = 0 ;
24364 bool val2 ;
24365 int ecode2 = 0 ;
24366 PyObject *swig_obj[2] ;
24367
24368 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24370 if (!SWIG_IsOK(res1)) {
24371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24372 }
24373 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24374 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24375 if (!SWIG_IsOK(ecode2)) {
24376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24377 }
24378 arg2 = static_cast< bool >(val2);
24379 if (arg1) (arg1)->m_altDown = arg2;
24380
24381 resultobj = SWIG_Py_Void();
24382 return resultobj;
24383 fail:
24384 return NULL;
24385 }
24386
24387
24388 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24389 PyObject *resultobj = 0;
24390 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24391 bool result;
24392 void *argp1 = 0 ;
24393 int res1 = 0 ;
24394 PyObject *swig_obj[1] ;
24395
24396 if (!args) SWIG_fail;
24397 swig_obj[0] = args;
24398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24399 if (!SWIG_IsOK(res1)) {
24400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24401 }
24402 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24403 result = (bool) ((arg1)->m_altDown);
24404 {
24405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24406 }
24407 return resultobj;
24408 fail:
24409 return NULL;
24410 }
24411
24412
24413 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24414 PyObject *resultobj = 0;
24415 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24416 bool arg2 ;
24417 void *argp1 = 0 ;
24418 int res1 = 0 ;
24419 bool val2 ;
24420 int ecode2 = 0 ;
24421 PyObject *swig_obj[2] ;
24422
24423 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24425 if (!SWIG_IsOK(res1)) {
24426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24427 }
24428 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24429 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24430 if (!SWIG_IsOK(ecode2)) {
24431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24432 }
24433 arg2 = static_cast< bool >(val2);
24434 if (arg1) (arg1)->m_metaDown = arg2;
24435
24436 resultobj = SWIG_Py_Void();
24437 return resultobj;
24438 fail:
24439 return NULL;
24440 }
24441
24442
24443 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24444 PyObject *resultobj = 0;
24445 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24446 bool result;
24447 void *argp1 = 0 ;
24448 int res1 = 0 ;
24449 PyObject *swig_obj[1] ;
24450
24451 if (!args) SWIG_fail;
24452 swig_obj[0] = args;
24453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24454 if (!SWIG_IsOK(res1)) {
24455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24456 }
24457 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24458 result = (bool) ((arg1)->m_metaDown);
24459 {
24460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24461 }
24462 return resultobj;
24463 fail:
24464 return NULL;
24465 }
24466
24467
24468 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24469 PyObject *resultobj = 0;
24470 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24471 int arg2 ;
24472 void *argp1 = 0 ;
24473 int res1 = 0 ;
24474 int val2 ;
24475 int ecode2 = 0 ;
24476 PyObject *swig_obj[2] ;
24477
24478 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24480 if (!SWIG_IsOK(res1)) {
24481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24482 }
24483 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24484 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24485 if (!SWIG_IsOK(ecode2)) {
24486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24487 }
24488 arg2 = static_cast< int >(val2);
24489 if (arg1) (arg1)->m_wheelRotation = arg2;
24490
24491 resultobj = SWIG_Py_Void();
24492 return resultobj;
24493 fail:
24494 return NULL;
24495 }
24496
24497
24498 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24499 PyObject *resultobj = 0;
24500 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24501 int result;
24502 void *argp1 = 0 ;
24503 int res1 = 0 ;
24504 PyObject *swig_obj[1] ;
24505
24506 if (!args) SWIG_fail;
24507 swig_obj[0] = args;
24508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24509 if (!SWIG_IsOK(res1)) {
24510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24511 }
24512 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24513 result = (int) ((arg1)->m_wheelRotation);
24514 resultobj = SWIG_From_int(static_cast< int >(result));
24515 return resultobj;
24516 fail:
24517 return NULL;
24518 }
24519
24520
24521 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24522 PyObject *resultobj = 0;
24523 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24524 int arg2 ;
24525 void *argp1 = 0 ;
24526 int res1 = 0 ;
24527 int val2 ;
24528 int ecode2 = 0 ;
24529 PyObject *swig_obj[2] ;
24530
24531 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24533 if (!SWIG_IsOK(res1)) {
24534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24535 }
24536 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24537 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24538 if (!SWIG_IsOK(ecode2)) {
24539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24540 }
24541 arg2 = static_cast< int >(val2);
24542 if (arg1) (arg1)->m_wheelDelta = arg2;
24543
24544 resultobj = SWIG_Py_Void();
24545 return resultobj;
24546 fail:
24547 return NULL;
24548 }
24549
24550
24551 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24552 PyObject *resultobj = 0;
24553 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24554 int result;
24555 void *argp1 = 0 ;
24556 int res1 = 0 ;
24557 PyObject *swig_obj[1] ;
24558
24559 if (!args) SWIG_fail;
24560 swig_obj[0] = args;
24561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24562 if (!SWIG_IsOK(res1)) {
24563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24564 }
24565 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24566 result = (int) ((arg1)->m_wheelDelta);
24567 resultobj = SWIG_From_int(static_cast< int >(result));
24568 return resultobj;
24569 fail:
24570 return NULL;
24571 }
24572
24573
24574 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24575 PyObject *resultobj = 0;
24576 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24577 int arg2 ;
24578 void *argp1 = 0 ;
24579 int res1 = 0 ;
24580 int val2 ;
24581 int ecode2 = 0 ;
24582 PyObject *swig_obj[2] ;
24583
24584 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24586 if (!SWIG_IsOK(res1)) {
24587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24588 }
24589 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24590 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24591 if (!SWIG_IsOK(ecode2)) {
24592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24593 }
24594 arg2 = static_cast< int >(val2);
24595 if (arg1) (arg1)->m_linesPerAction = arg2;
24596
24597 resultobj = SWIG_Py_Void();
24598 return resultobj;
24599 fail:
24600 return NULL;
24601 }
24602
24603
24604 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24605 PyObject *resultobj = 0;
24606 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24607 int result;
24608 void *argp1 = 0 ;
24609 int res1 = 0 ;
24610 PyObject *swig_obj[1] ;
24611
24612 if (!args) SWIG_fail;
24613 swig_obj[0] = args;
24614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24615 if (!SWIG_IsOK(res1)) {
24616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24617 }
24618 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24619 result = (int) ((arg1)->m_linesPerAction);
24620 resultobj = SWIG_From_int(static_cast< int >(result));
24621 return resultobj;
24622 fail:
24623 return NULL;
24624 }
24625
24626
24627 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24628 PyObject *obj;
24629 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24630 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24631 return SWIG_Py_Void();
24632 }
24633
24634 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24635 return SWIG_Python_InitShadowInstance(args);
24636 }
24637
24638 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24639 PyObject *resultobj = 0;
24640 int arg1 = (int) 0 ;
24641 int arg2 = (int) 0 ;
24642 wxSetCursorEvent *result = 0 ;
24643 int val1 ;
24644 int ecode1 = 0 ;
24645 int val2 ;
24646 int ecode2 = 0 ;
24647 PyObject * obj0 = 0 ;
24648 PyObject * obj1 = 0 ;
24649 char * kwnames[] = {
24650 (char *) "x",(char *) "y", NULL
24651 };
24652
24653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24654 if (obj0) {
24655 ecode1 = SWIG_AsVal_int(obj0, &val1);
24656 if (!SWIG_IsOK(ecode1)) {
24657 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24658 }
24659 arg1 = static_cast< int >(val1);
24660 }
24661 if (obj1) {
24662 ecode2 = SWIG_AsVal_int(obj1, &val2);
24663 if (!SWIG_IsOK(ecode2)) {
24664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24665 }
24666 arg2 = static_cast< int >(val2);
24667 }
24668 {
24669 PyThreadState* __tstate = wxPyBeginAllowThreads();
24670 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24671 wxPyEndAllowThreads(__tstate);
24672 if (PyErr_Occurred()) SWIG_fail;
24673 }
24674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24675 return resultobj;
24676 fail:
24677 return NULL;
24678 }
24679
24680
24681 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24682 PyObject *resultobj = 0;
24683 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24684 int result;
24685 void *argp1 = 0 ;
24686 int res1 = 0 ;
24687 PyObject *swig_obj[1] ;
24688
24689 if (!args) SWIG_fail;
24690 swig_obj[0] = args;
24691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24692 if (!SWIG_IsOK(res1)) {
24693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24694 }
24695 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24696 {
24697 PyThreadState* __tstate = wxPyBeginAllowThreads();
24698 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24699 wxPyEndAllowThreads(__tstate);
24700 if (PyErr_Occurred()) SWIG_fail;
24701 }
24702 resultobj = SWIG_From_int(static_cast< int >(result));
24703 return resultobj;
24704 fail:
24705 return NULL;
24706 }
24707
24708
24709 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24710 PyObject *resultobj = 0;
24711 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24712 int result;
24713 void *argp1 = 0 ;
24714 int res1 = 0 ;
24715 PyObject *swig_obj[1] ;
24716
24717 if (!args) SWIG_fail;
24718 swig_obj[0] = args;
24719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24720 if (!SWIG_IsOK(res1)) {
24721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24722 }
24723 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24724 {
24725 PyThreadState* __tstate = wxPyBeginAllowThreads();
24726 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24727 wxPyEndAllowThreads(__tstate);
24728 if (PyErr_Occurred()) SWIG_fail;
24729 }
24730 resultobj = SWIG_From_int(static_cast< int >(result));
24731 return resultobj;
24732 fail:
24733 return NULL;
24734 }
24735
24736
24737 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24738 PyObject *resultobj = 0;
24739 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24740 wxCursor *arg2 = 0 ;
24741 void *argp1 = 0 ;
24742 int res1 = 0 ;
24743 void *argp2 = 0 ;
24744 int res2 = 0 ;
24745 PyObject * obj0 = 0 ;
24746 PyObject * obj1 = 0 ;
24747 char * kwnames[] = {
24748 (char *) "self",(char *) "cursor", NULL
24749 };
24750
24751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24753 if (!SWIG_IsOK(res1)) {
24754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24755 }
24756 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24757 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24758 if (!SWIG_IsOK(res2)) {
24759 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24760 }
24761 if (!argp2) {
24762 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24763 }
24764 arg2 = reinterpret_cast< wxCursor * >(argp2);
24765 {
24766 PyThreadState* __tstate = wxPyBeginAllowThreads();
24767 (arg1)->SetCursor((wxCursor const &)*arg2);
24768 wxPyEndAllowThreads(__tstate);
24769 if (PyErr_Occurred()) SWIG_fail;
24770 }
24771 resultobj = SWIG_Py_Void();
24772 return resultobj;
24773 fail:
24774 return NULL;
24775 }
24776
24777
24778 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24779 PyObject *resultobj = 0;
24780 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24781 wxCursor *result = 0 ;
24782 void *argp1 = 0 ;
24783 int res1 = 0 ;
24784 PyObject *swig_obj[1] ;
24785
24786 if (!args) SWIG_fail;
24787 swig_obj[0] = args;
24788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24789 if (!SWIG_IsOK(res1)) {
24790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24791 }
24792 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24793 {
24794 PyThreadState* __tstate = wxPyBeginAllowThreads();
24795 {
24796 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24797 result = (wxCursor *) &_result_ref;
24798 }
24799 wxPyEndAllowThreads(__tstate);
24800 if (PyErr_Occurred()) SWIG_fail;
24801 }
24802 {
24803 wxCursor* resultptr = new wxCursor(*result);
24804 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24805 }
24806 return resultobj;
24807 fail:
24808 return NULL;
24809 }
24810
24811
24812 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24813 PyObject *resultobj = 0;
24814 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24815 bool result;
24816 void *argp1 = 0 ;
24817 int res1 = 0 ;
24818 PyObject *swig_obj[1] ;
24819
24820 if (!args) SWIG_fail;
24821 swig_obj[0] = args;
24822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24823 if (!SWIG_IsOK(res1)) {
24824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24825 }
24826 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24827 {
24828 PyThreadState* __tstate = wxPyBeginAllowThreads();
24829 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24830 wxPyEndAllowThreads(__tstate);
24831 if (PyErr_Occurred()) SWIG_fail;
24832 }
24833 {
24834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24835 }
24836 return resultobj;
24837 fail:
24838 return NULL;
24839 }
24840
24841
24842 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24843 PyObject *obj;
24844 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24845 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24846 return SWIG_Py_Void();
24847 }
24848
24849 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24850 return SWIG_Python_InitShadowInstance(args);
24851 }
24852
24853 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24854 PyObject *resultobj = 0;
24855 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24856 wxKeyEvent *result = 0 ;
24857 int val1 ;
24858 int ecode1 = 0 ;
24859 PyObject * obj0 = 0 ;
24860 char * kwnames[] = {
24861 (char *) "eventType", NULL
24862 };
24863
24864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24865 if (obj0) {
24866 ecode1 = SWIG_AsVal_int(obj0, &val1);
24867 if (!SWIG_IsOK(ecode1)) {
24868 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24869 }
24870 arg1 = static_cast< wxEventType >(val1);
24871 }
24872 {
24873 PyThreadState* __tstate = wxPyBeginAllowThreads();
24874 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24875 wxPyEndAllowThreads(__tstate);
24876 if (PyErr_Occurred()) SWIG_fail;
24877 }
24878 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24879 return resultobj;
24880 fail:
24881 return NULL;
24882 }
24883
24884
24885 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24886 PyObject *resultobj = 0;
24887 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24888 int result;
24889 void *argp1 = 0 ;
24890 int res1 = 0 ;
24891 PyObject *swig_obj[1] ;
24892
24893 if (!args) SWIG_fail;
24894 swig_obj[0] = args;
24895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24896 if (!SWIG_IsOK(res1)) {
24897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24898 }
24899 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24900 {
24901 PyThreadState* __tstate = wxPyBeginAllowThreads();
24902 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24903 wxPyEndAllowThreads(__tstate);
24904 if (PyErr_Occurred()) SWIG_fail;
24905 }
24906 resultobj = SWIG_From_int(static_cast< int >(result));
24907 return resultobj;
24908 fail:
24909 return NULL;
24910 }
24911
24912
24913 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24914 PyObject *resultobj = 0;
24915 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24916 bool result;
24917 void *argp1 = 0 ;
24918 int res1 = 0 ;
24919 PyObject *swig_obj[1] ;
24920
24921 if (!args) SWIG_fail;
24922 swig_obj[0] = args;
24923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24924 if (!SWIG_IsOK(res1)) {
24925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24926 }
24927 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24928 {
24929 PyThreadState* __tstate = wxPyBeginAllowThreads();
24930 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
24931 wxPyEndAllowThreads(__tstate);
24932 if (PyErr_Occurred()) SWIG_fail;
24933 }
24934 {
24935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24936 }
24937 return resultobj;
24938 fail:
24939 return NULL;
24940 }
24941
24942
24943 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24944 PyObject *resultobj = 0;
24945 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24946 bool result;
24947 void *argp1 = 0 ;
24948 int res1 = 0 ;
24949 PyObject *swig_obj[1] ;
24950
24951 if (!args) SWIG_fail;
24952 swig_obj[0] = args;
24953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24954 if (!SWIG_IsOK(res1)) {
24955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24956 }
24957 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24958 {
24959 PyThreadState* __tstate = wxPyBeginAllowThreads();
24960 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
24961 wxPyEndAllowThreads(__tstate);
24962 if (PyErr_Occurred()) SWIG_fail;
24963 }
24964 {
24965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24966 }
24967 return resultobj;
24968 fail:
24969 return NULL;
24970 }
24971
24972
24973 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24974 PyObject *resultobj = 0;
24975 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24976 bool result;
24977 void *argp1 = 0 ;
24978 int res1 = 0 ;
24979 PyObject *swig_obj[1] ;
24980
24981 if (!args) SWIG_fail;
24982 swig_obj[0] = args;
24983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24984 if (!SWIG_IsOK(res1)) {
24985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24986 }
24987 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24988 {
24989 PyThreadState* __tstate = wxPyBeginAllowThreads();
24990 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
24991 wxPyEndAllowThreads(__tstate);
24992 if (PyErr_Occurred()) SWIG_fail;
24993 }
24994 {
24995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24996 }
24997 return resultobj;
24998 fail:
24999 return NULL;
25000 }
25001
25002
25003 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25004 PyObject *resultobj = 0;
25005 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25006 bool result;
25007 void *argp1 = 0 ;
25008 int res1 = 0 ;
25009 PyObject *swig_obj[1] ;
25010
25011 if (!args) SWIG_fail;
25012 swig_obj[0] = args;
25013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25014 if (!SWIG_IsOK(res1)) {
25015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25016 }
25017 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25018 {
25019 PyThreadState* __tstate = wxPyBeginAllowThreads();
25020 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
25021 wxPyEndAllowThreads(__tstate);
25022 if (PyErr_Occurred()) SWIG_fail;
25023 }
25024 {
25025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25026 }
25027 return resultobj;
25028 fail:
25029 return NULL;
25030 }
25031
25032
25033 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25034 PyObject *resultobj = 0;
25035 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25036 bool result;
25037 void *argp1 = 0 ;
25038 int res1 = 0 ;
25039 PyObject *swig_obj[1] ;
25040
25041 if (!args) SWIG_fail;
25042 swig_obj[0] = args;
25043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25044 if (!SWIG_IsOK(res1)) {
25045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25046 }
25047 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25048 {
25049 PyThreadState* __tstate = wxPyBeginAllowThreads();
25050 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25051 wxPyEndAllowThreads(__tstate);
25052 if (PyErr_Occurred()) SWIG_fail;
25053 }
25054 {
25055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25056 }
25057 return resultobj;
25058 fail:
25059 return NULL;
25060 }
25061
25062
25063 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25064 PyObject *resultobj = 0;
25065 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25066 bool result;
25067 void *argp1 = 0 ;
25068 int res1 = 0 ;
25069 PyObject *swig_obj[1] ;
25070
25071 if (!args) SWIG_fail;
25072 swig_obj[0] = args;
25073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25074 if (!SWIG_IsOK(res1)) {
25075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25076 }
25077 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25078 {
25079 PyThreadState* __tstate = wxPyBeginAllowThreads();
25080 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25081 wxPyEndAllowThreads(__tstate);
25082 if (PyErr_Occurred()) SWIG_fail;
25083 }
25084 {
25085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25086 }
25087 return resultobj;
25088 fail:
25089 return NULL;
25090 }
25091
25092
25093 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25094 PyObject *resultobj = 0;
25095 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25096 int result;
25097 void *argp1 = 0 ;
25098 int res1 = 0 ;
25099 PyObject *swig_obj[1] ;
25100
25101 if (!args) SWIG_fail;
25102 swig_obj[0] = args;
25103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25104 if (!SWIG_IsOK(res1)) {
25105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25106 }
25107 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25108 {
25109 PyThreadState* __tstate = wxPyBeginAllowThreads();
25110 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25111 wxPyEndAllowThreads(__tstate);
25112 if (PyErr_Occurred()) SWIG_fail;
25113 }
25114 resultobj = SWIG_From_int(static_cast< int >(result));
25115 return resultobj;
25116 fail:
25117 return NULL;
25118 }
25119
25120
25121 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25122 PyObject *resultobj = 0;
25123 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25124 int result;
25125 void *argp1 = 0 ;
25126 int res1 = 0 ;
25127 PyObject *swig_obj[1] ;
25128
25129 if (!args) SWIG_fail;
25130 swig_obj[0] = args;
25131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25132 if (!SWIG_IsOK(res1)) {
25133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25134 }
25135 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25136 {
25137 PyThreadState* __tstate = wxPyBeginAllowThreads();
25138 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25139 wxPyEndAllowThreads(__tstate);
25140 if (PyErr_Occurred()) SWIG_fail;
25141 }
25142 resultobj = SWIG_From_int(static_cast< int >(result));
25143 return resultobj;
25144 fail:
25145 return NULL;
25146 }
25147
25148
25149 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25150 PyObject *resultobj = 0;
25151 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25152 int arg2 ;
25153 void *argp1 = 0 ;
25154 int res1 = 0 ;
25155 int val2 ;
25156 int ecode2 = 0 ;
25157 PyObject * obj0 = 0 ;
25158 PyObject * obj1 = 0 ;
25159 char * kwnames[] = {
25160 (char *) "self",(char *) "uniChar", NULL
25161 };
25162
25163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25165 if (!SWIG_IsOK(res1)) {
25166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25167 }
25168 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25169 ecode2 = SWIG_AsVal_int(obj1, &val2);
25170 if (!SWIG_IsOK(ecode2)) {
25171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25172 }
25173 arg2 = static_cast< int >(val2);
25174 {
25175 PyThreadState* __tstate = wxPyBeginAllowThreads();
25176 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25177 wxPyEndAllowThreads(__tstate);
25178 if (PyErr_Occurred()) SWIG_fail;
25179 }
25180 resultobj = SWIG_Py_Void();
25181 return resultobj;
25182 fail:
25183 return NULL;
25184 }
25185
25186
25187 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25188 PyObject *resultobj = 0;
25189 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25190 unsigned int result;
25191 void *argp1 = 0 ;
25192 int res1 = 0 ;
25193 PyObject *swig_obj[1] ;
25194
25195 if (!args) SWIG_fail;
25196 swig_obj[0] = args;
25197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25198 if (!SWIG_IsOK(res1)) {
25199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25200 }
25201 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25202 {
25203 PyThreadState* __tstate = wxPyBeginAllowThreads();
25204 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25205 wxPyEndAllowThreads(__tstate);
25206 if (PyErr_Occurred()) SWIG_fail;
25207 }
25208 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25209 return resultobj;
25210 fail:
25211 return NULL;
25212 }
25213
25214
25215 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25216 PyObject *resultobj = 0;
25217 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25218 unsigned int result;
25219 void *argp1 = 0 ;
25220 int res1 = 0 ;
25221 PyObject *swig_obj[1] ;
25222
25223 if (!args) SWIG_fail;
25224 swig_obj[0] = args;
25225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25226 if (!SWIG_IsOK(res1)) {
25227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25228 }
25229 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25230 {
25231 PyThreadState* __tstate = wxPyBeginAllowThreads();
25232 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25233 wxPyEndAllowThreads(__tstate);
25234 if (PyErr_Occurred()) SWIG_fail;
25235 }
25236 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25237 return resultobj;
25238 fail:
25239 return NULL;
25240 }
25241
25242
25243 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25244 PyObject *resultobj = 0;
25245 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25246 wxPoint result;
25247 void *argp1 = 0 ;
25248 int res1 = 0 ;
25249 PyObject *swig_obj[1] ;
25250
25251 if (!args) SWIG_fail;
25252 swig_obj[0] = args;
25253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25254 if (!SWIG_IsOK(res1)) {
25255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25256 }
25257 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25258 {
25259 PyThreadState* __tstate = wxPyBeginAllowThreads();
25260 result = (arg1)->GetPosition();
25261 wxPyEndAllowThreads(__tstate);
25262 if (PyErr_Occurred()) SWIG_fail;
25263 }
25264 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25265 return resultobj;
25266 fail:
25267 return NULL;
25268 }
25269
25270
25271 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25272 PyObject *resultobj = 0;
25273 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25274 long *arg2 = (long *) 0 ;
25275 long *arg3 = (long *) 0 ;
25276 void *argp1 = 0 ;
25277 int res1 = 0 ;
25278 long temp2 ;
25279 int res2 = SWIG_TMPOBJ ;
25280 long temp3 ;
25281 int res3 = SWIG_TMPOBJ ;
25282 PyObject *swig_obj[1] ;
25283
25284 arg2 = &temp2;
25285 arg3 = &temp3;
25286 if (!args) SWIG_fail;
25287 swig_obj[0] = args;
25288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25289 if (!SWIG_IsOK(res1)) {
25290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25291 }
25292 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25293 {
25294 PyThreadState* __tstate = wxPyBeginAllowThreads();
25295 (arg1)->GetPosition(arg2,arg3);
25296 wxPyEndAllowThreads(__tstate);
25297 if (PyErr_Occurred()) SWIG_fail;
25298 }
25299 resultobj = SWIG_Py_Void();
25300 if (SWIG_IsTmpObj(res2)) {
25301 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25302 } else {
25303 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25304 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25305 }
25306 if (SWIG_IsTmpObj(res3)) {
25307 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25308 } else {
25309 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25310 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25311 }
25312 return resultobj;
25313 fail:
25314 return NULL;
25315 }
25316
25317
25318 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25319 PyObject *resultobj = 0;
25320 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25321 int result;
25322 void *argp1 = 0 ;
25323 int res1 = 0 ;
25324 PyObject *swig_obj[1] ;
25325
25326 if (!args) SWIG_fail;
25327 swig_obj[0] = args;
25328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25329 if (!SWIG_IsOK(res1)) {
25330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25331 }
25332 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25333 {
25334 PyThreadState* __tstate = wxPyBeginAllowThreads();
25335 result = (int)((wxKeyEvent const *)arg1)->GetX();
25336 wxPyEndAllowThreads(__tstate);
25337 if (PyErr_Occurred()) SWIG_fail;
25338 }
25339 resultobj = SWIG_From_int(static_cast< int >(result));
25340 return resultobj;
25341 fail:
25342 return NULL;
25343 }
25344
25345
25346 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25347 PyObject *resultobj = 0;
25348 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25349 int result;
25350 void *argp1 = 0 ;
25351 int res1 = 0 ;
25352 PyObject *swig_obj[1] ;
25353
25354 if (!args) SWIG_fail;
25355 swig_obj[0] = args;
25356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25357 if (!SWIG_IsOK(res1)) {
25358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25359 }
25360 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25361 {
25362 PyThreadState* __tstate = wxPyBeginAllowThreads();
25363 result = (int)((wxKeyEvent const *)arg1)->GetY();
25364 wxPyEndAllowThreads(__tstate);
25365 if (PyErr_Occurred()) SWIG_fail;
25366 }
25367 resultobj = SWIG_From_int(static_cast< int >(result));
25368 return resultobj;
25369 fail:
25370 return NULL;
25371 }
25372
25373
25374 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25375 PyObject *resultobj = 0;
25376 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25377 int arg2 ;
25378 void *argp1 = 0 ;
25379 int res1 = 0 ;
25380 int val2 ;
25381 int ecode2 = 0 ;
25382 PyObject *swig_obj[2] ;
25383
25384 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25386 if (!SWIG_IsOK(res1)) {
25387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25388 }
25389 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25390 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25391 if (!SWIG_IsOK(ecode2)) {
25392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25393 }
25394 arg2 = static_cast< int >(val2);
25395 if (arg1) (arg1)->m_x = arg2;
25396
25397 resultobj = SWIG_Py_Void();
25398 return resultobj;
25399 fail:
25400 return NULL;
25401 }
25402
25403
25404 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25405 PyObject *resultobj = 0;
25406 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25407 int result;
25408 void *argp1 = 0 ;
25409 int res1 = 0 ;
25410 PyObject *swig_obj[1] ;
25411
25412 if (!args) SWIG_fail;
25413 swig_obj[0] = args;
25414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25415 if (!SWIG_IsOK(res1)) {
25416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25417 }
25418 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25419 result = (int) ((arg1)->m_x);
25420 resultobj = SWIG_From_int(static_cast< int >(result));
25421 return resultobj;
25422 fail:
25423 return NULL;
25424 }
25425
25426
25427 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25428 PyObject *resultobj = 0;
25429 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25430 int arg2 ;
25431 void *argp1 = 0 ;
25432 int res1 = 0 ;
25433 int val2 ;
25434 int ecode2 = 0 ;
25435 PyObject *swig_obj[2] ;
25436
25437 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25439 if (!SWIG_IsOK(res1)) {
25440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25441 }
25442 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25443 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25444 if (!SWIG_IsOK(ecode2)) {
25445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25446 }
25447 arg2 = static_cast< int >(val2);
25448 if (arg1) (arg1)->m_y = arg2;
25449
25450 resultobj = SWIG_Py_Void();
25451 return resultobj;
25452 fail:
25453 return NULL;
25454 }
25455
25456
25457 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25458 PyObject *resultobj = 0;
25459 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25460 int result;
25461 void *argp1 = 0 ;
25462 int res1 = 0 ;
25463 PyObject *swig_obj[1] ;
25464
25465 if (!args) SWIG_fail;
25466 swig_obj[0] = args;
25467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25468 if (!SWIG_IsOK(res1)) {
25469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25470 }
25471 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25472 result = (int) ((arg1)->m_y);
25473 resultobj = SWIG_From_int(static_cast< int >(result));
25474 return resultobj;
25475 fail:
25476 return NULL;
25477 }
25478
25479
25480 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25481 PyObject *resultobj = 0;
25482 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25483 long arg2 ;
25484 void *argp1 = 0 ;
25485 int res1 = 0 ;
25486 long val2 ;
25487 int ecode2 = 0 ;
25488 PyObject *swig_obj[2] ;
25489
25490 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25492 if (!SWIG_IsOK(res1)) {
25493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25494 }
25495 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25496 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25497 if (!SWIG_IsOK(ecode2)) {
25498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25499 }
25500 arg2 = static_cast< long >(val2);
25501 if (arg1) (arg1)->m_keyCode = arg2;
25502
25503 resultobj = SWIG_Py_Void();
25504 return resultobj;
25505 fail:
25506 return NULL;
25507 }
25508
25509
25510 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25511 PyObject *resultobj = 0;
25512 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25513 long result;
25514 void *argp1 = 0 ;
25515 int res1 = 0 ;
25516 PyObject *swig_obj[1] ;
25517
25518 if (!args) SWIG_fail;
25519 swig_obj[0] = args;
25520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25521 if (!SWIG_IsOK(res1)) {
25522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25523 }
25524 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25525 result = (long) ((arg1)->m_keyCode);
25526 resultobj = SWIG_From_long(static_cast< long >(result));
25527 return resultobj;
25528 fail:
25529 return NULL;
25530 }
25531
25532
25533 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25534 PyObject *resultobj = 0;
25535 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25536 bool arg2 ;
25537 void *argp1 = 0 ;
25538 int res1 = 0 ;
25539 bool val2 ;
25540 int ecode2 = 0 ;
25541 PyObject *swig_obj[2] ;
25542
25543 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25545 if (!SWIG_IsOK(res1)) {
25546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25547 }
25548 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25549 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25550 if (!SWIG_IsOK(ecode2)) {
25551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25552 }
25553 arg2 = static_cast< bool >(val2);
25554 if (arg1) (arg1)->m_controlDown = arg2;
25555
25556 resultobj = SWIG_Py_Void();
25557 return resultobj;
25558 fail:
25559 return NULL;
25560 }
25561
25562
25563 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25564 PyObject *resultobj = 0;
25565 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25566 bool result;
25567 void *argp1 = 0 ;
25568 int res1 = 0 ;
25569 PyObject *swig_obj[1] ;
25570
25571 if (!args) SWIG_fail;
25572 swig_obj[0] = args;
25573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25574 if (!SWIG_IsOK(res1)) {
25575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25576 }
25577 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25578 result = (bool) ((arg1)->m_controlDown);
25579 {
25580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25581 }
25582 return resultobj;
25583 fail:
25584 return NULL;
25585 }
25586
25587
25588 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25589 PyObject *resultobj = 0;
25590 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25591 bool arg2 ;
25592 void *argp1 = 0 ;
25593 int res1 = 0 ;
25594 bool val2 ;
25595 int ecode2 = 0 ;
25596 PyObject *swig_obj[2] ;
25597
25598 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25600 if (!SWIG_IsOK(res1)) {
25601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25602 }
25603 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25604 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25605 if (!SWIG_IsOK(ecode2)) {
25606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25607 }
25608 arg2 = static_cast< bool >(val2);
25609 if (arg1) (arg1)->m_shiftDown = arg2;
25610
25611 resultobj = SWIG_Py_Void();
25612 return resultobj;
25613 fail:
25614 return NULL;
25615 }
25616
25617
25618 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25619 PyObject *resultobj = 0;
25620 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25621 bool result;
25622 void *argp1 = 0 ;
25623 int res1 = 0 ;
25624 PyObject *swig_obj[1] ;
25625
25626 if (!args) SWIG_fail;
25627 swig_obj[0] = args;
25628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25629 if (!SWIG_IsOK(res1)) {
25630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25631 }
25632 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25633 result = (bool) ((arg1)->m_shiftDown);
25634 {
25635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25636 }
25637 return resultobj;
25638 fail:
25639 return NULL;
25640 }
25641
25642
25643 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25644 PyObject *resultobj = 0;
25645 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25646 bool arg2 ;
25647 void *argp1 = 0 ;
25648 int res1 = 0 ;
25649 bool val2 ;
25650 int ecode2 = 0 ;
25651 PyObject *swig_obj[2] ;
25652
25653 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25655 if (!SWIG_IsOK(res1)) {
25656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25657 }
25658 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25659 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25660 if (!SWIG_IsOK(ecode2)) {
25661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25662 }
25663 arg2 = static_cast< bool >(val2);
25664 if (arg1) (arg1)->m_altDown = arg2;
25665
25666 resultobj = SWIG_Py_Void();
25667 return resultobj;
25668 fail:
25669 return NULL;
25670 }
25671
25672
25673 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25674 PyObject *resultobj = 0;
25675 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25676 bool result;
25677 void *argp1 = 0 ;
25678 int res1 = 0 ;
25679 PyObject *swig_obj[1] ;
25680
25681 if (!args) SWIG_fail;
25682 swig_obj[0] = args;
25683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25684 if (!SWIG_IsOK(res1)) {
25685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25686 }
25687 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25688 result = (bool) ((arg1)->m_altDown);
25689 {
25690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25691 }
25692 return resultobj;
25693 fail:
25694 return NULL;
25695 }
25696
25697
25698 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25699 PyObject *resultobj = 0;
25700 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25701 bool arg2 ;
25702 void *argp1 = 0 ;
25703 int res1 = 0 ;
25704 bool val2 ;
25705 int ecode2 = 0 ;
25706 PyObject *swig_obj[2] ;
25707
25708 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25710 if (!SWIG_IsOK(res1)) {
25711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25712 }
25713 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25714 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25715 if (!SWIG_IsOK(ecode2)) {
25716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25717 }
25718 arg2 = static_cast< bool >(val2);
25719 if (arg1) (arg1)->m_metaDown = arg2;
25720
25721 resultobj = SWIG_Py_Void();
25722 return resultobj;
25723 fail:
25724 return NULL;
25725 }
25726
25727
25728 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25729 PyObject *resultobj = 0;
25730 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25731 bool result;
25732 void *argp1 = 0 ;
25733 int res1 = 0 ;
25734 PyObject *swig_obj[1] ;
25735
25736 if (!args) SWIG_fail;
25737 swig_obj[0] = args;
25738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25739 if (!SWIG_IsOK(res1)) {
25740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25741 }
25742 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25743 result = (bool) ((arg1)->m_metaDown);
25744 {
25745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25746 }
25747 return resultobj;
25748 fail:
25749 return NULL;
25750 }
25751
25752
25753 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25754 PyObject *resultobj = 0;
25755 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25756 bool arg2 ;
25757 void *argp1 = 0 ;
25758 int res1 = 0 ;
25759 bool val2 ;
25760 int ecode2 = 0 ;
25761 PyObject *swig_obj[2] ;
25762
25763 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25765 if (!SWIG_IsOK(res1)) {
25766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25767 }
25768 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25769 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25770 if (!SWIG_IsOK(ecode2)) {
25771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25772 }
25773 arg2 = static_cast< bool >(val2);
25774 if (arg1) (arg1)->m_scanCode = arg2;
25775
25776 resultobj = SWIG_Py_Void();
25777 return resultobj;
25778 fail:
25779 return NULL;
25780 }
25781
25782
25783 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25784 PyObject *resultobj = 0;
25785 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25786 bool result;
25787 void *argp1 = 0 ;
25788 int res1 = 0 ;
25789 PyObject *swig_obj[1] ;
25790
25791 if (!args) SWIG_fail;
25792 swig_obj[0] = args;
25793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25794 if (!SWIG_IsOK(res1)) {
25795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25796 }
25797 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25798 result = (bool) ((arg1)->m_scanCode);
25799 {
25800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25801 }
25802 return resultobj;
25803 fail:
25804 return NULL;
25805 }
25806
25807
25808 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25809 PyObject *resultobj = 0;
25810 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25811 unsigned int arg2 ;
25812 void *argp1 = 0 ;
25813 int res1 = 0 ;
25814 unsigned int val2 ;
25815 int ecode2 = 0 ;
25816 PyObject *swig_obj[2] ;
25817
25818 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25820 if (!SWIG_IsOK(res1)) {
25821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25822 }
25823 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25824 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25825 if (!SWIG_IsOK(ecode2)) {
25826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25827 }
25828 arg2 = static_cast< unsigned int >(val2);
25829 if (arg1) (arg1)->m_rawCode = arg2;
25830
25831 resultobj = SWIG_Py_Void();
25832 return resultobj;
25833 fail:
25834 return NULL;
25835 }
25836
25837
25838 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25839 PyObject *resultobj = 0;
25840 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25841 unsigned int result;
25842 void *argp1 = 0 ;
25843 int res1 = 0 ;
25844 PyObject *swig_obj[1] ;
25845
25846 if (!args) SWIG_fail;
25847 swig_obj[0] = args;
25848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25849 if (!SWIG_IsOK(res1)) {
25850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25851 }
25852 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25853 result = (unsigned int) ((arg1)->m_rawCode);
25854 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25855 return resultobj;
25856 fail:
25857 return NULL;
25858 }
25859
25860
25861 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25862 PyObject *resultobj = 0;
25863 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25864 unsigned int arg2 ;
25865 void *argp1 = 0 ;
25866 int res1 = 0 ;
25867 unsigned int val2 ;
25868 int ecode2 = 0 ;
25869 PyObject *swig_obj[2] ;
25870
25871 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25873 if (!SWIG_IsOK(res1)) {
25874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25875 }
25876 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25877 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25878 if (!SWIG_IsOK(ecode2)) {
25879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25880 }
25881 arg2 = static_cast< unsigned int >(val2);
25882 if (arg1) (arg1)->m_rawFlags = arg2;
25883
25884 resultobj = SWIG_Py_Void();
25885 return resultobj;
25886 fail:
25887 return NULL;
25888 }
25889
25890
25891 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25892 PyObject *resultobj = 0;
25893 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25894 unsigned int result;
25895 void *argp1 = 0 ;
25896 int res1 = 0 ;
25897 PyObject *swig_obj[1] ;
25898
25899 if (!args) SWIG_fail;
25900 swig_obj[0] = args;
25901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25902 if (!SWIG_IsOK(res1)) {
25903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25904 }
25905 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25906 result = (unsigned int) ((arg1)->m_rawFlags);
25907 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25908 return resultobj;
25909 fail:
25910 return NULL;
25911 }
25912
25913
25914 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25915 PyObject *obj;
25916 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25917 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25918 return SWIG_Py_Void();
25919 }
25920
25921 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25922 return SWIG_Python_InitShadowInstance(args);
25923 }
25924
25925 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25926 PyObject *resultobj = 0;
25927 wxSize const &arg1_defvalue = wxDefaultSize ;
25928 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
25929 int arg2 = (int) 0 ;
25930 wxSizeEvent *result = 0 ;
25931 wxSize temp1 ;
25932 int val2 ;
25933 int ecode2 = 0 ;
25934 PyObject * obj0 = 0 ;
25935 PyObject * obj1 = 0 ;
25936 char * kwnames[] = {
25937 (char *) "sz",(char *) "winid", NULL
25938 };
25939
25940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25941 if (obj0) {
25942 {
25943 arg1 = &temp1;
25944 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
25945 }
25946 }
25947 if (obj1) {
25948 ecode2 = SWIG_AsVal_int(obj1, &val2);
25949 if (!SWIG_IsOK(ecode2)) {
25950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
25951 }
25952 arg2 = static_cast< int >(val2);
25953 }
25954 {
25955 PyThreadState* __tstate = wxPyBeginAllowThreads();
25956 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
25957 wxPyEndAllowThreads(__tstate);
25958 if (PyErr_Occurred()) SWIG_fail;
25959 }
25960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
25961 return resultobj;
25962 fail:
25963 return NULL;
25964 }
25965
25966
25967 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25968 PyObject *resultobj = 0;
25969 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25970 wxSize 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_wxSizeEvent, 0 | 0 );
25978 if (!SWIG_IsOK(res1)) {
25979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25980 }
25981 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25982 {
25983 PyThreadState* __tstate = wxPyBeginAllowThreads();
25984 result = ((wxSizeEvent const *)arg1)->GetSize();
25985 wxPyEndAllowThreads(__tstate);
25986 if (PyErr_Occurred()) SWIG_fail;
25987 }
25988 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
25989 return resultobj;
25990 fail:
25991 return NULL;
25992 }
25993
25994
25995 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25996 PyObject *resultobj = 0;
25997 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25998 wxRect result;
25999 void *argp1 = 0 ;
26000 int res1 = 0 ;
26001 PyObject *swig_obj[1] ;
26002
26003 if (!args) SWIG_fail;
26004 swig_obj[0] = args;
26005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26006 if (!SWIG_IsOK(res1)) {
26007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26008 }
26009 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26010 {
26011 PyThreadState* __tstate = wxPyBeginAllowThreads();
26012 result = ((wxSizeEvent const *)arg1)->GetRect();
26013 wxPyEndAllowThreads(__tstate);
26014 if (PyErr_Occurred()) SWIG_fail;
26015 }
26016 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26017 return resultobj;
26018 fail:
26019 return NULL;
26020 }
26021
26022
26023 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26024 PyObject *resultobj = 0;
26025 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26026 wxRect arg2 ;
26027 void *argp1 = 0 ;
26028 int res1 = 0 ;
26029 void *argp2 ;
26030 int res2 = 0 ;
26031 PyObject * obj0 = 0 ;
26032 PyObject * obj1 = 0 ;
26033 char * kwnames[] = {
26034 (char *) "self",(char *) "rect", NULL
26035 };
26036
26037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26039 if (!SWIG_IsOK(res1)) {
26040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26041 }
26042 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26043 {
26044 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26045 if (!SWIG_IsOK(res2)) {
26046 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26047 }
26048 if (!argp2) {
26049 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26050 } else {
26051 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26052 arg2 = *temp;
26053 if (SWIG_IsNewObj(res2)) delete temp;
26054 }
26055 }
26056 {
26057 PyThreadState* __tstate = wxPyBeginAllowThreads();
26058 (arg1)->SetRect(arg2);
26059 wxPyEndAllowThreads(__tstate);
26060 if (PyErr_Occurred()) SWIG_fail;
26061 }
26062 resultobj = SWIG_Py_Void();
26063 return resultobj;
26064 fail:
26065 return NULL;
26066 }
26067
26068
26069 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26070 PyObject *resultobj = 0;
26071 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26072 wxSize arg2 ;
26073 void *argp1 = 0 ;
26074 int res1 = 0 ;
26075 void *argp2 ;
26076 int res2 = 0 ;
26077 PyObject * obj0 = 0 ;
26078 PyObject * obj1 = 0 ;
26079 char * kwnames[] = {
26080 (char *) "self",(char *) "size", NULL
26081 };
26082
26083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26085 if (!SWIG_IsOK(res1)) {
26086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26087 }
26088 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26089 {
26090 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26091 if (!SWIG_IsOK(res2)) {
26092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26093 }
26094 if (!argp2) {
26095 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26096 } else {
26097 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26098 arg2 = *temp;
26099 if (SWIG_IsNewObj(res2)) delete temp;
26100 }
26101 }
26102 {
26103 PyThreadState* __tstate = wxPyBeginAllowThreads();
26104 wxSizeEvent_SetSize(arg1,arg2);
26105 wxPyEndAllowThreads(__tstate);
26106 if (PyErr_Occurred()) SWIG_fail;
26107 }
26108 resultobj = SWIG_Py_Void();
26109 return resultobj;
26110 fail:
26111 return NULL;
26112 }
26113
26114
26115 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26116 PyObject *resultobj = 0;
26117 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26118 wxSize *arg2 = (wxSize *) 0 ;
26119 void *argp1 = 0 ;
26120 int res1 = 0 ;
26121 void *argp2 = 0 ;
26122 int res2 = 0 ;
26123 PyObject *swig_obj[2] ;
26124
26125 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26127 if (!SWIG_IsOK(res1)) {
26128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26129 }
26130 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26131 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26132 if (!SWIG_IsOK(res2)) {
26133 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26134 }
26135 arg2 = reinterpret_cast< wxSize * >(argp2);
26136 if (arg1) (arg1)->m_size = *arg2;
26137
26138 resultobj = SWIG_Py_Void();
26139 return resultobj;
26140 fail:
26141 return NULL;
26142 }
26143
26144
26145 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26146 PyObject *resultobj = 0;
26147 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26148 wxSize *result = 0 ;
26149 void *argp1 = 0 ;
26150 int res1 = 0 ;
26151 PyObject *swig_obj[1] ;
26152
26153 if (!args) SWIG_fail;
26154 swig_obj[0] = args;
26155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26156 if (!SWIG_IsOK(res1)) {
26157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26158 }
26159 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26160 result = (wxSize *)& ((arg1)->m_size);
26161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26162 return resultobj;
26163 fail:
26164 return NULL;
26165 }
26166
26167
26168 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26169 PyObject *resultobj = 0;
26170 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26171 wxRect *arg2 = (wxRect *) 0 ;
26172 void *argp1 = 0 ;
26173 int res1 = 0 ;
26174 void *argp2 = 0 ;
26175 int res2 = 0 ;
26176 PyObject *swig_obj[2] ;
26177
26178 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26180 if (!SWIG_IsOK(res1)) {
26181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26182 }
26183 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26184 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26185 if (!SWIG_IsOK(res2)) {
26186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26187 }
26188 arg2 = reinterpret_cast< wxRect * >(argp2);
26189 if (arg1) (arg1)->m_rect = *arg2;
26190
26191 resultobj = SWIG_Py_Void();
26192 return resultobj;
26193 fail:
26194 return NULL;
26195 }
26196
26197
26198 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26199 PyObject *resultobj = 0;
26200 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26201 wxRect *result = 0 ;
26202 void *argp1 = 0 ;
26203 int res1 = 0 ;
26204 PyObject *swig_obj[1] ;
26205
26206 if (!args) SWIG_fail;
26207 swig_obj[0] = args;
26208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26209 if (!SWIG_IsOK(res1)) {
26210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26211 }
26212 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26213 result = (wxRect *)& ((arg1)->m_rect);
26214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26215 return resultobj;
26216 fail:
26217 return NULL;
26218 }
26219
26220
26221 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26222 PyObject *obj;
26223 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26224 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26225 return SWIG_Py_Void();
26226 }
26227
26228 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26229 return SWIG_Python_InitShadowInstance(args);
26230 }
26231
26232 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26233 PyObject *resultobj = 0;
26234 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26235 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26236 int arg2 = (int) 0 ;
26237 wxMoveEvent *result = 0 ;
26238 wxPoint temp1 ;
26239 int val2 ;
26240 int ecode2 = 0 ;
26241 PyObject * obj0 = 0 ;
26242 PyObject * obj1 = 0 ;
26243 char * kwnames[] = {
26244 (char *) "pos",(char *) "winid", NULL
26245 };
26246
26247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26248 if (obj0) {
26249 {
26250 arg1 = &temp1;
26251 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26252 }
26253 }
26254 if (obj1) {
26255 ecode2 = SWIG_AsVal_int(obj1, &val2);
26256 if (!SWIG_IsOK(ecode2)) {
26257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26258 }
26259 arg2 = static_cast< int >(val2);
26260 }
26261 {
26262 PyThreadState* __tstate = wxPyBeginAllowThreads();
26263 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26264 wxPyEndAllowThreads(__tstate);
26265 if (PyErr_Occurred()) SWIG_fail;
26266 }
26267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26268 return resultobj;
26269 fail:
26270 return NULL;
26271 }
26272
26273
26274 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26275 PyObject *resultobj = 0;
26276 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26277 wxPoint result;
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_wxMoveEvent, 0 | 0 );
26285 if (!SWIG_IsOK(res1)) {
26286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26287 }
26288 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26289 {
26290 PyThreadState* __tstate = wxPyBeginAllowThreads();
26291 result = ((wxMoveEvent const *)arg1)->GetPosition();
26292 wxPyEndAllowThreads(__tstate);
26293 if (PyErr_Occurred()) SWIG_fail;
26294 }
26295 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26296 return resultobj;
26297 fail:
26298 return NULL;
26299 }
26300
26301
26302 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26303 PyObject *resultobj = 0;
26304 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26305 wxRect result;
26306 void *argp1 = 0 ;
26307 int res1 = 0 ;
26308 PyObject *swig_obj[1] ;
26309
26310 if (!args) SWIG_fail;
26311 swig_obj[0] = args;
26312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26313 if (!SWIG_IsOK(res1)) {
26314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26315 }
26316 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26317 {
26318 PyThreadState* __tstate = wxPyBeginAllowThreads();
26319 result = ((wxMoveEvent const *)arg1)->GetRect();
26320 wxPyEndAllowThreads(__tstate);
26321 if (PyErr_Occurred()) SWIG_fail;
26322 }
26323 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26324 return resultobj;
26325 fail:
26326 return NULL;
26327 }
26328
26329
26330 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26331 PyObject *resultobj = 0;
26332 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26333 wxRect *arg2 = 0 ;
26334 void *argp1 = 0 ;
26335 int res1 = 0 ;
26336 wxRect temp2 ;
26337 PyObject * obj0 = 0 ;
26338 PyObject * obj1 = 0 ;
26339 char * kwnames[] = {
26340 (char *) "self",(char *) "rect", NULL
26341 };
26342
26343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26345 if (!SWIG_IsOK(res1)) {
26346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26347 }
26348 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26349 {
26350 arg2 = &temp2;
26351 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26352 }
26353 {
26354 PyThreadState* __tstate = wxPyBeginAllowThreads();
26355 (arg1)->SetRect((wxRect const &)*arg2);
26356 wxPyEndAllowThreads(__tstate);
26357 if (PyErr_Occurred()) SWIG_fail;
26358 }
26359 resultobj = SWIG_Py_Void();
26360 return resultobj;
26361 fail:
26362 return NULL;
26363 }
26364
26365
26366 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26367 PyObject *resultobj = 0;
26368 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26369 wxPoint *arg2 = 0 ;
26370 void *argp1 = 0 ;
26371 int res1 = 0 ;
26372 wxPoint temp2 ;
26373 PyObject * obj0 = 0 ;
26374 PyObject * obj1 = 0 ;
26375 char * kwnames[] = {
26376 (char *) "self",(char *) "pos", NULL
26377 };
26378
26379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26381 if (!SWIG_IsOK(res1)) {
26382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26383 }
26384 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26385 {
26386 arg2 = &temp2;
26387 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26388 }
26389 {
26390 PyThreadState* __tstate = wxPyBeginAllowThreads();
26391 (arg1)->SetPosition((wxPoint const &)*arg2);
26392 wxPyEndAllowThreads(__tstate);
26393 if (PyErr_Occurred()) SWIG_fail;
26394 }
26395 resultobj = SWIG_Py_Void();
26396 return resultobj;
26397 fail:
26398 return NULL;
26399 }
26400
26401
26402 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26403 PyObject *obj;
26404 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26405 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26406 return SWIG_Py_Void();
26407 }
26408
26409 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26410 return SWIG_Python_InitShadowInstance(args);
26411 }
26412
26413 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26414 PyObject *resultobj = 0;
26415 int arg1 = (int) 0 ;
26416 wxPaintEvent *result = 0 ;
26417 int val1 ;
26418 int ecode1 = 0 ;
26419 PyObject * obj0 = 0 ;
26420 char * kwnames[] = {
26421 (char *) "Id", NULL
26422 };
26423
26424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26425 if (obj0) {
26426 ecode1 = SWIG_AsVal_int(obj0, &val1);
26427 if (!SWIG_IsOK(ecode1)) {
26428 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26429 }
26430 arg1 = static_cast< int >(val1);
26431 }
26432 {
26433 PyThreadState* __tstate = wxPyBeginAllowThreads();
26434 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26435 wxPyEndAllowThreads(__tstate);
26436 if (PyErr_Occurred()) SWIG_fail;
26437 }
26438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26439 return resultobj;
26440 fail:
26441 return NULL;
26442 }
26443
26444
26445 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26446 PyObject *obj;
26447 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26448 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26449 return SWIG_Py_Void();
26450 }
26451
26452 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26453 return SWIG_Python_InitShadowInstance(args);
26454 }
26455
26456 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26457 PyObject *resultobj = 0;
26458 int arg1 = (int) 0 ;
26459 wxNcPaintEvent *result = 0 ;
26460 int val1 ;
26461 int ecode1 = 0 ;
26462 PyObject * obj0 = 0 ;
26463 char * kwnames[] = {
26464 (char *) "winid", NULL
26465 };
26466
26467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26468 if (obj0) {
26469 ecode1 = SWIG_AsVal_int(obj0, &val1);
26470 if (!SWIG_IsOK(ecode1)) {
26471 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26472 }
26473 arg1 = static_cast< int >(val1);
26474 }
26475 {
26476 PyThreadState* __tstate = wxPyBeginAllowThreads();
26477 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26478 wxPyEndAllowThreads(__tstate);
26479 if (PyErr_Occurred()) SWIG_fail;
26480 }
26481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26482 return resultobj;
26483 fail:
26484 return NULL;
26485 }
26486
26487
26488 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26489 PyObject *obj;
26490 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26491 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26492 return SWIG_Py_Void();
26493 }
26494
26495 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26496 return SWIG_Python_InitShadowInstance(args);
26497 }
26498
26499 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26500 PyObject *resultobj = 0;
26501 int arg1 = (int) 0 ;
26502 wxDC *arg2 = (wxDC *) NULL ;
26503 wxEraseEvent *result = 0 ;
26504 int val1 ;
26505 int ecode1 = 0 ;
26506 void *argp2 = 0 ;
26507 int res2 = 0 ;
26508 PyObject * obj0 = 0 ;
26509 PyObject * obj1 = 0 ;
26510 char * kwnames[] = {
26511 (char *) "Id",(char *) "dc", NULL
26512 };
26513
26514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26515 if (obj0) {
26516 ecode1 = SWIG_AsVal_int(obj0, &val1);
26517 if (!SWIG_IsOK(ecode1)) {
26518 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26519 }
26520 arg1 = static_cast< int >(val1);
26521 }
26522 if (obj1) {
26523 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26524 if (!SWIG_IsOK(res2)) {
26525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26526 }
26527 arg2 = reinterpret_cast< wxDC * >(argp2);
26528 }
26529 {
26530 PyThreadState* __tstate = wxPyBeginAllowThreads();
26531 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26532 wxPyEndAllowThreads(__tstate);
26533 if (PyErr_Occurred()) SWIG_fail;
26534 }
26535 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26536 return resultobj;
26537 fail:
26538 return NULL;
26539 }
26540
26541
26542 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26543 PyObject *resultobj = 0;
26544 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26545 wxDC *result = 0 ;
26546 void *argp1 = 0 ;
26547 int res1 = 0 ;
26548 PyObject *swig_obj[1] ;
26549
26550 if (!args) SWIG_fail;
26551 swig_obj[0] = args;
26552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26553 if (!SWIG_IsOK(res1)) {
26554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26555 }
26556 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26557 {
26558 PyThreadState* __tstate = wxPyBeginAllowThreads();
26559 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26560 wxPyEndAllowThreads(__tstate);
26561 if (PyErr_Occurred()) SWIG_fail;
26562 }
26563 {
26564 resultobj = wxPyMake_wxObject(result, (bool)0);
26565 }
26566 return resultobj;
26567 fail:
26568 return NULL;
26569 }
26570
26571
26572 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26573 PyObject *obj;
26574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26575 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26576 return SWIG_Py_Void();
26577 }
26578
26579 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26580 return SWIG_Python_InitShadowInstance(args);
26581 }
26582
26583 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26584 PyObject *resultobj = 0;
26585 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26586 int arg2 = (int) 0 ;
26587 wxFocusEvent *result = 0 ;
26588 int val1 ;
26589 int ecode1 = 0 ;
26590 int val2 ;
26591 int ecode2 = 0 ;
26592 PyObject * obj0 = 0 ;
26593 PyObject * obj1 = 0 ;
26594 char * kwnames[] = {
26595 (char *) "type",(char *) "winid", NULL
26596 };
26597
26598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26599 if (obj0) {
26600 ecode1 = SWIG_AsVal_int(obj0, &val1);
26601 if (!SWIG_IsOK(ecode1)) {
26602 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26603 }
26604 arg1 = static_cast< wxEventType >(val1);
26605 }
26606 if (obj1) {
26607 ecode2 = SWIG_AsVal_int(obj1, &val2);
26608 if (!SWIG_IsOK(ecode2)) {
26609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26610 }
26611 arg2 = static_cast< int >(val2);
26612 }
26613 {
26614 PyThreadState* __tstate = wxPyBeginAllowThreads();
26615 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26616 wxPyEndAllowThreads(__tstate);
26617 if (PyErr_Occurred()) SWIG_fail;
26618 }
26619 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26620 return resultobj;
26621 fail:
26622 return NULL;
26623 }
26624
26625
26626 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26627 PyObject *resultobj = 0;
26628 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26629 wxWindow *result = 0 ;
26630 void *argp1 = 0 ;
26631 int res1 = 0 ;
26632 PyObject *swig_obj[1] ;
26633
26634 if (!args) SWIG_fail;
26635 swig_obj[0] = args;
26636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26637 if (!SWIG_IsOK(res1)) {
26638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26639 }
26640 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26641 {
26642 PyThreadState* __tstate = wxPyBeginAllowThreads();
26643 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26644 wxPyEndAllowThreads(__tstate);
26645 if (PyErr_Occurred()) SWIG_fail;
26646 }
26647 {
26648 resultobj = wxPyMake_wxObject(result, (bool)0);
26649 }
26650 return resultobj;
26651 fail:
26652 return NULL;
26653 }
26654
26655
26656 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26657 PyObject *resultobj = 0;
26658 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26659 wxWindow *arg2 = (wxWindow *) 0 ;
26660 void *argp1 = 0 ;
26661 int res1 = 0 ;
26662 void *argp2 = 0 ;
26663 int res2 = 0 ;
26664 PyObject * obj0 = 0 ;
26665 PyObject * obj1 = 0 ;
26666 char * kwnames[] = {
26667 (char *) "self",(char *) "win", NULL
26668 };
26669
26670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26672 if (!SWIG_IsOK(res1)) {
26673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26674 }
26675 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26676 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26677 if (!SWIG_IsOK(res2)) {
26678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26679 }
26680 arg2 = reinterpret_cast< wxWindow * >(argp2);
26681 {
26682 PyThreadState* __tstate = wxPyBeginAllowThreads();
26683 (arg1)->SetWindow(arg2);
26684 wxPyEndAllowThreads(__tstate);
26685 if (PyErr_Occurred()) SWIG_fail;
26686 }
26687 resultobj = SWIG_Py_Void();
26688 return resultobj;
26689 fail:
26690 return NULL;
26691 }
26692
26693
26694 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26695 PyObject *obj;
26696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26697 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26698 return SWIG_Py_Void();
26699 }
26700
26701 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26702 return SWIG_Python_InitShadowInstance(args);
26703 }
26704
26705 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26706 PyObject *resultobj = 0;
26707 wxWindow *arg1 = (wxWindow *) NULL ;
26708 wxChildFocusEvent *result = 0 ;
26709 void *argp1 = 0 ;
26710 int res1 = 0 ;
26711 PyObject * obj0 = 0 ;
26712 char * kwnames[] = {
26713 (char *) "win", NULL
26714 };
26715
26716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26717 if (obj0) {
26718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26719 if (!SWIG_IsOK(res1)) {
26720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26721 }
26722 arg1 = reinterpret_cast< wxWindow * >(argp1);
26723 }
26724 {
26725 PyThreadState* __tstate = wxPyBeginAllowThreads();
26726 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26727 wxPyEndAllowThreads(__tstate);
26728 if (PyErr_Occurred()) SWIG_fail;
26729 }
26730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26731 return resultobj;
26732 fail:
26733 return NULL;
26734 }
26735
26736
26737 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26738 PyObject *resultobj = 0;
26739 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26740 wxWindow *result = 0 ;
26741 void *argp1 = 0 ;
26742 int res1 = 0 ;
26743 PyObject *swig_obj[1] ;
26744
26745 if (!args) SWIG_fail;
26746 swig_obj[0] = args;
26747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26748 if (!SWIG_IsOK(res1)) {
26749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26750 }
26751 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26752 {
26753 PyThreadState* __tstate = wxPyBeginAllowThreads();
26754 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26755 wxPyEndAllowThreads(__tstate);
26756 if (PyErr_Occurred()) SWIG_fail;
26757 }
26758 {
26759 resultobj = wxPyMake_wxObject(result, (bool)0);
26760 }
26761 return resultobj;
26762 fail:
26763 return NULL;
26764 }
26765
26766
26767 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26768 PyObject *obj;
26769 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26770 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26771 return SWIG_Py_Void();
26772 }
26773
26774 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26775 return SWIG_Python_InitShadowInstance(args);
26776 }
26777
26778 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26779 PyObject *resultobj = 0;
26780 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26781 bool arg2 = (bool) true ;
26782 int arg3 = (int) 0 ;
26783 wxActivateEvent *result = 0 ;
26784 int val1 ;
26785 int ecode1 = 0 ;
26786 bool val2 ;
26787 int ecode2 = 0 ;
26788 int val3 ;
26789 int ecode3 = 0 ;
26790 PyObject * obj0 = 0 ;
26791 PyObject * obj1 = 0 ;
26792 PyObject * obj2 = 0 ;
26793 char * kwnames[] = {
26794 (char *) "type",(char *) "active",(char *) "Id", NULL
26795 };
26796
26797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26798 if (obj0) {
26799 ecode1 = SWIG_AsVal_int(obj0, &val1);
26800 if (!SWIG_IsOK(ecode1)) {
26801 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26802 }
26803 arg1 = static_cast< wxEventType >(val1);
26804 }
26805 if (obj1) {
26806 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26807 if (!SWIG_IsOK(ecode2)) {
26808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26809 }
26810 arg2 = static_cast< bool >(val2);
26811 }
26812 if (obj2) {
26813 ecode3 = SWIG_AsVal_int(obj2, &val3);
26814 if (!SWIG_IsOK(ecode3)) {
26815 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26816 }
26817 arg3 = static_cast< int >(val3);
26818 }
26819 {
26820 PyThreadState* __tstate = wxPyBeginAllowThreads();
26821 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26822 wxPyEndAllowThreads(__tstate);
26823 if (PyErr_Occurred()) SWIG_fail;
26824 }
26825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26826 return resultobj;
26827 fail:
26828 return NULL;
26829 }
26830
26831
26832 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26833 PyObject *resultobj = 0;
26834 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26835 bool result;
26836 void *argp1 = 0 ;
26837 int res1 = 0 ;
26838 PyObject *swig_obj[1] ;
26839
26840 if (!args) SWIG_fail;
26841 swig_obj[0] = args;
26842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26843 if (!SWIG_IsOK(res1)) {
26844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26845 }
26846 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26847 {
26848 PyThreadState* __tstate = wxPyBeginAllowThreads();
26849 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26850 wxPyEndAllowThreads(__tstate);
26851 if (PyErr_Occurred()) SWIG_fail;
26852 }
26853 {
26854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26855 }
26856 return resultobj;
26857 fail:
26858 return NULL;
26859 }
26860
26861
26862 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26863 PyObject *obj;
26864 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26865 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26866 return SWIG_Py_Void();
26867 }
26868
26869 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26870 return SWIG_Python_InitShadowInstance(args);
26871 }
26872
26873 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26874 PyObject *resultobj = 0;
26875 int arg1 = (int) 0 ;
26876 wxInitDialogEvent *result = 0 ;
26877 int val1 ;
26878 int ecode1 = 0 ;
26879 PyObject * obj0 = 0 ;
26880 char * kwnames[] = {
26881 (char *) "Id", NULL
26882 };
26883
26884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26885 if (obj0) {
26886 ecode1 = SWIG_AsVal_int(obj0, &val1);
26887 if (!SWIG_IsOK(ecode1)) {
26888 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26889 }
26890 arg1 = static_cast< int >(val1);
26891 }
26892 {
26893 PyThreadState* __tstate = wxPyBeginAllowThreads();
26894 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26895 wxPyEndAllowThreads(__tstate);
26896 if (PyErr_Occurred()) SWIG_fail;
26897 }
26898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26899 return resultobj;
26900 fail:
26901 return NULL;
26902 }
26903
26904
26905 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26906 PyObject *obj;
26907 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26908 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26909 return SWIG_Py_Void();
26910 }
26911
26912 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26913 return SWIG_Python_InitShadowInstance(args);
26914 }
26915
26916 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26917 PyObject *resultobj = 0;
26918 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26919 int arg2 = (int) 0 ;
26920 wxMenu *arg3 = (wxMenu *) NULL ;
26921 wxMenuEvent *result = 0 ;
26922 int val1 ;
26923 int ecode1 = 0 ;
26924 int val2 ;
26925 int ecode2 = 0 ;
26926 void *argp3 = 0 ;
26927 int res3 = 0 ;
26928 PyObject * obj0 = 0 ;
26929 PyObject * obj1 = 0 ;
26930 PyObject * obj2 = 0 ;
26931 char * kwnames[] = {
26932 (char *) "type",(char *) "winid",(char *) "menu", NULL
26933 };
26934
26935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26936 if (obj0) {
26937 ecode1 = SWIG_AsVal_int(obj0, &val1);
26938 if (!SWIG_IsOK(ecode1)) {
26939 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26940 }
26941 arg1 = static_cast< wxEventType >(val1);
26942 }
26943 if (obj1) {
26944 ecode2 = SWIG_AsVal_int(obj1, &val2);
26945 if (!SWIG_IsOK(ecode2)) {
26946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
26947 }
26948 arg2 = static_cast< int >(val2);
26949 }
26950 if (obj2) {
26951 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
26952 if (!SWIG_IsOK(res3)) {
26953 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
26954 }
26955 arg3 = reinterpret_cast< wxMenu * >(argp3);
26956 }
26957 {
26958 PyThreadState* __tstate = wxPyBeginAllowThreads();
26959 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
26960 wxPyEndAllowThreads(__tstate);
26961 if (PyErr_Occurred()) SWIG_fail;
26962 }
26963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
26964 return resultobj;
26965 fail:
26966 return NULL;
26967 }
26968
26969
26970 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26971 PyObject *resultobj = 0;
26972 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26973 int result;
26974 void *argp1 = 0 ;
26975 int res1 = 0 ;
26976 PyObject *swig_obj[1] ;
26977
26978 if (!args) SWIG_fail;
26979 swig_obj[0] = args;
26980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26981 if (!SWIG_IsOK(res1)) {
26982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26983 }
26984 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
26985 {
26986 PyThreadState* __tstate = wxPyBeginAllowThreads();
26987 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
26988 wxPyEndAllowThreads(__tstate);
26989 if (PyErr_Occurred()) SWIG_fail;
26990 }
26991 resultobj = SWIG_From_int(static_cast< int >(result));
26992 return resultobj;
26993 fail:
26994 return NULL;
26995 }
26996
26997
26998 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26999 PyObject *resultobj = 0;
27000 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27001 bool result;
27002 void *argp1 = 0 ;
27003 int res1 = 0 ;
27004 PyObject *swig_obj[1] ;
27005
27006 if (!args) SWIG_fail;
27007 swig_obj[0] = args;
27008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27009 if (!SWIG_IsOK(res1)) {
27010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27011 }
27012 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27013 {
27014 PyThreadState* __tstate = wxPyBeginAllowThreads();
27015 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
27016 wxPyEndAllowThreads(__tstate);
27017 if (PyErr_Occurred()) SWIG_fail;
27018 }
27019 {
27020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27021 }
27022 return resultobj;
27023 fail:
27024 return NULL;
27025 }
27026
27027
27028 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27029 PyObject *resultobj = 0;
27030 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27031 wxMenu *result = 0 ;
27032 void *argp1 = 0 ;
27033 int res1 = 0 ;
27034 PyObject *swig_obj[1] ;
27035
27036 if (!args) SWIG_fail;
27037 swig_obj[0] = args;
27038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27039 if (!SWIG_IsOK(res1)) {
27040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27041 }
27042 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27043 {
27044 PyThreadState* __tstate = wxPyBeginAllowThreads();
27045 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27046 wxPyEndAllowThreads(__tstate);
27047 if (PyErr_Occurred()) SWIG_fail;
27048 }
27049 {
27050 resultobj = wxPyMake_wxObject(result, (bool)0);
27051 }
27052 return resultobj;
27053 fail:
27054 return NULL;
27055 }
27056
27057
27058 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27059 PyObject *obj;
27060 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27061 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27062 return SWIG_Py_Void();
27063 }
27064
27065 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27066 return SWIG_Python_InitShadowInstance(args);
27067 }
27068
27069 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27070 PyObject *resultobj = 0;
27071 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27072 int arg2 = (int) 0 ;
27073 wxCloseEvent *result = 0 ;
27074 int val1 ;
27075 int ecode1 = 0 ;
27076 int val2 ;
27077 int ecode2 = 0 ;
27078 PyObject * obj0 = 0 ;
27079 PyObject * obj1 = 0 ;
27080 char * kwnames[] = {
27081 (char *) "type",(char *) "winid", NULL
27082 };
27083
27084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27085 if (obj0) {
27086 ecode1 = SWIG_AsVal_int(obj0, &val1);
27087 if (!SWIG_IsOK(ecode1)) {
27088 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27089 }
27090 arg1 = static_cast< wxEventType >(val1);
27091 }
27092 if (obj1) {
27093 ecode2 = SWIG_AsVal_int(obj1, &val2);
27094 if (!SWIG_IsOK(ecode2)) {
27095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27096 }
27097 arg2 = static_cast< int >(val2);
27098 }
27099 {
27100 PyThreadState* __tstate = wxPyBeginAllowThreads();
27101 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27102 wxPyEndAllowThreads(__tstate);
27103 if (PyErr_Occurred()) SWIG_fail;
27104 }
27105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27106 return resultobj;
27107 fail:
27108 return NULL;
27109 }
27110
27111
27112 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27113 PyObject *resultobj = 0;
27114 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27115 bool arg2 ;
27116 void *argp1 = 0 ;
27117 int res1 = 0 ;
27118 bool val2 ;
27119 int ecode2 = 0 ;
27120 PyObject * obj0 = 0 ;
27121 PyObject * obj1 = 0 ;
27122 char * kwnames[] = {
27123 (char *) "self",(char *) "logOff", NULL
27124 };
27125
27126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27128 if (!SWIG_IsOK(res1)) {
27129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27130 }
27131 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27132 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27133 if (!SWIG_IsOK(ecode2)) {
27134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27135 }
27136 arg2 = static_cast< bool >(val2);
27137 {
27138 PyThreadState* __tstate = wxPyBeginAllowThreads();
27139 (arg1)->SetLoggingOff(arg2);
27140 wxPyEndAllowThreads(__tstate);
27141 if (PyErr_Occurred()) SWIG_fail;
27142 }
27143 resultobj = SWIG_Py_Void();
27144 return resultobj;
27145 fail:
27146 return NULL;
27147 }
27148
27149
27150 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27151 PyObject *resultobj = 0;
27152 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27153 bool result;
27154 void *argp1 = 0 ;
27155 int res1 = 0 ;
27156 PyObject *swig_obj[1] ;
27157
27158 if (!args) SWIG_fail;
27159 swig_obj[0] = args;
27160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27161 if (!SWIG_IsOK(res1)) {
27162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27163 }
27164 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27165 {
27166 PyThreadState* __tstate = wxPyBeginAllowThreads();
27167 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27168 wxPyEndAllowThreads(__tstate);
27169 if (PyErr_Occurred()) SWIG_fail;
27170 }
27171 {
27172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27173 }
27174 return resultobj;
27175 fail:
27176 return NULL;
27177 }
27178
27179
27180 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27181 PyObject *resultobj = 0;
27182 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27183 bool arg2 = (bool) true ;
27184 void *argp1 = 0 ;
27185 int res1 = 0 ;
27186 bool val2 ;
27187 int ecode2 = 0 ;
27188 PyObject * obj0 = 0 ;
27189 PyObject * obj1 = 0 ;
27190 char * kwnames[] = {
27191 (char *) "self",(char *) "veto", NULL
27192 };
27193
27194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27196 if (!SWIG_IsOK(res1)) {
27197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27198 }
27199 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27200 if (obj1) {
27201 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27202 if (!SWIG_IsOK(ecode2)) {
27203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27204 }
27205 arg2 = static_cast< bool >(val2);
27206 }
27207 {
27208 PyThreadState* __tstate = wxPyBeginAllowThreads();
27209 (arg1)->Veto(arg2);
27210 wxPyEndAllowThreads(__tstate);
27211 if (PyErr_Occurred()) SWIG_fail;
27212 }
27213 resultobj = SWIG_Py_Void();
27214 return resultobj;
27215 fail:
27216 return NULL;
27217 }
27218
27219
27220 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27221 PyObject *resultobj = 0;
27222 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27223 bool result;
27224 void *argp1 = 0 ;
27225 int res1 = 0 ;
27226 PyObject *swig_obj[1] ;
27227
27228 if (!args) SWIG_fail;
27229 swig_obj[0] = args;
27230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27231 if (!SWIG_IsOK(res1)) {
27232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27233 }
27234 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27235 {
27236 PyThreadState* __tstate = wxPyBeginAllowThreads();
27237 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27238 wxPyEndAllowThreads(__tstate);
27239 if (PyErr_Occurred()) SWIG_fail;
27240 }
27241 {
27242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27243 }
27244 return resultobj;
27245 fail:
27246 return NULL;
27247 }
27248
27249
27250 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27251 PyObject *resultobj = 0;
27252 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27253 bool arg2 ;
27254 void *argp1 = 0 ;
27255 int res1 = 0 ;
27256 bool val2 ;
27257 int ecode2 = 0 ;
27258 PyObject * obj0 = 0 ;
27259 PyObject * obj1 = 0 ;
27260 char * kwnames[] = {
27261 (char *) "self",(char *) "canVeto", NULL
27262 };
27263
27264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27266 if (!SWIG_IsOK(res1)) {
27267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27268 }
27269 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27270 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27271 if (!SWIG_IsOK(ecode2)) {
27272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27273 }
27274 arg2 = static_cast< bool >(val2);
27275 {
27276 PyThreadState* __tstate = wxPyBeginAllowThreads();
27277 (arg1)->SetCanVeto(arg2);
27278 wxPyEndAllowThreads(__tstate);
27279 if (PyErr_Occurred()) SWIG_fail;
27280 }
27281 resultobj = SWIG_Py_Void();
27282 return resultobj;
27283 fail:
27284 return NULL;
27285 }
27286
27287
27288 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27289 PyObject *resultobj = 0;
27290 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27291 bool result;
27292 void *argp1 = 0 ;
27293 int res1 = 0 ;
27294 PyObject *swig_obj[1] ;
27295
27296 if (!args) SWIG_fail;
27297 swig_obj[0] = args;
27298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27299 if (!SWIG_IsOK(res1)) {
27300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27301 }
27302 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27303 {
27304 PyThreadState* __tstate = wxPyBeginAllowThreads();
27305 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27306 wxPyEndAllowThreads(__tstate);
27307 if (PyErr_Occurred()) SWIG_fail;
27308 }
27309 {
27310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27311 }
27312 return resultobj;
27313 fail:
27314 return NULL;
27315 }
27316
27317
27318 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27319 PyObject *obj;
27320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27321 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27322 return SWIG_Py_Void();
27323 }
27324
27325 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27326 return SWIG_Python_InitShadowInstance(args);
27327 }
27328
27329 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27330 PyObject *resultobj = 0;
27331 int arg1 = (int) 0 ;
27332 bool arg2 = (bool) false ;
27333 wxShowEvent *result = 0 ;
27334 int val1 ;
27335 int ecode1 = 0 ;
27336 bool val2 ;
27337 int ecode2 = 0 ;
27338 PyObject * obj0 = 0 ;
27339 PyObject * obj1 = 0 ;
27340 char * kwnames[] = {
27341 (char *) "winid",(char *) "show", NULL
27342 };
27343
27344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27345 if (obj0) {
27346 ecode1 = SWIG_AsVal_int(obj0, &val1);
27347 if (!SWIG_IsOK(ecode1)) {
27348 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27349 }
27350 arg1 = static_cast< int >(val1);
27351 }
27352 if (obj1) {
27353 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27354 if (!SWIG_IsOK(ecode2)) {
27355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27356 }
27357 arg2 = static_cast< bool >(val2);
27358 }
27359 {
27360 PyThreadState* __tstate = wxPyBeginAllowThreads();
27361 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27362 wxPyEndAllowThreads(__tstate);
27363 if (PyErr_Occurred()) SWIG_fail;
27364 }
27365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27366 return resultobj;
27367 fail:
27368 return NULL;
27369 }
27370
27371
27372 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27373 PyObject *resultobj = 0;
27374 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27375 bool arg2 ;
27376 void *argp1 = 0 ;
27377 int res1 = 0 ;
27378 bool val2 ;
27379 int ecode2 = 0 ;
27380 PyObject * obj0 = 0 ;
27381 PyObject * obj1 = 0 ;
27382 char * kwnames[] = {
27383 (char *) "self",(char *) "show", NULL
27384 };
27385
27386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27388 if (!SWIG_IsOK(res1)) {
27389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27390 }
27391 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27392 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27393 if (!SWIG_IsOK(ecode2)) {
27394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27395 }
27396 arg2 = static_cast< bool >(val2);
27397 {
27398 PyThreadState* __tstate = wxPyBeginAllowThreads();
27399 (arg1)->SetShow(arg2);
27400 wxPyEndAllowThreads(__tstate);
27401 if (PyErr_Occurred()) SWIG_fail;
27402 }
27403 resultobj = SWIG_Py_Void();
27404 return resultobj;
27405 fail:
27406 return NULL;
27407 }
27408
27409
27410 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27411 PyObject *resultobj = 0;
27412 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27413 bool result;
27414 void *argp1 = 0 ;
27415 int res1 = 0 ;
27416 PyObject *swig_obj[1] ;
27417
27418 if (!args) SWIG_fail;
27419 swig_obj[0] = args;
27420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27421 if (!SWIG_IsOK(res1)) {
27422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27423 }
27424 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27425 {
27426 PyThreadState* __tstate = wxPyBeginAllowThreads();
27427 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27428 wxPyEndAllowThreads(__tstate);
27429 if (PyErr_Occurred()) SWIG_fail;
27430 }
27431 {
27432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27433 }
27434 return resultobj;
27435 fail:
27436 return NULL;
27437 }
27438
27439
27440 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27441 PyObject *obj;
27442 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27443 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27444 return SWIG_Py_Void();
27445 }
27446
27447 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27448 return SWIG_Python_InitShadowInstance(args);
27449 }
27450
27451 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27452 PyObject *resultobj = 0;
27453 int arg1 = (int) 0 ;
27454 bool arg2 = (bool) true ;
27455 wxIconizeEvent *result = 0 ;
27456 int val1 ;
27457 int ecode1 = 0 ;
27458 bool val2 ;
27459 int ecode2 = 0 ;
27460 PyObject * obj0 = 0 ;
27461 PyObject * obj1 = 0 ;
27462 char * kwnames[] = {
27463 (char *) "id",(char *) "iconized", NULL
27464 };
27465
27466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27467 if (obj0) {
27468 ecode1 = SWIG_AsVal_int(obj0, &val1);
27469 if (!SWIG_IsOK(ecode1)) {
27470 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27471 }
27472 arg1 = static_cast< int >(val1);
27473 }
27474 if (obj1) {
27475 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27476 if (!SWIG_IsOK(ecode2)) {
27477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27478 }
27479 arg2 = static_cast< bool >(val2);
27480 }
27481 {
27482 PyThreadState* __tstate = wxPyBeginAllowThreads();
27483 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27484 wxPyEndAllowThreads(__tstate);
27485 if (PyErr_Occurred()) SWIG_fail;
27486 }
27487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27488 return resultobj;
27489 fail:
27490 return NULL;
27491 }
27492
27493
27494 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27495 PyObject *resultobj = 0;
27496 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27497 bool result;
27498 void *argp1 = 0 ;
27499 int res1 = 0 ;
27500 PyObject *swig_obj[1] ;
27501
27502 if (!args) SWIG_fail;
27503 swig_obj[0] = args;
27504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27505 if (!SWIG_IsOK(res1)) {
27506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27507 }
27508 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27509 {
27510 PyThreadState* __tstate = wxPyBeginAllowThreads();
27511 result = (bool)(arg1)->Iconized();
27512 wxPyEndAllowThreads(__tstate);
27513 if (PyErr_Occurred()) SWIG_fail;
27514 }
27515 {
27516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27517 }
27518 return resultobj;
27519 fail:
27520 return NULL;
27521 }
27522
27523
27524 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27525 PyObject *obj;
27526 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27527 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27528 return SWIG_Py_Void();
27529 }
27530
27531 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27532 return SWIG_Python_InitShadowInstance(args);
27533 }
27534
27535 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27536 PyObject *resultobj = 0;
27537 int arg1 = (int) 0 ;
27538 wxMaximizeEvent *result = 0 ;
27539 int val1 ;
27540 int ecode1 = 0 ;
27541 PyObject * obj0 = 0 ;
27542 char * kwnames[] = {
27543 (char *) "id", NULL
27544 };
27545
27546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27547 if (obj0) {
27548 ecode1 = SWIG_AsVal_int(obj0, &val1);
27549 if (!SWIG_IsOK(ecode1)) {
27550 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27551 }
27552 arg1 = static_cast< int >(val1);
27553 }
27554 {
27555 PyThreadState* __tstate = wxPyBeginAllowThreads();
27556 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27557 wxPyEndAllowThreads(__tstate);
27558 if (PyErr_Occurred()) SWIG_fail;
27559 }
27560 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27561 return resultobj;
27562 fail:
27563 return NULL;
27564 }
27565
27566
27567 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27568 PyObject *obj;
27569 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27570 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27571 return SWIG_Py_Void();
27572 }
27573
27574 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27575 return SWIG_Python_InitShadowInstance(args);
27576 }
27577
27578 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27579 PyObject *resultobj = 0;
27580 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27581 wxPoint result;
27582 void *argp1 = 0 ;
27583 int res1 = 0 ;
27584 PyObject *swig_obj[1] ;
27585
27586 if (!args) SWIG_fail;
27587 swig_obj[0] = args;
27588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27589 if (!SWIG_IsOK(res1)) {
27590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27591 }
27592 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27593 {
27594 PyThreadState* __tstate = wxPyBeginAllowThreads();
27595 result = (arg1)->GetPosition();
27596 wxPyEndAllowThreads(__tstate);
27597 if (PyErr_Occurred()) SWIG_fail;
27598 }
27599 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27600 return resultobj;
27601 fail:
27602 return NULL;
27603 }
27604
27605
27606 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27607 PyObject *resultobj = 0;
27608 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27609 int result;
27610 void *argp1 = 0 ;
27611 int res1 = 0 ;
27612 PyObject *swig_obj[1] ;
27613
27614 if (!args) SWIG_fail;
27615 swig_obj[0] = args;
27616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27617 if (!SWIG_IsOK(res1)) {
27618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27619 }
27620 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27621 {
27622 PyThreadState* __tstate = wxPyBeginAllowThreads();
27623 result = (int)(arg1)->GetNumberOfFiles();
27624 wxPyEndAllowThreads(__tstate);
27625 if (PyErr_Occurred()) SWIG_fail;
27626 }
27627 resultobj = SWIG_From_int(static_cast< int >(result));
27628 return resultobj;
27629 fail:
27630 return NULL;
27631 }
27632
27633
27634 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27635 PyObject *resultobj = 0;
27636 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27637 PyObject *result = 0 ;
27638 void *argp1 = 0 ;
27639 int res1 = 0 ;
27640 PyObject *swig_obj[1] ;
27641
27642 if (!args) SWIG_fail;
27643 swig_obj[0] = args;
27644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27645 if (!SWIG_IsOK(res1)) {
27646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27647 }
27648 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27649 {
27650 PyThreadState* __tstate = wxPyBeginAllowThreads();
27651 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27652 wxPyEndAllowThreads(__tstate);
27653 if (PyErr_Occurred()) SWIG_fail;
27654 }
27655 resultobj = result;
27656 return resultobj;
27657 fail:
27658 return NULL;
27659 }
27660
27661
27662 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27663 PyObject *obj;
27664 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27665 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27666 return SWIG_Py_Void();
27667 }
27668
27669 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27670 PyObject *resultobj = 0;
27671 int arg1 = (int) 0 ;
27672 wxUpdateUIEvent *result = 0 ;
27673 int val1 ;
27674 int ecode1 = 0 ;
27675 PyObject * obj0 = 0 ;
27676 char * kwnames[] = {
27677 (char *) "commandId", NULL
27678 };
27679
27680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27681 if (obj0) {
27682 ecode1 = SWIG_AsVal_int(obj0, &val1);
27683 if (!SWIG_IsOK(ecode1)) {
27684 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27685 }
27686 arg1 = static_cast< int >(val1);
27687 }
27688 {
27689 PyThreadState* __tstate = wxPyBeginAllowThreads();
27690 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27691 wxPyEndAllowThreads(__tstate);
27692 if (PyErr_Occurred()) SWIG_fail;
27693 }
27694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27695 return resultobj;
27696 fail:
27697 return NULL;
27698 }
27699
27700
27701 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27702 PyObject *resultobj = 0;
27703 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27704 bool result;
27705 void *argp1 = 0 ;
27706 int res1 = 0 ;
27707 PyObject *swig_obj[1] ;
27708
27709 if (!args) SWIG_fail;
27710 swig_obj[0] = args;
27711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27712 if (!SWIG_IsOK(res1)) {
27713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27714 }
27715 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27716 {
27717 PyThreadState* __tstate = wxPyBeginAllowThreads();
27718 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27719 wxPyEndAllowThreads(__tstate);
27720 if (PyErr_Occurred()) SWIG_fail;
27721 }
27722 {
27723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27724 }
27725 return resultobj;
27726 fail:
27727 return NULL;
27728 }
27729
27730
27731 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27732 PyObject *resultobj = 0;
27733 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27734 bool result;
27735 void *argp1 = 0 ;
27736 int res1 = 0 ;
27737 PyObject *swig_obj[1] ;
27738
27739 if (!args) SWIG_fail;
27740 swig_obj[0] = args;
27741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27742 if (!SWIG_IsOK(res1)) {
27743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27744 }
27745 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27746 {
27747 PyThreadState* __tstate = wxPyBeginAllowThreads();
27748 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27749 wxPyEndAllowThreads(__tstate);
27750 if (PyErr_Occurred()) SWIG_fail;
27751 }
27752 {
27753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27754 }
27755 return resultobj;
27756 fail:
27757 return NULL;
27758 }
27759
27760
27761 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27762 PyObject *resultobj = 0;
27763 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27764 bool result;
27765 void *argp1 = 0 ;
27766 int res1 = 0 ;
27767 PyObject *swig_obj[1] ;
27768
27769 if (!args) SWIG_fail;
27770 swig_obj[0] = args;
27771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27772 if (!SWIG_IsOK(res1)) {
27773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27774 }
27775 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27776 {
27777 PyThreadState* __tstate = wxPyBeginAllowThreads();
27778 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27779 wxPyEndAllowThreads(__tstate);
27780 if (PyErr_Occurred()) SWIG_fail;
27781 }
27782 {
27783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27784 }
27785 return resultobj;
27786 fail:
27787 return NULL;
27788 }
27789
27790
27791 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27792 PyObject *resultobj = 0;
27793 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27794 wxString result;
27795 void *argp1 = 0 ;
27796 int res1 = 0 ;
27797 PyObject *swig_obj[1] ;
27798
27799 if (!args) SWIG_fail;
27800 swig_obj[0] = args;
27801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27802 if (!SWIG_IsOK(res1)) {
27803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27804 }
27805 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27806 {
27807 PyThreadState* __tstate = wxPyBeginAllowThreads();
27808 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27809 wxPyEndAllowThreads(__tstate);
27810 if (PyErr_Occurred()) SWIG_fail;
27811 }
27812 {
27813 #if wxUSE_UNICODE
27814 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27815 #else
27816 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27817 #endif
27818 }
27819 return resultobj;
27820 fail:
27821 return NULL;
27822 }
27823
27824
27825 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27826 PyObject *resultobj = 0;
27827 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27828 bool result;
27829 void *argp1 = 0 ;
27830 int res1 = 0 ;
27831 PyObject *swig_obj[1] ;
27832
27833 if (!args) SWIG_fail;
27834 swig_obj[0] = args;
27835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27836 if (!SWIG_IsOK(res1)) {
27837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27838 }
27839 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27840 {
27841 PyThreadState* __tstate = wxPyBeginAllowThreads();
27842 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27843 wxPyEndAllowThreads(__tstate);
27844 if (PyErr_Occurred()) SWIG_fail;
27845 }
27846 {
27847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27848 }
27849 return resultobj;
27850 fail:
27851 return NULL;
27852 }
27853
27854
27855 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27856 PyObject *resultobj = 0;
27857 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27858 bool result;
27859 void *argp1 = 0 ;
27860 int res1 = 0 ;
27861 PyObject *swig_obj[1] ;
27862
27863 if (!args) SWIG_fail;
27864 swig_obj[0] = args;
27865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27866 if (!SWIG_IsOK(res1)) {
27867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27868 }
27869 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27870 {
27871 PyThreadState* __tstate = wxPyBeginAllowThreads();
27872 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27873 wxPyEndAllowThreads(__tstate);
27874 if (PyErr_Occurred()) SWIG_fail;
27875 }
27876 {
27877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27878 }
27879 return resultobj;
27880 fail:
27881 return NULL;
27882 }
27883
27884
27885 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27886 PyObject *resultobj = 0;
27887 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27888 bool result;
27889 void *argp1 = 0 ;
27890 int res1 = 0 ;
27891 PyObject *swig_obj[1] ;
27892
27893 if (!args) SWIG_fail;
27894 swig_obj[0] = args;
27895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27896 if (!SWIG_IsOK(res1)) {
27897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27898 }
27899 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27900 {
27901 PyThreadState* __tstate = wxPyBeginAllowThreads();
27902 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27903 wxPyEndAllowThreads(__tstate);
27904 if (PyErr_Occurred()) SWIG_fail;
27905 }
27906 {
27907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27908 }
27909 return resultobj;
27910 fail:
27911 return NULL;
27912 }
27913
27914
27915 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27916 PyObject *resultobj = 0;
27917 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27918 bool result;
27919 void *argp1 = 0 ;
27920 int res1 = 0 ;
27921 PyObject *swig_obj[1] ;
27922
27923 if (!args) SWIG_fail;
27924 swig_obj[0] = args;
27925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27926 if (!SWIG_IsOK(res1)) {
27927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27928 }
27929 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27930 {
27931 PyThreadState* __tstate = wxPyBeginAllowThreads();
27932 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
27933 wxPyEndAllowThreads(__tstate);
27934 if (PyErr_Occurred()) SWIG_fail;
27935 }
27936 {
27937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27938 }
27939 return resultobj;
27940 fail:
27941 return NULL;
27942 }
27943
27944
27945 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27946 PyObject *resultobj = 0;
27947 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27948 bool arg2 ;
27949 void *argp1 = 0 ;
27950 int res1 = 0 ;
27951 bool val2 ;
27952 int ecode2 = 0 ;
27953 PyObject * obj0 = 0 ;
27954 PyObject * obj1 = 0 ;
27955 char * kwnames[] = {
27956 (char *) "self",(char *) "check", NULL
27957 };
27958
27959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
27960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27961 if (!SWIG_IsOK(res1)) {
27962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27963 }
27964 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27965 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27966 if (!SWIG_IsOK(ecode2)) {
27967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
27968 }
27969 arg2 = static_cast< bool >(val2);
27970 {
27971 PyThreadState* __tstate = wxPyBeginAllowThreads();
27972 (arg1)->Check(arg2);
27973 wxPyEndAllowThreads(__tstate);
27974 if (PyErr_Occurred()) SWIG_fail;
27975 }
27976 resultobj = SWIG_Py_Void();
27977 return resultobj;
27978 fail:
27979 return NULL;
27980 }
27981
27982
27983 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27984 PyObject *resultobj = 0;
27985 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27986 bool arg2 ;
27987 void *argp1 = 0 ;
27988 int res1 = 0 ;
27989 bool val2 ;
27990 int ecode2 = 0 ;
27991 PyObject * obj0 = 0 ;
27992 PyObject * obj1 = 0 ;
27993 char * kwnames[] = {
27994 (char *) "self",(char *) "enable", NULL
27995 };
27996
27997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
27998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27999 if (!SWIG_IsOK(res1)) {
28000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28001 }
28002 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28003 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28004 if (!SWIG_IsOK(ecode2)) {
28005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
28006 }
28007 arg2 = static_cast< bool >(val2);
28008 {
28009 PyThreadState* __tstate = wxPyBeginAllowThreads();
28010 (arg1)->Enable(arg2);
28011 wxPyEndAllowThreads(__tstate);
28012 if (PyErr_Occurred()) SWIG_fail;
28013 }
28014 resultobj = SWIG_Py_Void();
28015 return resultobj;
28016 fail:
28017 return NULL;
28018 }
28019
28020
28021 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(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 *) "show", NULL
28033 };
28034
28035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",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_Show" "', 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_Show" "', expected argument " "2"" of type '" "bool""'");
28044 }
28045 arg2 = static_cast< bool >(val2);
28046 {
28047 PyThreadState* __tstate = wxPyBeginAllowThreads();
28048 (arg1)->Show(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_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28060 PyObject *resultobj = 0;
28061 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28062 wxString *arg2 = 0 ;
28063 void *argp1 = 0 ;
28064 int res1 = 0 ;
28065 bool temp2 = false ;
28066 PyObject * obj0 = 0 ;
28067 PyObject * obj1 = 0 ;
28068 char * kwnames[] = {
28069 (char *) "self",(char *) "text", NULL
28070 };
28071
28072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28074 if (!SWIG_IsOK(res1)) {
28075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28076 }
28077 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28078 {
28079 arg2 = wxString_in_helper(obj1);
28080 if (arg2 == NULL) SWIG_fail;
28081 temp2 = true;
28082 }
28083 {
28084 PyThreadState* __tstate = wxPyBeginAllowThreads();
28085 (arg1)->SetText((wxString const &)*arg2);
28086 wxPyEndAllowThreads(__tstate);
28087 if (PyErr_Occurred()) SWIG_fail;
28088 }
28089 resultobj = SWIG_Py_Void();
28090 {
28091 if (temp2)
28092 delete arg2;
28093 }
28094 return resultobj;
28095 fail:
28096 {
28097 if (temp2)
28098 delete arg2;
28099 }
28100 return NULL;
28101 }
28102
28103
28104 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28105 PyObject *resultobj = 0;
28106 long arg1 ;
28107 long val1 ;
28108 int ecode1 = 0 ;
28109 PyObject * obj0 = 0 ;
28110 char * kwnames[] = {
28111 (char *) "updateInterval", NULL
28112 };
28113
28114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28115 ecode1 = SWIG_AsVal_long(obj0, &val1);
28116 if (!SWIG_IsOK(ecode1)) {
28117 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28118 }
28119 arg1 = static_cast< long >(val1);
28120 {
28121 PyThreadState* __tstate = wxPyBeginAllowThreads();
28122 wxUpdateUIEvent::SetUpdateInterval(arg1);
28123 wxPyEndAllowThreads(__tstate);
28124 if (PyErr_Occurred()) SWIG_fail;
28125 }
28126 resultobj = SWIG_Py_Void();
28127 return resultobj;
28128 fail:
28129 return NULL;
28130 }
28131
28132
28133 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28134 PyObject *resultobj = 0;
28135 long result;
28136
28137 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28138 {
28139 PyThreadState* __tstate = wxPyBeginAllowThreads();
28140 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28141 wxPyEndAllowThreads(__tstate);
28142 if (PyErr_Occurred()) SWIG_fail;
28143 }
28144 resultobj = SWIG_From_long(static_cast< long >(result));
28145 return resultobj;
28146 fail:
28147 return NULL;
28148 }
28149
28150
28151 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28152 PyObject *resultobj = 0;
28153 wxWindow *arg1 = (wxWindow *) 0 ;
28154 bool result;
28155 void *argp1 = 0 ;
28156 int res1 = 0 ;
28157 PyObject * obj0 = 0 ;
28158 char * kwnames[] = {
28159 (char *) "win", NULL
28160 };
28161
28162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28164 if (!SWIG_IsOK(res1)) {
28165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28166 }
28167 arg1 = reinterpret_cast< wxWindow * >(argp1);
28168 {
28169 PyThreadState* __tstate = wxPyBeginAllowThreads();
28170 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28171 wxPyEndAllowThreads(__tstate);
28172 if (PyErr_Occurred()) SWIG_fail;
28173 }
28174 {
28175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28176 }
28177 return resultobj;
28178 fail:
28179 return NULL;
28180 }
28181
28182
28183 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28184 PyObject *resultobj = 0;
28185
28186 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28187 {
28188 PyThreadState* __tstate = wxPyBeginAllowThreads();
28189 wxUpdateUIEvent::ResetUpdateTime();
28190 wxPyEndAllowThreads(__tstate);
28191 if (PyErr_Occurred()) SWIG_fail;
28192 }
28193 resultobj = SWIG_Py_Void();
28194 return resultobj;
28195 fail:
28196 return NULL;
28197 }
28198
28199
28200 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28201 PyObject *resultobj = 0;
28202 wxUpdateUIMode arg1 ;
28203 int val1 ;
28204 int ecode1 = 0 ;
28205 PyObject * obj0 = 0 ;
28206 char * kwnames[] = {
28207 (char *) "mode", NULL
28208 };
28209
28210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28211 ecode1 = SWIG_AsVal_int(obj0, &val1);
28212 if (!SWIG_IsOK(ecode1)) {
28213 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28214 }
28215 arg1 = static_cast< wxUpdateUIMode >(val1);
28216 {
28217 PyThreadState* __tstate = wxPyBeginAllowThreads();
28218 wxUpdateUIEvent::SetMode(arg1);
28219 wxPyEndAllowThreads(__tstate);
28220 if (PyErr_Occurred()) SWIG_fail;
28221 }
28222 resultobj = SWIG_Py_Void();
28223 return resultobj;
28224 fail:
28225 return NULL;
28226 }
28227
28228
28229 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28230 PyObject *resultobj = 0;
28231 wxUpdateUIMode result;
28232
28233 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28234 {
28235 PyThreadState* __tstate = wxPyBeginAllowThreads();
28236 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28237 wxPyEndAllowThreads(__tstate);
28238 if (PyErr_Occurred()) SWIG_fail;
28239 }
28240 resultobj = SWIG_From_int(static_cast< int >(result));
28241 return resultobj;
28242 fail:
28243 return NULL;
28244 }
28245
28246
28247 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28248 PyObject *obj;
28249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28250 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28251 return SWIG_Py_Void();
28252 }
28253
28254 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28255 return SWIG_Python_InitShadowInstance(args);
28256 }
28257
28258 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28259 PyObject *resultobj = 0;
28260 wxSysColourChangedEvent *result = 0 ;
28261
28262 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28263 {
28264 PyThreadState* __tstate = wxPyBeginAllowThreads();
28265 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28266 wxPyEndAllowThreads(__tstate);
28267 if (PyErr_Occurred()) SWIG_fail;
28268 }
28269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28270 return resultobj;
28271 fail:
28272 return NULL;
28273 }
28274
28275
28276 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28277 PyObject *obj;
28278 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28279 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28280 return SWIG_Py_Void();
28281 }
28282
28283 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28284 return SWIG_Python_InitShadowInstance(args);
28285 }
28286
28287 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28288 PyObject *resultobj = 0;
28289 int arg1 = (int) 0 ;
28290 wxWindow *arg2 = (wxWindow *) NULL ;
28291 wxMouseCaptureChangedEvent *result = 0 ;
28292 int val1 ;
28293 int ecode1 = 0 ;
28294 void *argp2 = 0 ;
28295 int res2 = 0 ;
28296 PyObject * obj0 = 0 ;
28297 PyObject * obj1 = 0 ;
28298 char * kwnames[] = {
28299 (char *) "winid",(char *) "gainedCapture", NULL
28300 };
28301
28302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28303 if (obj0) {
28304 ecode1 = SWIG_AsVal_int(obj0, &val1);
28305 if (!SWIG_IsOK(ecode1)) {
28306 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28307 }
28308 arg1 = static_cast< int >(val1);
28309 }
28310 if (obj1) {
28311 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28312 if (!SWIG_IsOK(res2)) {
28313 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28314 }
28315 arg2 = reinterpret_cast< wxWindow * >(argp2);
28316 }
28317 {
28318 PyThreadState* __tstate = wxPyBeginAllowThreads();
28319 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28320 wxPyEndAllowThreads(__tstate);
28321 if (PyErr_Occurred()) SWIG_fail;
28322 }
28323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28324 return resultobj;
28325 fail:
28326 return NULL;
28327 }
28328
28329
28330 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28331 PyObject *resultobj = 0;
28332 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28333 wxWindow *result = 0 ;
28334 void *argp1 = 0 ;
28335 int res1 = 0 ;
28336 PyObject *swig_obj[1] ;
28337
28338 if (!args) SWIG_fail;
28339 swig_obj[0] = args;
28340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28341 if (!SWIG_IsOK(res1)) {
28342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28343 }
28344 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28345 {
28346 PyThreadState* __tstate = wxPyBeginAllowThreads();
28347 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28348 wxPyEndAllowThreads(__tstate);
28349 if (PyErr_Occurred()) SWIG_fail;
28350 }
28351 {
28352 resultobj = wxPyMake_wxObject(result, (bool)0);
28353 }
28354 return resultobj;
28355 fail:
28356 return NULL;
28357 }
28358
28359
28360 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28361 PyObject *obj;
28362 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28363 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28364 return SWIG_Py_Void();
28365 }
28366
28367 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28368 return SWIG_Python_InitShadowInstance(args);
28369 }
28370
28371 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28372 PyObject *resultobj = 0;
28373 int arg1 = (int) 0 ;
28374 wxMouseCaptureLostEvent *result = 0 ;
28375 int val1 ;
28376 int ecode1 = 0 ;
28377 PyObject * obj0 = 0 ;
28378 char * kwnames[] = {
28379 (char *) "winid", NULL
28380 };
28381
28382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28383 if (obj0) {
28384 ecode1 = SWIG_AsVal_int(obj0, &val1);
28385 if (!SWIG_IsOK(ecode1)) {
28386 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28387 }
28388 arg1 = static_cast< int >(val1);
28389 }
28390 {
28391 PyThreadState* __tstate = wxPyBeginAllowThreads();
28392 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28393 wxPyEndAllowThreads(__tstate);
28394 if (PyErr_Occurred()) SWIG_fail;
28395 }
28396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28397 return resultobj;
28398 fail:
28399 return NULL;
28400 }
28401
28402
28403 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28404 PyObject *obj;
28405 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28406 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28407 return SWIG_Py_Void();
28408 }
28409
28410 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28411 return SWIG_Python_InitShadowInstance(args);
28412 }
28413
28414 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28415 PyObject *resultobj = 0;
28416 wxDisplayChangedEvent *result = 0 ;
28417
28418 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28419 {
28420 PyThreadState* __tstate = wxPyBeginAllowThreads();
28421 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28422 wxPyEndAllowThreads(__tstate);
28423 if (PyErr_Occurred()) SWIG_fail;
28424 }
28425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28426 return resultobj;
28427 fail:
28428 return NULL;
28429 }
28430
28431
28432 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28433 PyObject *obj;
28434 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28435 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28436 return SWIG_Py_Void();
28437 }
28438
28439 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28440 return SWIG_Python_InitShadowInstance(args);
28441 }
28442
28443 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28444 PyObject *resultobj = 0;
28445 int arg1 = (int) 0 ;
28446 wxPaletteChangedEvent *result = 0 ;
28447 int val1 ;
28448 int ecode1 = 0 ;
28449 PyObject * obj0 = 0 ;
28450 char * kwnames[] = {
28451 (char *) "id", NULL
28452 };
28453
28454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28455 if (obj0) {
28456 ecode1 = SWIG_AsVal_int(obj0, &val1);
28457 if (!SWIG_IsOK(ecode1)) {
28458 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28459 }
28460 arg1 = static_cast< int >(val1);
28461 }
28462 {
28463 PyThreadState* __tstate = wxPyBeginAllowThreads();
28464 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28465 wxPyEndAllowThreads(__tstate);
28466 if (PyErr_Occurred()) SWIG_fail;
28467 }
28468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28469 return resultobj;
28470 fail:
28471 return NULL;
28472 }
28473
28474
28475 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28476 PyObject *resultobj = 0;
28477 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28478 wxWindow *arg2 = (wxWindow *) 0 ;
28479 void *argp1 = 0 ;
28480 int res1 = 0 ;
28481 void *argp2 = 0 ;
28482 int res2 = 0 ;
28483 PyObject * obj0 = 0 ;
28484 PyObject * obj1 = 0 ;
28485 char * kwnames[] = {
28486 (char *) "self",(char *) "win", NULL
28487 };
28488
28489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28491 if (!SWIG_IsOK(res1)) {
28492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28493 }
28494 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28495 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28496 if (!SWIG_IsOK(res2)) {
28497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28498 }
28499 arg2 = reinterpret_cast< wxWindow * >(argp2);
28500 {
28501 PyThreadState* __tstate = wxPyBeginAllowThreads();
28502 (arg1)->SetChangedWindow(arg2);
28503 wxPyEndAllowThreads(__tstate);
28504 if (PyErr_Occurred()) SWIG_fail;
28505 }
28506 resultobj = SWIG_Py_Void();
28507 return resultobj;
28508 fail:
28509 return NULL;
28510 }
28511
28512
28513 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28514 PyObject *resultobj = 0;
28515 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28516 wxWindow *result = 0 ;
28517 void *argp1 = 0 ;
28518 int res1 = 0 ;
28519 PyObject *swig_obj[1] ;
28520
28521 if (!args) SWIG_fail;
28522 swig_obj[0] = args;
28523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28524 if (!SWIG_IsOK(res1)) {
28525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28526 }
28527 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28528 {
28529 PyThreadState* __tstate = wxPyBeginAllowThreads();
28530 result = (wxWindow *)(arg1)->GetChangedWindow();
28531 wxPyEndAllowThreads(__tstate);
28532 if (PyErr_Occurred()) SWIG_fail;
28533 }
28534 {
28535 resultobj = wxPyMake_wxObject(result, (bool)0);
28536 }
28537 return resultobj;
28538 fail:
28539 return NULL;
28540 }
28541
28542
28543 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28544 PyObject *obj;
28545 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28546 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28547 return SWIG_Py_Void();
28548 }
28549
28550 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28551 return SWIG_Python_InitShadowInstance(args);
28552 }
28553
28554 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28555 PyObject *resultobj = 0;
28556 int arg1 = (int) 0 ;
28557 wxQueryNewPaletteEvent *result = 0 ;
28558 int val1 ;
28559 int ecode1 = 0 ;
28560 PyObject * obj0 = 0 ;
28561 char * kwnames[] = {
28562 (char *) "winid", NULL
28563 };
28564
28565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28566 if (obj0) {
28567 ecode1 = SWIG_AsVal_int(obj0, &val1);
28568 if (!SWIG_IsOK(ecode1)) {
28569 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28570 }
28571 arg1 = static_cast< int >(val1);
28572 }
28573 {
28574 PyThreadState* __tstate = wxPyBeginAllowThreads();
28575 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28576 wxPyEndAllowThreads(__tstate);
28577 if (PyErr_Occurred()) SWIG_fail;
28578 }
28579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28580 return resultobj;
28581 fail:
28582 return NULL;
28583 }
28584
28585
28586 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28587 PyObject *resultobj = 0;
28588 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28589 bool arg2 ;
28590 void *argp1 = 0 ;
28591 int res1 = 0 ;
28592 bool val2 ;
28593 int ecode2 = 0 ;
28594 PyObject * obj0 = 0 ;
28595 PyObject * obj1 = 0 ;
28596 char * kwnames[] = {
28597 (char *) "self",(char *) "realized", NULL
28598 };
28599
28600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28602 if (!SWIG_IsOK(res1)) {
28603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28604 }
28605 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28606 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28607 if (!SWIG_IsOK(ecode2)) {
28608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28609 }
28610 arg2 = static_cast< bool >(val2);
28611 {
28612 PyThreadState* __tstate = wxPyBeginAllowThreads();
28613 (arg1)->SetPaletteRealized(arg2);
28614 wxPyEndAllowThreads(__tstate);
28615 if (PyErr_Occurred()) SWIG_fail;
28616 }
28617 resultobj = SWIG_Py_Void();
28618 return resultobj;
28619 fail:
28620 return NULL;
28621 }
28622
28623
28624 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28625 PyObject *resultobj = 0;
28626 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28627 bool result;
28628 void *argp1 = 0 ;
28629 int res1 = 0 ;
28630 PyObject *swig_obj[1] ;
28631
28632 if (!args) SWIG_fail;
28633 swig_obj[0] = args;
28634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28635 if (!SWIG_IsOK(res1)) {
28636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28637 }
28638 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28639 {
28640 PyThreadState* __tstate = wxPyBeginAllowThreads();
28641 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28642 wxPyEndAllowThreads(__tstate);
28643 if (PyErr_Occurred()) SWIG_fail;
28644 }
28645 {
28646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28647 }
28648 return resultobj;
28649 fail:
28650 return NULL;
28651 }
28652
28653
28654 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28655 PyObject *obj;
28656 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28657 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28658 return SWIG_Py_Void();
28659 }
28660
28661 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28662 return SWIG_Python_InitShadowInstance(args);
28663 }
28664
28665 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28666 PyObject *resultobj = 0;
28667 wxNavigationKeyEvent *result = 0 ;
28668
28669 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28670 {
28671 PyThreadState* __tstate = wxPyBeginAllowThreads();
28672 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28673 wxPyEndAllowThreads(__tstate);
28674 if (PyErr_Occurred()) SWIG_fail;
28675 }
28676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28677 return resultobj;
28678 fail:
28679 return NULL;
28680 }
28681
28682
28683 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28684 PyObject *resultobj = 0;
28685 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28686 bool result;
28687 void *argp1 = 0 ;
28688 int res1 = 0 ;
28689 PyObject *swig_obj[1] ;
28690
28691 if (!args) SWIG_fail;
28692 swig_obj[0] = args;
28693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28694 if (!SWIG_IsOK(res1)) {
28695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28696 }
28697 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28698 {
28699 PyThreadState* __tstate = wxPyBeginAllowThreads();
28700 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28701 wxPyEndAllowThreads(__tstate);
28702 if (PyErr_Occurred()) SWIG_fail;
28703 }
28704 {
28705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28706 }
28707 return resultobj;
28708 fail:
28709 return NULL;
28710 }
28711
28712
28713 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28714 PyObject *resultobj = 0;
28715 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28716 bool arg2 ;
28717 void *argp1 = 0 ;
28718 int res1 = 0 ;
28719 bool val2 ;
28720 int ecode2 = 0 ;
28721 PyObject * obj0 = 0 ;
28722 PyObject * obj1 = 0 ;
28723 char * kwnames[] = {
28724 (char *) "self",(char *) "forward", NULL
28725 };
28726
28727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28729 if (!SWIG_IsOK(res1)) {
28730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28731 }
28732 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28733 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28734 if (!SWIG_IsOK(ecode2)) {
28735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28736 }
28737 arg2 = static_cast< bool >(val2);
28738 {
28739 PyThreadState* __tstate = wxPyBeginAllowThreads();
28740 (arg1)->SetDirection(arg2);
28741 wxPyEndAllowThreads(__tstate);
28742 if (PyErr_Occurred()) SWIG_fail;
28743 }
28744 resultobj = SWIG_Py_Void();
28745 return resultobj;
28746 fail:
28747 return NULL;
28748 }
28749
28750
28751 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28752 PyObject *resultobj = 0;
28753 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28754 bool result;
28755 void *argp1 = 0 ;
28756 int res1 = 0 ;
28757 PyObject *swig_obj[1] ;
28758
28759 if (!args) SWIG_fail;
28760 swig_obj[0] = args;
28761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28762 if (!SWIG_IsOK(res1)) {
28763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28764 }
28765 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28766 {
28767 PyThreadState* __tstate = wxPyBeginAllowThreads();
28768 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28769 wxPyEndAllowThreads(__tstate);
28770 if (PyErr_Occurred()) SWIG_fail;
28771 }
28772 {
28773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28774 }
28775 return resultobj;
28776 fail:
28777 return NULL;
28778 }
28779
28780
28781 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28782 PyObject *resultobj = 0;
28783 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28784 bool arg2 ;
28785 void *argp1 = 0 ;
28786 int res1 = 0 ;
28787 bool val2 ;
28788 int ecode2 = 0 ;
28789 PyObject * obj0 = 0 ;
28790 PyObject * obj1 = 0 ;
28791 char * kwnames[] = {
28792 (char *) "self",(char *) "ischange", NULL
28793 };
28794
28795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28797 if (!SWIG_IsOK(res1)) {
28798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28799 }
28800 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28801 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28802 if (!SWIG_IsOK(ecode2)) {
28803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28804 }
28805 arg2 = static_cast< bool >(val2);
28806 {
28807 PyThreadState* __tstate = wxPyBeginAllowThreads();
28808 (arg1)->SetWindowChange(arg2);
28809 wxPyEndAllowThreads(__tstate);
28810 if (PyErr_Occurred()) SWIG_fail;
28811 }
28812 resultobj = SWIG_Py_Void();
28813 return resultobj;
28814 fail:
28815 return NULL;
28816 }
28817
28818
28819 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28820 PyObject *resultobj = 0;
28821 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28822 bool result;
28823 void *argp1 = 0 ;
28824 int res1 = 0 ;
28825 PyObject *swig_obj[1] ;
28826
28827 if (!args) SWIG_fail;
28828 swig_obj[0] = args;
28829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28830 if (!SWIG_IsOK(res1)) {
28831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28832 }
28833 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28834 {
28835 PyThreadState* __tstate = wxPyBeginAllowThreads();
28836 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28837 wxPyEndAllowThreads(__tstate);
28838 if (PyErr_Occurred()) SWIG_fail;
28839 }
28840 {
28841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28842 }
28843 return resultobj;
28844 fail:
28845 return NULL;
28846 }
28847
28848
28849 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28850 PyObject *resultobj = 0;
28851 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28852 bool arg2 ;
28853 void *argp1 = 0 ;
28854 int res1 = 0 ;
28855 bool val2 ;
28856 int ecode2 = 0 ;
28857 PyObject * obj0 = 0 ;
28858 PyObject * obj1 = 0 ;
28859 char * kwnames[] = {
28860 (char *) "self",(char *) "bIs", NULL
28861 };
28862
28863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28865 if (!SWIG_IsOK(res1)) {
28866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28867 }
28868 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28869 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28870 if (!SWIG_IsOK(ecode2)) {
28871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28872 }
28873 arg2 = static_cast< bool >(val2);
28874 {
28875 PyThreadState* __tstate = wxPyBeginAllowThreads();
28876 (arg1)->SetFromTab(arg2);
28877 wxPyEndAllowThreads(__tstate);
28878 if (PyErr_Occurred()) SWIG_fail;
28879 }
28880 resultobj = SWIG_Py_Void();
28881 return resultobj;
28882 fail:
28883 return NULL;
28884 }
28885
28886
28887 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28888 PyObject *resultobj = 0;
28889 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28890 long arg2 ;
28891 void *argp1 = 0 ;
28892 int res1 = 0 ;
28893 long val2 ;
28894 int ecode2 = 0 ;
28895 PyObject * obj0 = 0 ;
28896 PyObject * obj1 = 0 ;
28897 char * kwnames[] = {
28898 (char *) "self",(char *) "flags", NULL
28899 };
28900
28901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28903 if (!SWIG_IsOK(res1)) {
28904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28905 }
28906 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28907 ecode2 = SWIG_AsVal_long(obj1, &val2);
28908 if (!SWIG_IsOK(ecode2)) {
28909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28910 }
28911 arg2 = static_cast< long >(val2);
28912 {
28913 PyThreadState* __tstate = wxPyBeginAllowThreads();
28914 (arg1)->SetFlags(arg2);
28915 wxPyEndAllowThreads(__tstate);
28916 if (PyErr_Occurred()) SWIG_fail;
28917 }
28918 resultobj = SWIG_Py_Void();
28919 return resultobj;
28920 fail:
28921 return NULL;
28922 }
28923
28924
28925 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28926 PyObject *resultobj = 0;
28927 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28928 wxWindow *result = 0 ;
28929 void *argp1 = 0 ;
28930 int res1 = 0 ;
28931 PyObject *swig_obj[1] ;
28932
28933 if (!args) SWIG_fail;
28934 swig_obj[0] = args;
28935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28936 if (!SWIG_IsOK(res1)) {
28937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28938 }
28939 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28940 {
28941 PyThreadState* __tstate = wxPyBeginAllowThreads();
28942 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
28943 wxPyEndAllowThreads(__tstate);
28944 if (PyErr_Occurred()) SWIG_fail;
28945 }
28946 {
28947 resultobj = wxPyMake_wxObject(result, (bool)0);
28948 }
28949 return resultobj;
28950 fail:
28951 return NULL;
28952 }
28953
28954
28955 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28956 PyObject *resultobj = 0;
28957 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28958 wxWindow *arg2 = (wxWindow *) 0 ;
28959 void *argp1 = 0 ;
28960 int res1 = 0 ;
28961 void *argp2 = 0 ;
28962 int res2 = 0 ;
28963 PyObject * obj0 = 0 ;
28964 PyObject * obj1 = 0 ;
28965 char * kwnames[] = {
28966 (char *) "self",(char *) "win", NULL
28967 };
28968
28969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
28970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28971 if (!SWIG_IsOK(res1)) {
28972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28973 }
28974 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28975 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28976 if (!SWIG_IsOK(res2)) {
28977 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
28978 }
28979 arg2 = reinterpret_cast< wxWindow * >(argp2);
28980 {
28981 PyThreadState* __tstate = wxPyBeginAllowThreads();
28982 (arg1)->SetCurrentFocus(arg2);
28983 wxPyEndAllowThreads(__tstate);
28984 if (PyErr_Occurred()) SWIG_fail;
28985 }
28986 resultobj = SWIG_Py_Void();
28987 return resultobj;
28988 fail:
28989 return NULL;
28990 }
28991
28992
28993 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28994 PyObject *obj;
28995 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28996 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
28997 return SWIG_Py_Void();
28998 }
28999
29000 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29001 return SWIG_Python_InitShadowInstance(args);
29002 }
29003
29004 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29005 PyObject *resultobj = 0;
29006 wxWindow *arg1 = (wxWindow *) NULL ;
29007 wxWindowCreateEvent *result = 0 ;
29008 void *argp1 = 0 ;
29009 int res1 = 0 ;
29010 PyObject * obj0 = 0 ;
29011 char * kwnames[] = {
29012 (char *) "win", NULL
29013 };
29014
29015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
29016 if (obj0) {
29017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29018 if (!SWIG_IsOK(res1)) {
29019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29020 }
29021 arg1 = reinterpret_cast< wxWindow * >(argp1);
29022 }
29023 {
29024 PyThreadState* __tstate = wxPyBeginAllowThreads();
29025 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29026 wxPyEndAllowThreads(__tstate);
29027 if (PyErr_Occurred()) SWIG_fail;
29028 }
29029 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29030 return resultobj;
29031 fail:
29032 return NULL;
29033 }
29034
29035
29036 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29037 PyObject *resultobj = 0;
29038 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29039 wxWindow *result = 0 ;
29040 void *argp1 = 0 ;
29041 int res1 = 0 ;
29042 PyObject *swig_obj[1] ;
29043
29044 if (!args) SWIG_fail;
29045 swig_obj[0] = args;
29046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29047 if (!SWIG_IsOK(res1)) {
29048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29049 }
29050 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29051 {
29052 PyThreadState* __tstate = wxPyBeginAllowThreads();
29053 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29054 wxPyEndAllowThreads(__tstate);
29055 if (PyErr_Occurred()) SWIG_fail;
29056 }
29057 {
29058 resultobj = wxPyMake_wxObject(result, (bool)0);
29059 }
29060 return resultobj;
29061 fail:
29062 return NULL;
29063 }
29064
29065
29066 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29067 PyObject *obj;
29068 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29069 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29070 return SWIG_Py_Void();
29071 }
29072
29073 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29074 return SWIG_Python_InitShadowInstance(args);
29075 }
29076
29077 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29078 PyObject *resultobj = 0;
29079 wxWindow *arg1 = (wxWindow *) NULL ;
29080 wxWindowDestroyEvent *result = 0 ;
29081 void *argp1 = 0 ;
29082 int res1 = 0 ;
29083 PyObject * obj0 = 0 ;
29084 char * kwnames[] = {
29085 (char *) "win", NULL
29086 };
29087
29088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29089 if (obj0) {
29090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29091 if (!SWIG_IsOK(res1)) {
29092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29093 }
29094 arg1 = reinterpret_cast< wxWindow * >(argp1);
29095 }
29096 {
29097 PyThreadState* __tstate = wxPyBeginAllowThreads();
29098 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29099 wxPyEndAllowThreads(__tstate);
29100 if (PyErr_Occurred()) SWIG_fail;
29101 }
29102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29103 return resultobj;
29104 fail:
29105 return NULL;
29106 }
29107
29108
29109 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29110 PyObject *resultobj = 0;
29111 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29112 wxWindow *result = 0 ;
29113 void *argp1 = 0 ;
29114 int res1 = 0 ;
29115 PyObject *swig_obj[1] ;
29116
29117 if (!args) SWIG_fail;
29118 swig_obj[0] = args;
29119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29120 if (!SWIG_IsOK(res1)) {
29121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29122 }
29123 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29124 {
29125 PyThreadState* __tstate = wxPyBeginAllowThreads();
29126 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29127 wxPyEndAllowThreads(__tstate);
29128 if (PyErr_Occurred()) SWIG_fail;
29129 }
29130 {
29131 resultobj = wxPyMake_wxObject(result, (bool)0);
29132 }
29133 return resultobj;
29134 fail:
29135 return NULL;
29136 }
29137
29138
29139 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29140 PyObject *obj;
29141 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29142 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29143 return SWIG_Py_Void();
29144 }
29145
29146 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29147 return SWIG_Python_InitShadowInstance(args);
29148 }
29149
29150 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29151 PyObject *resultobj = 0;
29152 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29153 int arg2 = (int) 0 ;
29154 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29155 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29156 wxContextMenuEvent *result = 0 ;
29157 int val1 ;
29158 int ecode1 = 0 ;
29159 int val2 ;
29160 int ecode2 = 0 ;
29161 wxPoint temp3 ;
29162 PyObject * obj0 = 0 ;
29163 PyObject * obj1 = 0 ;
29164 PyObject * obj2 = 0 ;
29165 char * kwnames[] = {
29166 (char *) "type",(char *) "winid",(char *) "pt", NULL
29167 };
29168
29169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29170 if (obj0) {
29171 ecode1 = SWIG_AsVal_int(obj0, &val1);
29172 if (!SWIG_IsOK(ecode1)) {
29173 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29174 }
29175 arg1 = static_cast< wxEventType >(val1);
29176 }
29177 if (obj1) {
29178 ecode2 = SWIG_AsVal_int(obj1, &val2);
29179 if (!SWIG_IsOK(ecode2)) {
29180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29181 }
29182 arg2 = static_cast< int >(val2);
29183 }
29184 if (obj2) {
29185 {
29186 arg3 = &temp3;
29187 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29188 }
29189 }
29190 {
29191 PyThreadState* __tstate = wxPyBeginAllowThreads();
29192 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29193 wxPyEndAllowThreads(__tstate);
29194 if (PyErr_Occurred()) SWIG_fail;
29195 }
29196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29197 return resultobj;
29198 fail:
29199 return NULL;
29200 }
29201
29202
29203 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29204 PyObject *resultobj = 0;
29205 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29206 wxPoint *result = 0 ;
29207 void *argp1 = 0 ;
29208 int res1 = 0 ;
29209 PyObject *swig_obj[1] ;
29210
29211 if (!args) SWIG_fail;
29212 swig_obj[0] = args;
29213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29214 if (!SWIG_IsOK(res1)) {
29215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29216 }
29217 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29218 {
29219 PyThreadState* __tstate = wxPyBeginAllowThreads();
29220 {
29221 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29222 result = (wxPoint *) &_result_ref;
29223 }
29224 wxPyEndAllowThreads(__tstate);
29225 if (PyErr_Occurred()) SWIG_fail;
29226 }
29227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29228 return resultobj;
29229 fail:
29230 return NULL;
29231 }
29232
29233
29234 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29235 PyObject *resultobj = 0;
29236 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29237 wxPoint *arg2 = 0 ;
29238 void *argp1 = 0 ;
29239 int res1 = 0 ;
29240 wxPoint temp2 ;
29241 PyObject * obj0 = 0 ;
29242 PyObject * obj1 = 0 ;
29243 char * kwnames[] = {
29244 (char *) "self",(char *) "pos", NULL
29245 };
29246
29247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29249 if (!SWIG_IsOK(res1)) {
29250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29251 }
29252 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29253 {
29254 arg2 = &temp2;
29255 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29256 }
29257 {
29258 PyThreadState* __tstate = wxPyBeginAllowThreads();
29259 (arg1)->SetPosition((wxPoint const &)*arg2);
29260 wxPyEndAllowThreads(__tstate);
29261 if (PyErr_Occurred()) SWIG_fail;
29262 }
29263 resultobj = SWIG_Py_Void();
29264 return resultobj;
29265 fail:
29266 return NULL;
29267 }
29268
29269
29270 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29271 PyObject *obj;
29272 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29273 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29274 return SWIG_Py_Void();
29275 }
29276
29277 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29278 return SWIG_Python_InitShadowInstance(args);
29279 }
29280
29281 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29282 PyObject *resultobj = 0;
29283 wxIdleEvent *result = 0 ;
29284
29285 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29286 {
29287 PyThreadState* __tstate = wxPyBeginAllowThreads();
29288 result = (wxIdleEvent *)new wxIdleEvent();
29289 wxPyEndAllowThreads(__tstate);
29290 if (PyErr_Occurred()) SWIG_fail;
29291 }
29292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29293 return resultobj;
29294 fail:
29295 return NULL;
29296 }
29297
29298
29299 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29300 PyObject *resultobj = 0;
29301 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29302 bool arg2 = (bool) true ;
29303 void *argp1 = 0 ;
29304 int res1 = 0 ;
29305 bool val2 ;
29306 int ecode2 = 0 ;
29307 PyObject * obj0 = 0 ;
29308 PyObject * obj1 = 0 ;
29309 char * kwnames[] = {
29310 (char *) "self",(char *) "needMore", NULL
29311 };
29312
29313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29315 if (!SWIG_IsOK(res1)) {
29316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29317 }
29318 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29319 if (obj1) {
29320 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29321 if (!SWIG_IsOK(ecode2)) {
29322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29323 }
29324 arg2 = static_cast< bool >(val2);
29325 }
29326 {
29327 PyThreadState* __tstate = wxPyBeginAllowThreads();
29328 (arg1)->RequestMore(arg2);
29329 wxPyEndAllowThreads(__tstate);
29330 if (PyErr_Occurred()) SWIG_fail;
29331 }
29332 resultobj = SWIG_Py_Void();
29333 return resultobj;
29334 fail:
29335 return NULL;
29336 }
29337
29338
29339 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29340 PyObject *resultobj = 0;
29341 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29342 bool result;
29343 void *argp1 = 0 ;
29344 int res1 = 0 ;
29345 PyObject *swig_obj[1] ;
29346
29347 if (!args) SWIG_fail;
29348 swig_obj[0] = args;
29349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29350 if (!SWIG_IsOK(res1)) {
29351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29352 }
29353 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29354 {
29355 PyThreadState* __tstate = wxPyBeginAllowThreads();
29356 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29357 wxPyEndAllowThreads(__tstate);
29358 if (PyErr_Occurred()) SWIG_fail;
29359 }
29360 {
29361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29362 }
29363 return resultobj;
29364 fail:
29365 return NULL;
29366 }
29367
29368
29369 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29370 PyObject *resultobj = 0;
29371 wxIdleMode arg1 ;
29372 int val1 ;
29373 int ecode1 = 0 ;
29374 PyObject * obj0 = 0 ;
29375 char * kwnames[] = {
29376 (char *) "mode", NULL
29377 };
29378
29379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29380 ecode1 = SWIG_AsVal_int(obj0, &val1);
29381 if (!SWIG_IsOK(ecode1)) {
29382 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29383 }
29384 arg1 = static_cast< wxIdleMode >(val1);
29385 {
29386 PyThreadState* __tstate = wxPyBeginAllowThreads();
29387 wxIdleEvent::SetMode(arg1);
29388 wxPyEndAllowThreads(__tstate);
29389 if (PyErr_Occurred()) SWIG_fail;
29390 }
29391 resultobj = SWIG_Py_Void();
29392 return resultobj;
29393 fail:
29394 return NULL;
29395 }
29396
29397
29398 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29399 PyObject *resultobj = 0;
29400 wxIdleMode result;
29401
29402 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29403 {
29404 PyThreadState* __tstate = wxPyBeginAllowThreads();
29405 result = (wxIdleMode)wxIdleEvent::GetMode();
29406 wxPyEndAllowThreads(__tstate);
29407 if (PyErr_Occurred()) SWIG_fail;
29408 }
29409 resultobj = SWIG_From_int(static_cast< int >(result));
29410 return resultobj;
29411 fail:
29412 return NULL;
29413 }
29414
29415
29416 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29417 PyObject *resultobj = 0;
29418 wxWindow *arg1 = (wxWindow *) 0 ;
29419 bool result;
29420 void *argp1 = 0 ;
29421 int res1 = 0 ;
29422 PyObject * obj0 = 0 ;
29423 char * kwnames[] = {
29424 (char *) "win", NULL
29425 };
29426
29427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29429 if (!SWIG_IsOK(res1)) {
29430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29431 }
29432 arg1 = reinterpret_cast< wxWindow * >(argp1);
29433 {
29434 PyThreadState* __tstate = wxPyBeginAllowThreads();
29435 result = (bool)wxIdleEvent::CanSend(arg1);
29436 wxPyEndAllowThreads(__tstate);
29437 if (PyErr_Occurred()) SWIG_fail;
29438 }
29439 {
29440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29441 }
29442 return resultobj;
29443 fail:
29444 return NULL;
29445 }
29446
29447
29448 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29449 PyObject *obj;
29450 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29451 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29452 return SWIG_Py_Void();
29453 }
29454
29455 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29456 return SWIG_Python_InitShadowInstance(args);
29457 }
29458
29459 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29460 PyObject *resultobj = 0;
29461 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29462 int arg2 = (int) 0 ;
29463 wxClipboardTextEvent *result = 0 ;
29464 int val1 ;
29465 int ecode1 = 0 ;
29466 int val2 ;
29467 int ecode2 = 0 ;
29468 PyObject * obj0 = 0 ;
29469 PyObject * obj1 = 0 ;
29470 char * kwnames[] = {
29471 (char *) "type",(char *) "winid", NULL
29472 };
29473
29474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29475 if (obj0) {
29476 ecode1 = SWIG_AsVal_int(obj0, &val1);
29477 if (!SWIG_IsOK(ecode1)) {
29478 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29479 }
29480 arg1 = static_cast< wxEventType >(val1);
29481 }
29482 if (obj1) {
29483 ecode2 = SWIG_AsVal_int(obj1, &val2);
29484 if (!SWIG_IsOK(ecode2)) {
29485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29486 }
29487 arg2 = static_cast< int >(val2);
29488 }
29489 {
29490 PyThreadState* __tstate = wxPyBeginAllowThreads();
29491 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29492 wxPyEndAllowThreads(__tstate);
29493 if (PyErr_Occurred()) SWIG_fail;
29494 }
29495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29496 return resultobj;
29497 fail:
29498 return NULL;
29499 }
29500
29501
29502 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29503 PyObject *obj;
29504 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29505 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29506 return SWIG_Py_Void();
29507 }
29508
29509 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29510 return SWIG_Python_InitShadowInstance(args);
29511 }
29512
29513 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29514 PyObject *resultobj = 0;
29515 int arg1 = (int) 0 ;
29516 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29517 wxPyEvent *result = 0 ;
29518 int val1 ;
29519 int ecode1 = 0 ;
29520 int val2 ;
29521 int ecode2 = 0 ;
29522 PyObject * obj0 = 0 ;
29523 PyObject * obj1 = 0 ;
29524 char * kwnames[] = {
29525 (char *) "winid",(char *) "eventType", NULL
29526 };
29527
29528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29529 if (obj0) {
29530 ecode1 = SWIG_AsVal_int(obj0, &val1);
29531 if (!SWIG_IsOK(ecode1)) {
29532 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29533 }
29534 arg1 = static_cast< int >(val1);
29535 }
29536 if (obj1) {
29537 ecode2 = SWIG_AsVal_int(obj1, &val2);
29538 if (!SWIG_IsOK(ecode2)) {
29539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29540 }
29541 arg2 = static_cast< wxEventType >(val2);
29542 }
29543 {
29544 PyThreadState* __tstate = wxPyBeginAllowThreads();
29545 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29546 wxPyEndAllowThreads(__tstate);
29547 if (PyErr_Occurred()) SWIG_fail;
29548 }
29549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29550 return resultobj;
29551 fail:
29552 return NULL;
29553 }
29554
29555
29556 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29557 PyObject *resultobj = 0;
29558 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29559 void *argp1 = 0 ;
29560 int res1 = 0 ;
29561 PyObject *swig_obj[1] ;
29562
29563 if (!args) SWIG_fail;
29564 swig_obj[0] = args;
29565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29566 if (!SWIG_IsOK(res1)) {
29567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29568 }
29569 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29570 {
29571 PyThreadState* __tstate = wxPyBeginAllowThreads();
29572 delete arg1;
29573
29574 wxPyEndAllowThreads(__tstate);
29575 if (PyErr_Occurred()) SWIG_fail;
29576 }
29577 resultobj = SWIG_Py_Void();
29578 return resultobj;
29579 fail:
29580 return NULL;
29581 }
29582
29583
29584 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29585 PyObject *resultobj = 0;
29586 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29587 PyObject *arg2 = (PyObject *) 0 ;
29588 void *argp1 = 0 ;
29589 int res1 = 0 ;
29590 PyObject * obj0 = 0 ;
29591 PyObject * obj1 = 0 ;
29592 char * kwnames[] = {
29593 (char *) "self",(char *) "self", NULL
29594 };
29595
29596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29598 if (!SWIG_IsOK(res1)) {
29599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29600 }
29601 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29602 arg2 = obj1;
29603 {
29604 PyThreadState* __tstate = wxPyBeginAllowThreads();
29605 (arg1)->SetSelf(arg2);
29606 wxPyEndAllowThreads(__tstate);
29607 if (PyErr_Occurred()) SWIG_fail;
29608 }
29609 resultobj = SWIG_Py_Void();
29610 return resultobj;
29611 fail:
29612 return NULL;
29613 }
29614
29615
29616 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29617 PyObject *resultobj = 0;
29618 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29619 PyObject *result = 0 ;
29620 void *argp1 = 0 ;
29621 int res1 = 0 ;
29622 PyObject *swig_obj[1] ;
29623
29624 if (!args) SWIG_fail;
29625 swig_obj[0] = args;
29626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29627 if (!SWIG_IsOK(res1)) {
29628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29629 }
29630 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29631 {
29632 PyThreadState* __tstate = wxPyBeginAllowThreads();
29633 result = (PyObject *)(arg1)->GetSelf();
29634 wxPyEndAllowThreads(__tstate);
29635 if (PyErr_Occurred()) SWIG_fail;
29636 }
29637 resultobj = result;
29638 return resultobj;
29639 fail:
29640 return NULL;
29641 }
29642
29643
29644 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29645 PyObject *obj;
29646 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29647 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29648 return SWIG_Py_Void();
29649 }
29650
29651 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29652 return SWIG_Python_InitShadowInstance(args);
29653 }
29654
29655 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29656 PyObject *resultobj = 0;
29657 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29658 int arg2 = (int) 0 ;
29659 wxPyCommandEvent *result = 0 ;
29660 int val1 ;
29661 int ecode1 = 0 ;
29662 int val2 ;
29663 int ecode2 = 0 ;
29664 PyObject * obj0 = 0 ;
29665 PyObject * obj1 = 0 ;
29666 char * kwnames[] = {
29667 (char *) "eventType",(char *) "id", NULL
29668 };
29669
29670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29671 if (obj0) {
29672 ecode1 = SWIG_AsVal_int(obj0, &val1);
29673 if (!SWIG_IsOK(ecode1)) {
29674 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29675 }
29676 arg1 = static_cast< wxEventType >(val1);
29677 }
29678 if (obj1) {
29679 ecode2 = SWIG_AsVal_int(obj1, &val2);
29680 if (!SWIG_IsOK(ecode2)) {
29681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29682 }
29683 arg2 = static_cast< int >(val2);
29684 }
29685 {
29686 PyThreadState* __tstate = wxPyBeginAllowThreads();
29687 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29688 wxPyEndAllowThreads(__tstate);
29689 if (PyErr_Occurred()) SWIG_fail;
29690 }
29691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29692 return resultobj;
29693 fail:
29694 return NULL;
29695 }
29696
29697
29698 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29699 PyObject *resultobj = 0;
29700 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29701 void *argp1 = 0 ;
29702 int res1 = 0 ;
29703 PyObject *swig_obj[1] ;
29704
29705 if (!args) SWIG_fail;
29706 swig_obj[0] = args;
29707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29708 if (!SWIG_IsOK(res1)) {
29709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29710 }
29711 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29712 {
29713 PyThreadState* __tstate = wxPyBeginAllowThreads();
29714 delete arg1;
29715
29716 wxPyEndAllowThreads(__tstate);
29717 if (PyErr_Occurred()) SWIG_fail;
29718 }
29719 resultobj = SWIG_Py_Void();
29720 return resultobj;
29721 fail:
29722 return NULL;
29723 }
29724
29725
29726 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29727 PyObject *resultobj = 0;
29728 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29729 PyObject *arg2 = (PyObject *) 0 ;
29730 void *argp1 = 0 ;
29731 int res1 = 0 ;
29732 PyObject * obj0 = 0 ;
29733 PyObject * obj1 = 0 ;
29734 char * kwnames[] = {
29735 (char *) "self",(char *) "self", NULL
29736 };
29737
29738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29740 if (!SWIG_IsOK(res1)) {
29741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29742 }
29743 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29744 arg2 = obj1;
29745 {
29746 PyThreadState* __tstate = wxPyBeginAllowThreads();
29747 (arg1)->SetSelf(arg2);
29748 wxPyEndAllowThreads(__tstate);
29749 if (PyErr_Occurred()) SWIG_fail;
29750 }
29751 resultobj = SWIG_Py_Void();
29752 return resultobj;
29753 fail:
29754 return NULL;
29755 }
29756
29757
29758 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29759 PyObject *resultobj = 0;
29760 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29761 PyObject *result = 0 ;
29762 void *argp1 = 0 ;
29763 int res1 = 0 ;
29764 PyObject *swig_obj[1] ;
29765
29766 if (!args) SWIG_fail;
29767 swig_obj[0] = args;
29768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29769 if (!SWIG_IsOK(res1)) {
29770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29771 }
29772 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29773 {
29774 PyThreadState* __tstate = wxPyBeginAllowThreads();
29775 result = (PyObject *)(arg1)->GetSelf();
29776 wxPyEndAllowThreads(__tstate);
29777 if (PyErr_Occurred()) SWIG_fail;
29778 }
29779 resultobj = result;
29780 return resultobj;
29781 fail:
29782 return NULL;
29783 }
29784
29785
29786 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29787 PyObject *obj;
29788 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29789 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29790 return SWIG_Py_Void();
29791 }
29792
29793 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29794 return SWIG_Python_InitShadowInstance(args);
29795 }
29796
29797 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29798 PyObject *resultobj = 0;
29799 wxWindow *arg1 = (wxWindow *) 0 ;
29800 wxDateTime *arg2 = 0 ;
29801 wxEventType arg3 ;
29802 wxDateEvent *result = 0 ;
29803 void *argp1 = 0 ;
29804 int res1 = 0 ;
29805 void *argp2 = 0 ;
29806 int res2 = 0 ;
29807 int val3 ;
29808 int ecode3 = 0 ;
29809 PyObject * obj0 = 0 ;
29810 PyObject * obj1 = 0 ;
29811 PyObject * obj2 = 0 ;
29812 char * kwnames[] = {
29813 (char *) "win",(char *) "dt",(char *) "type", NULL
29814 };
29815
29816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29818 if (!SWIG_IsOK(res1)) {
29819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29820 }
29821 arg1 = reinterpret_cast< wxWindow * >(argp1);
29822 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29823 if (!SWIG_IsOK(res2)) {
29824 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29825 }
29826 if (!argp2) {
29827 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29828 }
29829 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29830 ecode3 = SWIG_AsVal_int(obj2, &val3);
29831 if (!SWIG_IsOK(ecode3)) {
29832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29833 }
29834 arg3 = static_cast< wxEventType >(val3);
29835 {
29836 PyThreadState* __tstate = wxPyBeginAllowThreads();
29837 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29838 wxPyEndAllowThreads(__tstate);
29839 if (PyErr_Occurred()) SWIG_fail;
29840 }
29841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29842 return resultobj;
29843 fail:
29844 return NULL;
29845 }
29846
29847
29848 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29849 PyObject *resultobj = 0;
29850 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29851 wxDateTime *result = 0 ;
29852 void *argp1 = 0 ;
29853 int res1 = 0 ;
29854 PyObject *swig_obj[1] ;
29855
29856 if (!args) SWIG_fail;
29857 swig_obj[0] = args;
29858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29859 if (!SWIG_IsOK(res1)) {
29860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29861 }
29862 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29863 {
29864 PyThreadState* __tstate = wxPyBeginAllowThreads();
29865 {
29866 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29867 result = (wxDateTime *) &_result_ref;
29868 }
29869 wxPyEndAllowThreads(__tstate);
29870 if (PyErr_Occurred()) SWIG_fail;
29871 }
29872 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29873 return resultobj;
29874 fail:
29875 return NULL;
29876 }
29877
29878
29879 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29880 PyObject *resultobj = 0;
29881 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29882 wxDateTime *arg2 = 0 ;
29883 void *argp1 = 0 ;
29884 int res1 = 0 ;
29885 void *argp2 = 0 ;
29886 int res2 = 0 ;
29887 PyObject * obj0 = 0 ;
29888 PyObject * obj1 = 0 ;
29889 char * kwnames[] = {
29890 (char *) "self",(char *) "date", NULL
29891 };
29892
29893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29895 if (!SWIG_IsOK(res1)) {
29896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29897 }
29898 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29899 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29900 if (!SWIG_IsOK(res2)) {
29901 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29902 }
29903 if (!argp2) {
29904 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29905 }
29906 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29907 {
29908 PyThreadState* __tstate = wxPyBeginAllowThreads();
29909 (arg1)->SetDate((wxDateTime const &)*arg2);
29910 wxPyEndAllowThreads(__tstate);
29911 if (PyErr_Occurred()) SWIG_fail;
29912 }
29913 resultobj = SWIG_Py_Void();
29914 return resultobj;
29915 fail:
29916 return NULL;
29917 }
29918
29919
29920 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29921 PyObject *obj;
29922 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29923 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
29924 return SWIG_Py_Void();
29925 }
29926
29927 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29928 return SWIG_Python_InitShadowInstance(args);
29929 }
29930
29931 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29932 PyObject *resultobj = 0;
29933 wxPyApp *result = 0 ;
29934
29935 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
29936 {
29937 PyThreadState* __tstate = wxPyBeginAllowThreads();
29938 result = (wxPyApp *)new_wxPyApp();
29939 wxPyEndAllowThreads(__tstate);
29940 if (PyErr_Occurred()) SWIG_fail;
29941 }
29942 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
29943 return resultobj;
29944 fail:
29945 return NULL;
29946 }
29947
29948
29949 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29950 PyObject *resultobj = 0;
29951 wxPyApp *arg1 = (wxPyApp *) 0 ;
29952 void *argp1 = 0 ;
29953 int res1 = 0 ;
29954 PyObject *swig_obj[1] ;
29955
29956 if (!args) SWIG_fail;
29957 swig_obj[0] = args;
29958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
29959 if (!SWIG_IsOK(res1)) {
29960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
29961 }
29962 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29963 {
29964 PyThreadState* __tstate = wxPyBeginAllowThreads();
29965 delete arg1;
29966
29967 wxPyEndAllowThreads(__tstate);
29968 if (PyErr_Occurred()) SWIG_fail;
29969 }
29970 resultobj = SWIG_Py_Void();
29971 return resultobj;
29972 fail:
29973 return NULL;
29974 }
29975
29976
29977 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29978 PyObject *resultobj = 0;
29979 wxPyApp *arg1 = (wxPyApp *) 0 ;
29980 PyObject *arg2 = (PyObject *) 0 ;
29981 PyObject *arg3 = (PyObject *) 0 ;
29982 bool arg4 ;
29983 void *argp1 = 0 ;
29984 int res1 = 0 ;
29985 bool val4 ;
29986 int ecode4 = 0 ;
29987 PyObject * obj0 = 0 ;
29988 PyObject * obj1 = 0 ;
29989 PyObject * obj2 = 0 ;
29990 PyObject * obj3 = 0 ;
29991 char * kwnames[] = {
29992 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
29993 };
29994
29995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29997 if (!SWIG_IsOK(res1)) {
29998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
29999 }
30000 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30001 arg2 = obj1;
30002 arg3 = obj2;
30003 ecode4 = SWIG_AsVal_bool(obj3, &val4);
30004 if (!SWIG_IsOK(ecode4)) {
30005 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
30006 }
30007 arg4 = static_cast< bool >(val4);
30008 {
30009 PyThreadState* __tstate = wxPyBeginAllowThreads();
30010 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
30011 wxPyEndAllowThreads(__tstate);
30012 if (PyErr_Occurred()) SWIG_fail;
30013 }
30014 resultobj = SWIG_Py_Void();
30015 return resultobj;
30016 fail:
30017 return NULL;
30018 }
30019
30020
30021 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30022 PyObject *resultobj = 0;
30023 wxPyApp *arg1 = (wxPyApp *) 0 ;
30024 wxString result;
30025 void *argp1 = 0 ;
30026 int res1 = 0 ;
30027 PyObject *swig_obj[1] ;
30028
30029 if (!args) SWIG_fail;
30030 swig_obj[0] = args;
30031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30032 if (!SWIG_IsOK(res1)) {
30033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30034 }
30035 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30036 {
30037 PyThreadState* __tstate = wxPyBeginAllowThreads();
30038 result = ((wxPyApp const *)arg1)->GetAppName();
30039 wxPyEndAllowThreads(__tstate);
30040 if (PyErr_Occurred()) SWIG_fail;
30041 }
30042 {
30043 #if wxUSE_UNICODE
30044 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30045 #else
30046 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30047 #endif
30048 }
30049 return resultobj;
30050 fail:
30051 return NULL;
30052 }
30053
30054
30055 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30056 PyObject *resultobj = 0;
30057 wxPyApp *arg1 = (wxPyApp *) 0 ;
30058 wxString *arg2 = 0 ;
30059 void *argp1 = 0 ;
30060 int res1 = 0 ;
30061 bool temp2 = false ;
30062 PyObject * obj0 = 0 ;
30063 PyObject * obj1 = 0 ;
30064 char * kwnames[] = {
30065 (char *) "self",(char *) "name", NULL
30066 };
30067
30068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30070 if (!SWIG_IsOK(res1)) {
30071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30072 }
30073 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30074 {
30075 arg2 = wxString_in_helper(obj1);
30076 if (arg2 == NULL) SWIG_fail;
30077 temp2 = true;
30078 }
30079 {
30080 PyThreadState* __tstate = wxPyBeginAllowThreads();
30081 (arg1)->SetAppName((wxString const &)*arg2);
30082 wxPyEndAllowThreads(__tstate);
30083 if (PyErr_Occurred()) SWIG_fail;
30084 }
30085 resultobj = SWIG_Py_Void();
30086 {
30087 if (temp2)
30088 delete arg2;
30089 }
30090 return resultobj;
30091 fail:
30092 {
30093 if (temp2)
30094 delete arg2;
30095 }
30096 return NULL;
30097 }
30098
30099
30100 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30101 PyObject *resultobj = 0;
30102 wxPyApp *arg1 = (wxPyApp *) 0 ;
30103 wxString result;
30104 void *argp1 = 0 ;
30105 int res1 = 0 ;
30106 PyObject *swig_obj[1] ;
30107
30108 if (!args) SWIG_fail;
30109 swig_obj[0] = args;
30110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30111 if (!SWIG_IsOK(res1)) {
30112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30113 }
30114 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30115 {
30116 PyThreadState* __tstate = wxPyBeginAllowThreads();
30117 result = ((wxPyApp const *)arg1)->GetClassName();
30118 wxPyEndAllowThreads(__tstate);
30119 if (PyErr_Occurred()) SWIG_fail;
30120 }
30121 {
30122 #if wxUSE_UNICODE
30123 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30124 #else
30125 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30126 #endif
30127 }
30128 return resultobj;
30129 fail:
30130 return NULL;
30131 }
30132
30133
30134 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30135 PyObject *resultobj = 0;
30136 wxPyApp *arg1 = (wxPyApp *) 0 ;
30137 wxString *arg2 = 0 ;
30138 void *argp1 = 0 ;
30139 int res1 = 0 ;
30140 bool temp2 = false ;
30141 PyObject * obj0 = 0 ;
30142 PyObject * obj1 = 0 ;
30143 char * kwnames[] = {
30144 (char *) "self",(char *) "name", NULL
30145 };
30146
30147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30149 if (!SWIG_IsOK(res1)) {
30150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30151 }
30152 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30153 {
30154 arg2 = wxString_in_helper(obj1);
30155 if (arg2 == NULL) SWIG_fail;
30156 temp2 = true;
30157 }
30158 {
30159 PyThreadState* __tstate = wxPyBeginAllowThreads();
30160 (arg1)->SetClassName((wxString const &)*arg2);
30161 wxPyEndAllowThreads(__tstate);
30162 if (PyErr_Occurred()) SWIG_fail;
30163 }
30164 resultobj = SWIG_Py_Void();
30165 {
30166 if (temp2)
30167 delete arg2;
30168 }
30169 return resultobj;
30170 fail:
30171 {
30172 if (temp2)
30173 delete arg2;
30174 }
30175 return NULL;
30176 }
30177
30178
30179 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30180 PyObject *resultobj = 0;
30181 wxPyApp *arg1 = (wxPyApp *) 0 ;
30182 wxString *result = 0 ;
30183 void *argp1 = 0 ;
30184 int res1 = 0 ;
30185 PyObject *swig_obj[1] ;
30186
30187 if (!args) SWIG_fail;
30188 swig_obj[0] = args;
30189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30190 if (!SWIG_IsOK(res1)) {
30191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30192 }
30193 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30194 {
30195 PyThreadState* __tstate = wxPyBeginAllowThreads();
30196 {
30197 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30198 result = (wxString *) &_result_ref;
30199 }
30200 wxPyEndAllowThreads(__tstate);
30201 if (PyErr_Occurred()) SWIG_fail;
30202 }
30203 {
30204 #if wxUSE_UNICODE
30205 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30206 #else
30207 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30208 #endif
30209 }
30210 return resultobj;
30211 fail:
30212 return NULL;
30213 }
30214
30215
30216 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30217 PyObject *resultobj = 0;
30218 wxPyApp *arg1 = (wxPyApp *) 0 ;
30219 wxString *arg2 = 0 ;
30220 void *argp1 = 0 ;
30221 int res1 = 0 ;
30222 bool temp2 = false ;
30223 PyObject * obj0 = 0 ;
30224 PyObject * obj1 = 0 ;
30225 char * kwnames[] = {
30226 (char *) "self",(char *) "name", NULL
30227 };
30228
30229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30231 if (!SWIG_IsOK(res1)) {
30232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30233 }
30234 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30235 {
30236 arg2 = wxString_in_helper(obj1);
30237 if (arg2 == NULL) SWIG_fail;
30238 temp2 = true;
30239 }
30240 {
30241 PyThreadState* __tstate = wxPyBeginAllowThreads();
30242 (arg1)->SetVendorName((wxString const &)*arg2);
30243 wxPyEndAllowThreads(__tstate);
30244 if (PyErr_Occurred()) SWIG_fail;
30245 }
30246 resultobj = SWIG_Py_Void();
30247 {
30248 if (temp2)
30249 delete arg2;
30250 }
30251 return resultobj;
30252 fail:
30253 {
30254 if (temp2)
30255 delete arg2;
30256 }
30257 return NULL;
30258 }
30259
30260
30261 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30262 PyObject *resultobj = 0;
30263 wxPyApp *arg1 = (wxPyApp *) 0 ;
30264 wxAppTraits *result = 0 ;
30265 void *argp1 = 0 ;
30266 int res1 = 0 ;
30267 PyObject *swig_obj[1] ;
30268
30269 if (!args) SWIG_fail;
30270 swig_obj[0] = args;
30271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30272 if (!SWIG_IsOK(res1)) {
30273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30274 }
30275 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30276 {
30277 PyThreadState* __tstate = wxPyBeginAllowThreads();
30278 result = (wxAppTraits *)(arg1)->GetTraits();
30279 wxPyEndAllowThreads(__tstate);
30280 if (PyErr_Occurred()) SWIG_fail;
30281 }
30282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30283 return resultobj;
30284 fail:
30285 return NULL;
30286 }
30287
30288
30289 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30290 PyObject *resultobj = 0;
30291 wxPyApp *arg1 = (wxPyApp *) 0 ;
30292 void *argp1 = 0 ;
30293 int res1 = 0 ;
30294 PyObject *swig_obj[1] ;
30295
30296 if (!args) SWIG_fail;
30297 swig_obj[0] = args;
30298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30299 if (!SWIG_IsOK(res1)) {
30300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30301 }
30302 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30303 {
30304 PyThreadState* __tstate = wxPyBeginAllowThreads();
30305 (arg1)->ProcessPendingEvents();
30306 wxPyEndAllowThreads(__tstate);
30307 if (PyErr_Occurred()) SWIG_fail;
30308 }
30309 resultobj = SWIG_Py_Void();
30310 return resultobj;
30311 fail:
30312 return NULL;
30313 }
30314
30315
30316 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30317 PyObject *resultobj = 0;
30318 wxPyApp *arg1 = (wxPyApp *) 0 ;
30319 bool arg2 = (bool) false ;
30320 bool result;
30321 void *argp1 = 0 ;
30322 int res1 = 0 ;
30323 bool val2 ;
30324 int ecode2 = 0 ;
30325 PyObject * obj0 = 0 ;
30326 PyObject * obj1 = 0 ;
30327 char * kwnames[] = {
30328 (char *) "self",(char *) "onlyIfNeeded", NULL
30329 };
30330
30331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30333 if (!SWIG_IsOK(res1)) {
30334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30335 }
30336 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30337 if (obj1) {
30338 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30339 if (!SWIG_IsOK(ecode2)) {
30340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30341 }
30342 arg2 = static_cast< bool >(val2);
30343 }
30344 {
30345 PyThreadState* __tstate = wxPyBeginAllowThreads();
30346 result = (bool)(arg1)->Yield(arg2);
30347 wxPyEndAllowThreads(__tstate);
30348 if (PyErr_Occurred()) SWIG_fail;
30349 }
30350 {
30351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30352 }
30353 return resultobj;
30354 fail:
30355 return NULL;
30356 }
30357
30358
30359 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30360 PyObject *resultobj = 0;
30361 wxPyApp *arg1 = (wxPyApp *) 0 ;
30362 void *argp1 = 0 ;
30363 int res1 = 0 ;
30364 PyObject *swig_obj[1] ;
30365
30366 if (!args) SWIG_fail;
30367 swig_obj[0] = args;
30368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30369 if (!SWIG_IsOK(res1)) {
30370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30371 }
30372 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30373 {
30374 PyThreadState* __tstate = wxPyBeginAllowThreads();
30375 (arg1)->WakeUpIdle();
30376 wxPyEndAllowThreads(__tstate);
30377 if (PyErr_Occurred()) SWIG_fail;
30378 }
30379 resultobj = SWIG_Py_Void();
30380 return resultobj;
30381 fail:
30382 return NULL;
30383 }
30384
30385
30386 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30387 PyObject *resultobj = 0;
30388 bool result;
30389
30390 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30391 {
30392 PyThreadState* __tstate = wxPyBeginAllowThreads();
30393 result = (bool)wxPyApp::IsMainLoopRunning();
30394 wxPyEndAllowThreads(__tstate);
30395 if (PyErr_Occurred()) SWIG_fail;
30396 }
30397 {
30398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30399 }
30400 return resultobj;
30401 fail:
30402 return NULL;
30403 }
30404
30405
30406 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30407 PyObject *resultobj = 0;
30408 wxPyApp *arg1 = (wxPyApp *) 0 ;
30409 int result;
30410 void *argp1 = 0 ;
30411 int res1 = 0 ;
30412 PyObject *swig_obj[1] ;
30413
30414 if (!args) SWIG_fail;
30415 swig_obj[0] = args;
30416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30417 if (!SWIG_IsOK(res1)) {
30418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30419 }
30420 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30421 {
30422 PyThreadState* __tstate = wxPyBeginAllowThreads();
30423 result = (int)(arg1)->MainLoop();
30424 wxPyEndAllowThreads(__tstate);
30425 if (PyErr_Occurred()) SWIG_fail;
30426 }
30427 resultobj = SWIG_From_int(static_cast< int >(result));
30428 return resultobj;
30429 fail:
30430 return NULL;
30431 }
30432
30433
30434 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30435 PyObject *resultobj = 0;
30436 wxPyApp *arg1 = (wxPyApp *) 0 ;
30437 void *argp1 = 0 ;
30438 int res1 = 0 ;
30439 PyObject *swig_obj[1] ;
30440
30441 if (!args) SWIG_fail;
30442 swig_obj[0] = args;
30443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30444 if (!SWIG_IsOK(res1)) {
30445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30446 }
30447 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30448 {
30449 PyThreadState* __tstate = wxPyBeginAllowThreads();
30450 (arg1)->Exit();
30451 wxPyEndAllowThreads(__tstate);
30452 if (PyErr_Occurred()) SWIG_fail;
30453 }
30454 resultobj = SWIG_Py_Void();
30455 return resultobj;
30456 fail:
30457 return NULL;
30458 }
30459
30460
30461 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30462 PyObject *resultobj = 0;
30463 wxPyApp *arg1 = (wxPyApp *) 0 ;
30464 wxLayoutDirection result;
30465 void *argp1 = 0 ;
30466 int res1 = 0 ;
30467 PyObject *swig_obj[1] ;
30468
30469 if (!args) SWIG_fail;
30470 swig_obj[0] = args;
30471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30472 if (!SWIG_IsOK(res1)) {
30473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30474 }
30475 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30476 {
30477 PyThreadState* __tstate = wxPyBeginAllowThreads();
30478 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30479 wxPyEndAllowThreads(__tstate);
30480 if (PyErr_Occurred()) SWIG_fail;
30481 }
30482 resultobj = SWIG_From_int(static_cast< int >(result));
30483 return resultobj;
30484 fail:
30485 return NULL;
30486 }
30487
30488
30489 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30490 PyObject *resultobj = 0;
30491 wxPyApp *arg1 = (wxPyApp *) 0 ;
30492 void *argp1 = 0 ;
30493 int res1 = 0 ;
30494 PyObject *swig_obj[1] ;
30495
30496 if (!args) SWIG_fail;
30497 swig_obj[0] = args;
30498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30499 if (!SWIG_IsOK(res1)) {
30500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30501 }
30502 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30503 {
30504 PyThreadState* __tstate = wxPyBeginAllowThreads();
30505 (arg1)->ExitMainLoop();
30506 wxPyEndAllowThreads(__tstate);
30507 if (PyErr_Occurred()) SWIG_fail;
30508 }
30509 resultobj = SWIG_Py_Void();
30510 return resultobj;
30511 fail:
30512 return NULL;
30513 }
30514
30515
30516 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30517 PyObject *resultobj = 0;
30518 wxPyApp *arg1 = (wxPyApp *) 0 ;
30519 bool result;
30520 void *argp1 = 0 ;
30521 int res1 = 0 ;
30522 PyObject *swig_obj[1] ;
30523
30524 if (!args) SWIG_fail;
30525 swig_obj[0] = args;
30526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30527 if (!SWIG_IsOK(res1)) {
30528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30529 }
30530 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30531 {
30532 PyThreadState* __tstate = wxPyBeginAllowThreads();
30533 result = (bool)(arg1)->Pending();
30534 wxPyEndAllowThreads(__tstate);
30535 if (PyErr_Occurred()) SWIG_fail;
30536 }
30537 {
30538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30539 }
30540 return resultobj;
30541 fail:
30542 return NULL;
30543 }
30544
30545
30546 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30547 PyObject *resultobj = 0;
30548 wxPyApp *arg1 = (wxPyApp *) 0 ;
30549 bool result;
30550 void *argp1 = 0 ;
30551 int res1 = 0 ;
30552 PyObject *swig_obj[1] ;
30553
30554 if (!args) SWIG_fail;
30555 swig_obj[0] = args;
30556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30557 if (!SWIG_IsOK(res1)) {
30558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30559 }
30560 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30561 {
30562 PyThreadState* __tstate = wxPyBeginAllowThreads();
30563 result = (bool)(arg1)->Dispatch();
30564 wxPyEndAllowThreads(__tstate);
30565 if (PyErr_Occurred()) SWIG_fail;
30566 }
30567 {
30568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30569 }
30570 return resultobj;
30571 fail:
30572 return NULL;
30573 }
30574
30575
30576 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30577 PyObject *resultobj = 0;
30578 wxPyApp *arg1 = (wxPyApp *) 0 ;
30579 bool result;
30580 void *argp1 = 0 ;
30581 int res1 = 0 ;
30582 PyObject *swig_obj[1] ;
30583
30584 if (!args) SWIG_fail;
30585 swig_obj[0] = args;
30586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30587 if (!SWIG_IsOK(res1)) {
30588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30589 }
30590 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30591 {
30592 PyThreadState* __tstate = wxPyBeginAllowThreads();
30593 result = (bool)(arg1)->ProcessIdle();
30594 wxPyEndAllowThreads(__tstate);
30595 if (PyErr_Occurred()) SWIG_fail;
30596 }
30597 {
30598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30599 }
30600 return resultobj;
30601 fail:
30602 return NULL;
30603 }
30604
30605
30606 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30607 PyObject *resultobj = 0;
30608 wxPyApp *arg1 = (wxPyApp *) 0 ;
30609 wxWindow *arg2 = (wxWindow *) 0 ;
30610 wxIdleEvent *arg3 = 0 ;
30611 bool result;
30612 void *argp1 = 0 ;
30613 int res1 = 0 ;
30614 void *argp2 = 0 ;
30615 int res2 = 0 ;
30616 void *argp3 = 0 ;
30617 int res3 = 0 ;
30618 PyObject * obj0 = 0 ;
30619 PyObject * obj1 = 0 ;
30620 PyObject * obj2 = 0 ;
30621 char * kwnames[] = {
30622 (char *) "self",(char *) "win",(char *) "event", NULL
30623 };
30624
30625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30627 if (!SWIG_IsOK(res1)) {
30628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30629 }
30630 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30631 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30632 if (!SWIG_IsOK(res2)) {
30633 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30634 }
30635 arg2 = reinterpret_cast< wxWindow * >(argp2);
30636 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30637 if (!SWIG_IsOK(res3)) {
30638 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30639 }
30640 if (!argp3) {
30641 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30642 }
30643 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30644 {
30645 PyThreadState* __tstate = wxPyBeginAllowThreads();
30646 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30647 wxPyEndAllowThreads(__tstate);
30648 if (PyErr_Occurred()) SWIG_fail;
30649 }
30650 {
30651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30652 }
30653 return resultobj;
30654 fail:
30655 return NULL;
30656 }
30657
30658
30659 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30660 PyObject *resultobj = 0;
30661 wxPyApp *arg1 = (wxPyApp *) 0 ;
30662 bool result;
30663 void *argp1 = 0 ;
30664 int res1 = 0 ;
30665 PyObject *swig_obj[1] ;
30666
30667 if (!args) SWIG_fail;
30668 swig_obj[0] = args;
30669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30670 if (!SWIG_IsOK(res1)) {
30671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30672 }
30673 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30674 {
30675 PyThreadState* __tstate = wxPyBeginAllowThreads();
30676 result = (bool)((wxPyApp const *)arg1)->IsActive();
30677 wxPyEndAllowThreads(__tstate);
30678 if (PyErr_Occurred()) SWIG_fail;
30679 }
30680 {
30681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30682 }
30683 return resultobj;
30684 fail:
30685 return NULL;
30686 }
30687
30688
30689 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30690 PyObject *resultobj = 0;
30691 wxPyApp *arg1 = (wxPyApp *) 0 ;
30692 wxWindow *arg2 = (wxWindow *) 0 ;
30693 void *argp1 = 0 ;
30694 int res1 = 0 ;
30695 void *argp2 = 0 ;
30696 int res2 = 0 ;
30697 PyObject * obj0 = 0 ;
30698 PyObject * obj1 = 0 ;
30699 char * kwnames[] = {
30700 (char *) "self",(char *) "win", NULL
30701 };
30702
30703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30705 if (!SWIG_IsOK(res1)) {
30706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30707 }
30708 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30709 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30710 if (!SWIG_IsOK(res2)) {
30711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30712 }
30713 arg2 = reinterpret_cast< wxWindow * >(argp2);
30714 {
30715 PyThreadState* __tstate = wxPyBeginAllowThreads();
30716 (arg1)->SetTopWindow(arg2);
30717 wxPyEndAllowThreads(__tstate);
30718 if (PyErr_Occurred()) SWIG_fail;
30719 }
30720 resultobj = SWIG_Py_Void();
30721 return resultobj;
30722 fail:
30723 return NULL;
30724 }
30725
30726
30727 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30728 PyObject *resultobj = 0;
30729 wxPyApp *arg1 = (wxPyApp *) 0 ;
30730 wxWindow *result = 0 ;
30731 void *argp1 = 0 ;
30732 int res1 = 0 ;
30733 PyObject *swig_obj[1] ;
30734
30735 if (!args) SWIG_fail;
30736 swig_obj[0] = args;
30737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30738 if (!SWIG_IsOK(res1)) {
30739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30740 }
30741 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30742 {
30743 PyThreadState* __tstate = wxPyBeginAllowThreads();
30744 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30745 wxPyEndAllowThreads(__tstate);
30746 if (PyErr_Occurred()) SWIG_fail;
30747 }
30748 {
30749 resultobj = wxPyMake_wxObject(result, (bool)0);
30750 }
30751 return resultobj;
30752 fail:
30753 return NULL;
30754 }
30755
30756
30757 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30758 PyObject *resultobj = 0;
30759 wxPyApp *arg1 = (wxPyApp *) 0 ;
30760 bool arg2 ;
30761 void *argp1 = 0 ;
30762 int res1 = 0 ;
30763 bool val2 ;
30764 int ecode2 = 0 ;
30765 PyObject * obj0 = 0 ;
30766 PyObject * obj1 = 0 ;
30767 char * kwnames[] = {
30768 (char *) "self",(char *) "flag", NULL
30769 };
30770
30771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30773 if (!SWIG_IsOK(res1)) {
30774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30775 }
30776 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30777 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30778 if (!SWIG_IsOK(ecode2)) {
30779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30780 }
30781 arg2 = static_cast< bool >(val2);
30782 {
30783 PyThreadState* __tstate = wxPyBeginAllowThreads();
30784 (arg1)->SetExitOnFrameDelete(arg2);
30785 wxPyEndAllowThreads(__tstate);
30786 if (PyErr_Occurred()) SWIG_fail;
30787 }
30788 resultobj = SWIG_Py_Void();
30789 return resultobj;
30790 fail:
30791 return NULL;
30792 }
30793
30794
30795 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30796 PyObject *resultobj = 0;
30797 wxPyApp *arg1 = (wxPyApp *) 0 ;
30798 bool result;
30799 void *argp1 = 0 ;
30800 int res1 = 0 ;
30801 PyObject *swig_obj[1] ;
30802
30803 if (!args) SWIG_fail;
30804 swig_obj[0] = args;
30805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30806 if (!SWIG_IsOK(res1)) {
30807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30808 }
30809 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30810 {
30811 PyThreadState* __tstate = wxPyBeginAllowThreads();
30812 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30813 wxPyEndAllowThreads(__tstate);
30814 if (PyErr_Occurred()) SWIG_fail;
30815 }
30816 {
30817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30818 }
30819 return resultobj;
30820 fail:
30821 return NULL;
30822 }
30823
30824
30825 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30826 PyObject *resultobj = 0;
30827 wxPyApp *arg1 = (wxPyApp *) 0 ;
30828 bool arg2 ;
30829 void *argp1 = 0 ;
30830 int res1 = 0 ;
30831 bool val2 ;
30832 int ecode2 = 0 ;
30833 PyObject * obj0 = 0 ;
30834 PyObject * obj1 = 0 ;
30835 char * kwnames[] = {
30836 (char *) "self",(char *) "flag", NULL
30837 };
30838
30839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
30840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30841 if (!SWIG_IsOK(res1)) {
30842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
30843 }
30844 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30845 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30846 if (!SWIG_IsOK(ecode2)) {
30847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
30848 }
30849 arg2 = static_cast< bool >(val2);
30850 {
30851 PyThreadState* __tstate = wxPyBeginAllowThreads();
30852 (arg1)->SetUseBestVisual(arg2);
30853 wxPyEndAllowThreads(__tstate);
30854 if (PyErr_Occurred()) SWIG_fail;
30855 }
30856 resultobj = SWIG_Py_Void();
30857 return resultobj;
30858 fail:
30859 return NULL;
30860 }
30861
30862
30863 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30864 PyObject *resultobj = 0;
30865 wxPyApp *arg1 = (wxPyApp *) 0 ;
30866 bool result;
30867 void *argp1 = 0 ;
30868 int res1 = 0 ;
30869 PyObject *swig_obj[1] ;
30870
30871 if (!args) SWIG_fail;
30872 swig_obj[0] = args;
30873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30874 if (!SWIG_IsOK(res1)) {
30875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30876 }
30877 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30878 {
30879 PyThreadState* __tstate = wxPyBeginAllowThreads();
30880 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
30881 wxPyEndAllowThreads(__tstate);
30882 if (PyErr_Occurred()) SWIG_fail;
30883 }
30884 {
30885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30886 }
30887 return resultobj;
30888 fail:
30889 return NULL;
30890 }
30891
30892
30893 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30894 PyObject *resultobj = 0;
30895 wxPyApp *arg1 = (wxPyApp *) 0 ;
30896 int arg2 ;
30897 void *argp1 = 0 ;
30898 int res1 = 0 ;
30899 int val2 ;
30900 int ecode2 = 0 ;
30901 PyObject * obj0 = 0 ;
30902 PyObject * obj1 = 0 ;
30903 char * kwnames[] = {
30904 (char *) "self",(char *) "mode", NULL
30905 };
30906
30907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
30908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30909 if (!SWIG_IsOK(res1)) {
30910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30911 }
30912 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30913 ecode2 = SWIG_AsVal_int(obj1, &val2);
30914 if (!SWIG_IsOK(ecode2)) {
30915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
30916 }
30917 arg2 = static_cast< int >(val2);
30918 {
30919 PyThreadState* __tstate = wxPyBeginAllowThreads();
30920 (arg1)->SetPrintMode(arg2);
30921 wxPyEndAllowThreads(__tstate);
30922 if (PyErr_Occurred()) SWIG_fail;
30923 }
30924 resultobj = SWIG_Py_Void();
30925 return resultobj;
30926 fail:
30927 return NULL;
30928 }
30929
30930
30931 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30932 PyObject *resultobj = 0;
30933 wxPyApp *arg1 = (wxPyApp *) 0 ;
30934 int result;
30935 void *argp1 = 0 ;
30936 int res1 = 0 ;
30937 PyObject *swig_obj[1] ;
30938
30939 if (!args) SWIG_fail;
30940 swig_obj[0] = args;
30941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30942 if (!SWIG_IsOK(res1)) {
30943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30944 }
30945 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30946 {
30947 PyThreadState* __tstate = wxPyBeginAllowThreads();
30948 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
30949 wxPyEndAllowThreads(__tstate);
30950 if (PyErr_Occurred()) SWIG_fail;
30951 }
30952 resultobj = SWIG_From_int(static_cast< int >(result));
30953 return resultobj;
30954 fail:
30955 return NULL;
30956 }
30957
30958
30959 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30960 PyObject *resultobj = 0;
30961 wxPyApp *arg1 = (wxPyApp *) 0 ;
30962 int arg2 ;
30963 void *argp1 = 0 ;
30964 int res1 = 0 ;
30965 int val2 ;
30966 int ecode2 = 0 ;
30967 PyObject * obj0 = 0 ;
30968 PyObject * obj1 = 0 ;
30969 char * kwnames[] = {
30970 (char *) "self",(char *) "mode", NULL
30971 };
30972
30973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
30974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30975 if (!SWIG_IsOK(res1)) {
30976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30977 }
30978 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30979 ecode2 = SWIG_AsVal_int(obj1, &val2);
30980 if (!SWIG_IsOK(ecode2)) {
30981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
30982 }
30983 arg2 = static_cast< int >(val2);
30984 {
30985 PyThreadState* __tstate = wxPyBeginAllowThreads();
30986 (arg1)->SetAssertMode(arg2);
30987 wxPyEndAllowThreads(__tstate);
30988 if (PyErr_Occurred()) SWIG_fail;
30989 }
30990 resultobj = SWIG_Py_Void();
30991 return resultobj;
30992 fail:
30993 return NULL;
30994 }
30995
30996
30997 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30998 PyObject *resultobj = 0;
30999 wxPyApp *arg1 = (wxPyApp *) 0 ;
31000 int result;
31001 void *argp1 = 0 ;
31002 int res1 = 0 ;
31003 PyObject *swig_obj[1] ;
31004
31005 if (!args) SWIG_fail;
31006 swig_obj[0] = args;
31007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31008 if (!SWIG_IsOK(res1)) {
31009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31010 }
31011 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31012 {
31013 PyThreadState* __tstate = wxPyBeginAllowThreads();
31014 result = (int)(arg1)->GetAssertMode();
31015 wxPyEndAllowThreads(__tstate);
31016 if (PyErr_Occurred()) SWIG_fail;
31017 }
31018 resultobj = SWIG_From_int(static_cast< int >(result));
31019 return resultobj;
31020 fail:
31021 return NULL;
31022 }
31023
31024
31025 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31026 PyObject *resultobj = 0;
31027 bool result;
31028
31029 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31030 {
31031 PyThreadState* __tstate = wxPyBeginAllowThreads();
31032 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31033 wxPyEndAllowThreads(__tstate);
31034 if (PyErr_Occurred()) SWIG_fail;
31035 }
31036 {
31037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31038 }
31039 return resultobj;
31040 fail:
31041 return NULL;
31042 }
31043
31044
31045 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31046 PyObject *resultobj = 0;
31047 long result;
31048
31049 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31050 {
31051 PyThreadState* __tstate = wxPyBeginAllowThreads();
31052 result = (long)wxPyApp::GetMacAboutMenuItemId();
31053 wxPyEndAllowThreads(__tstate);
31054 if (PyErr_Occurred()) SWIG_fail;
31055 }
31056 resultobj = SWIG_From_long(static_cast< long >(result));
31057 return resultobj;
31058 fail:
31059 return NULL;
31060 }
31061
31062
31063 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31064 PyObject *resultobj = 0;
31065 long result;
31066
31067 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31068 {
31069 PyThreadState* __tstate = wxPyBeginAllowThreads();
31070 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31071 wxPyEndAllowThreads(__tstate);
31072 if (PyErr_Occurred()) SWIG_fail;
31073 }
31074 resultobj = SWIG_From_long(static_cast< long >(result));
31075 return resultobj;
31076 fail:
31077 return NULL;
31078 }
31079
31080
31081 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31082 PyObject *resultobj = 0;
31083 long result;
31084
31085 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31086 {
31087 PyThreadState* __tstate = wxPyBeginAllowThreads();
31088 result = (long)wxPyApp::GetMacExitMenuItemId();
31089 wxPyEndAllowThreads(__tstate);
31090 if (PyErr_Occurred()) SWIG_fail;
31091 }
31092 resultobj = SWIG_From_long(static_cast< long >(result));
31093 return resultobj;
31094 fail:
31095 return NULL;
31096 }
31097
31098
31099 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31100 PyObject *resultobj = 0;
31101 wxString result;
31102
31103 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31104 {
31105 PyThreadState* __tstate = wxPyBeginAllowThreads();
31106 result = wxPyApp::GetMacHelpMenuTitleName();
31107 wxPyEndAllowThreads(__tstate);
31108 if (PyErr_Occurred()) SWIG_fail;
31109 }
31110 {
31111 #if wxUSE_UNICODE
31112 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31113 #else
31114 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31115 #endif
31116 }
31117 return resultobj;
31118 fail:
31119 return NULL;
31120 }
31121
31122
31123 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31124 PyObject *resultobj = 0;
31125 bool arg1 ;
31126 bool val1 ;
31127 int ecode1 = 0 ;
31128 PyObject * obj0 = 0 ;
31129 char * kwnames[] = {
31130 (char *) "val", NULL
31131 };
31132
31133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31134 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31135 if (!SWIG_IsOK(ecode1)) {
31136 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31137 }
31138 arg1 = static_cast< bool >(val1);
31139 {
31140 PyThreadState* __tstate = wxPyBeginAllowThreads();
31141 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31142 wxPyEndAllowThreads(__tstate);
31143 if (PyErr_Occurred()) SWIG_fail;
31144 }
31145 resultobj = SWIG_Py_Void();
31146 return resultobj;
31147 fail:
31148 return NULL;
31149 }
31150
31151
31152 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31153 PyObject *resultobj = 0;
31154 long arg1 ;
31155 long val1 ;
31156 int ecode1 = 0 ;
31157 PyObject * obj0 = 0 ;
31158 char * kwnames[] = {
31159 (char *) "val", NULL
31160 };
31161
31162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31163 ecode1 = SWIG_AsVal_long(obj0, &val1);
31164 if (!SWIG_IsOK(ecode1)) {
31165 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31166 }
31167 arg1 = static_cast< long >(val1);
31168 {
31169 PyThreadState* __tstate = wxPyBeginAllowThreads();
31170 wxPyApp::SetMacAboutMenuItemId(arg1);
31171 wxPyEndAllowThreads(__tstate);
31172 if (PyErr_Occurred()) SWIG_fail;
31173 }
31174 resultobj = SWIG_Py_Void();
31175 return resultobj;
31176 fail:
31177 return NULL;
31178 }
31179
31180
31181 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31182 PyObject *resultobj = 0;
31183 long arg1 ;
31184 long val1 ;
31185 int ecode1 = 0 ;
31186 PyObject * obj0 = 0 ;
31187 char * kwnames[] = {
31188 (char *) "val", NULL
31189 };
31190
31191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31192 ecode1 = SWIG_AsVal_long(obj0, &val1);
31193 if (!SWIG_IsOK(ecode1)) {
31194 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31195 }
31196 arg1 = static_cast< long >(val1);
31197 {
31198 PyThreadState* __tstate = wxPyBeginAllowThreads();
31199 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31200 wxPyEndAllowThreads(__tstate);
31201 if (PyErr_Occurred()) SWIG_fail;
31202 }
31203 resultobj = SWIG_Py_Void();
31204 return resultobj;
31205 fail:
31206 return NULL;
31207 }
31208
31209
31210 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31211 PyObject *resultobj = 0;
31212 long arg1 ;
31213 long val1 ;
31214 int ecode1 = 0 ;
31215 PyObject * obj0 = 0 ;
31216 char * kwnames[] = {
31217 (char *) "val", NULL
31218 };
31219
31220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31221 ecode1 = SWIG_AsVal_long(obj0, &val1);
31222 if (!SWIG_IsOK(ecode1)) {
31223 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31224 }
31225 arg1 = static_cast< long >(val1);
31226 {
31227 PyThreadState* __tstate = wxPyBeginAllowThreads();
31228 wxPyApp::SetMacExitMenuItemId(arg1);
31229 wxPyEndAllowThreads(__tstate);
31230 if (PyErr_Occurred()) SWIG_fail;
31231 }
31232 resultobj = SWIG_Py_Void();
31233 return resultobj;
31234 fail:
31235 return NULL;
31236 }
31237
31238
31239 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31240 PyObject *resultobj = 0;
31241 wxString *arg1 = 0 ;
31242 bool temp1 = false ;
31243 PyObject * obj0 = 0 ;
31244 char * kwnames[] = {
31245 (char *) "val", NULL
31246 };
31247
31248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31249 {
31250 arg1 = wxString_in_helper(obj0);
31251 if (arg1 == NULL) SWIG_fail;
31252 temp1 = true;
31253 }
31254 {
31255 PyThreadState* __tstate = wxPyBeginAllowThreads();
31256 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31257 wxPyEndAllowThreads(__tstate);
31258 if (PyErr_Occurred()) SWIG_fail;
31259 }
31260 resultobj = SWIG_Py_Void();
31261 {
31262 if (temp1)
31263 delete arg1;
31264 }
31265 return resultobj;
31266 fail:
31267 {
31268 if (temp1)
31269 delete arg1;
31270 }
31271 return NULL;
31272 }
31273
31274
31275 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31276 PyObject *resultobj = 0;
31277 wxPyApp *arg1 = (wxPyApp *) 0 ;
31278 void *argp1 = 0 ;
31279 int res1 = 0 ;
31280 PyObject *swig_obj[1] ;
31281
31282 if (!args) SWIG_fail;
31283 swig_obj[0] = args;
31284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31285 if (!SWIG_IsOK(res1)) {
31286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31287 }
31288 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31289 {
31290 PyThreadState* __tstate = wxPyBeginAllowThreads();
31291 (arg1)->_BootstrapApp();
31292 wxPyEndAllowThreads(__tstate);
31293 if (PyErr_Occurred()) SWIG_fail;
31294 }
31295 resultobj = SWIG_Py_Void();
31296 return resultobj;
31297 fail:
31298 return NULL;
31299 }
31300
31301
31302 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31303 PyObject *resultobj = 0;
31304 int result;
31305
31306 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31307 {
31308 PyThreadState* __tstate = wxPyBeginAllowThreads();
31309 result = (int)wxPyApp_GetComCtl32Version();
31310 wxPyEndAllowThreads(__tstate);
31311 if (PyErr_Occurred()) SWIG_fail;
31312 }
31313 resultobj = SWIG_From_int(static_cast< int >(result));
31314 return resultobj;
31315 fail:
31316 return NULL;
31317 }
31318
31319
31320 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31321 PyObject *resultobj = 0;
31322 bool result;
31323
31324 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31325 {
31326 PyThreadState* __tstate = wxPyBeginAllowThreads();
31327 result = (bool)wxPyApp_IsDisplayAvailable();
31328 wxPyEndAllowThreads(__tstate);
31329 if (PyErr_Occurred()) SWIG_fail;
31330 }
31331 {
31332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31333 }
31334 return resultobj;
31335 fail:
31336 return NULL;
31337 }
31338
31339
31340 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31341 PyObject *obj;
31342 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31343 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31344 return SWIG_Py_Void();
31345 }
31346
31347 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31348 return SWIG_Python_InitShadowInstance(args);
31349 }
31350
31351 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31352 PyObject *resultobj = 0;
31353
31354 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31355 {
31356 PyThreadState* __tstate = wxPyBeginAllowThreads();
31357 wxExit();
31358 wxPyEndAllowThreads(__tstate);
31359 if (PyErr_Occurred()) SWIG_fail;
31360 }
31361 resultobj = SWIG_Py_Void();
31362 return resultobj;
31363 fail:
31364 return NULL;
31365 }
31366
31367
31368 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31369 PyObject *resultobj = 0;
31370 bool result;
31371
31372 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31373 {
31374 PyThreadState* __tstate = wxPyBeginAllowThreads();
31375 result = (bool)wxYield();
31376 wxPyEndAllowThreads(__tstate);
31377 if (PyErr_Occurred()) SWIG_fail;
31378 }
31379 {
31380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31381 }
31382 return resultobj;
31383 fail:
31384 return NULL;
31385 }
31386
31387
31388 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31389 PyObject *resultobj = 0;
31390 bool result;
31391
31392 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31393 {
31394 PyThreadState* __tstate = wxPyBeginAllowThreads();
31395 result = (bool)wxYieldIfNeeded();
31396 wxPyEndAllowThreads(__tstate);
31397 if (PyErr_Occurred()) SWIG_fail;
31398 }
31399 {
31400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31401 }
31402 return resultobj;
31403 fail:
31404 return NULL;
31405 }
31406
31407
31408 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31409 PyObject *resultobj = 0;
31410 wxWindow *arg1 = (wxWindow *) NULL ;
31411 bool arg2 = (bool) false ;
31412 bool result;
31413 void *argp1 = 0 ;
31414 int res1 = 0 ;
31415 bool val2 ;
31416 int ecode2 = 0 ;
31417 PyObject * obj0 = 0 ;
31418 PyObject * obj1 = 0 ;
31419 char * kwnames[] = {
31420 (char *) "win",(char *) "onlyIfNeeded", NULL
31421 };
31422
31423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31424 if (obj0) {
31425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31426 if (!SWIG_IsOK(res1)) {
31427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31428 }
31429 arg1 = reinterpret_cast< wxWindow * >(argp1);
31430 }
31431 if (obj1) {
31432 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31433 if (!SWIG_IsOK(ecode2)) {
31434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31435 }
31436 arg2 = static_cast< bool >(val2);
31437 }
31438 {
31439 PyThreadState* __tstate = wxPyBeginAllowThreads();
31440 result = (bool)wxSafeYield(arg1,arg2);
31441 wxPyEndAllowThreads(__tstate);
31442 if (PyErr_Occurred()) SWIG_fail;
31443 }
31444 {
31445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31446 }
31447 return resultobj;
31448 fail:
31449 return NULL;
31450 }
31451
31452
31453 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31454 PyObject *resultobj = 0;
31455
31456 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31457 {
31458 PyThreadState* __tstate = wxPyBeginAllowThreads();
31459 wxWakeUpIdle();
31460 wxPyEndAllowThreads(__tstate);
31461 if (PyErr_Occurred()) SWIG_fail;
31462 }
31463 resultobj = SWIG_Py_Void();
31464 return resultobj;
31465 fail:
31466 return NULL;
31467 }
31468
31469
31470 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31471 PyObject *resultobj = 0;
31472 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31473 wxEvent *arg2 = 0 ;
31474 void *argp1 = 0 ;
31475 int res1 = 0 ;
31476 void *argp2 = 0 ;
31477 int res2 = 0 ;
31478 PyObject * obj0 = 0 ;
31479 PyObject * obj1 = 0 ;
31480 char * kwnames[] = {
31481 (char *) "dest",(char *) "event", NULL
31482 };
31483
31484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31486 if (!SWIG_IsOK(res1)) {
31487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31488 }
31489 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31490 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31491 if (!SWIG_IsOK(res2)) {
31492 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31493 }
31494 if (!argp2) {
31495 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31496 }
31497 arg2 = reinterpret_cast< wxEvent * >(argp2);
31498 {
31499 PyThreadState* __tstate = wxPyBeginAllowThreads();
31500 wxPostEvent(arg1,*arg2);
31501 wxPyEndAllowThreads(__tstate);
31502 if (PyErr_Occurred()) SWIG_fail;
31503 }
31504 resultobj = SWIG_Py_Void();
31505 return resultobj;
31506 fail:
31507 return NULL;
31508 }
31509
31510
31511 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31512 PyObject *resultobj = 0;
31513
31514 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31515 {
31516 PyThreadState* __tstate = wxPyBeginAllowThreads();
31517 wxApp_CleanUp();
31518 wxPyEndAllowThreads(__tstate);
31519 if (PyErr_Occurred()) SWIG_fail;
31520 }
31521 resultobj = SWIG_Py_Void();
31522 return resultobj;
31523 fail:
31524 return NULL;
31525 }
31526
31527
31528 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31529 PyObject *resultobj = 0;
31530 wxPyApp *result = 0 ;
31531
31532 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31533 {
31534 PyThreadState* __tstate = wxPyBeginAllowThreads();
31535 result = (wxPyApp *)wxPyGetApp();
31536 wxPyEndAllowThreads(__tstate);
31537 if (PyErr_Occurred()) SWIG_fail;
31538 }
31539 {
31540 resultobj = wxPyMake_wxObject(result, 0);
31541 }
31542 return resultobj;
31543 fail:
31544 return NULL;
31545 }
31546
31547
31548 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31549 PyObject *resultobj = 0;
31550 char *arg1 = (char *) 0 ;
31551 int res1 ;
31552 char *buf1 = 0 ;
31553 int alloc1 = 0 ;
31554 PyObject * obj0 = 0 ;
31555 char * kwnames[] = {
31556 (char *) "encoding", NULL
31557 };
31558
31559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31560 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31561 if (!SWIG_IsOK(res1)) {
31562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31563 }
31564 arg1 = buf1;
31565 {
31566 PyThreadState* __tstate = wxPyBeginAllowThreads();
31567 wxSetDefaultPyEncoding((char const *)arg1);
31568 wxPyEndAllowThreads(__tstate);
31569 if (PyErr_Occurred()) SWIG_fail;
31570 }
31571 resultobj = SWIG_Py_Void();
31572 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31573 return resultobj;
31574 fail:
31575 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31576 return NULL;
31577 }
31578
31579
31580 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31581 PyObject *resultobj = 0;
31582 char *result = 0 ;
31583
31584 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31585 {
31586 PyThreadState* __tstate = wxPyBeginAllowThreads();
31587 result = (char *)wxGetDefaultPyEncoding();
31588 wxPyEndAllowThreads(__tstate);
31589 if (PyErr_Occurred()) SWIG_fail;
31590 }
31591 resultobj = SWIG_FromCharPtr(result);
31592 return resultobj;
31593 fail:
31594 return NULL;
31595 }
31596
31597
31598 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31599 PyObject *resultobj = 0;
31600 wxEventLoop *result = 0 ;
31601
31602 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31603 {
31604 PyThreadState* __tstate = wxPyBeginAllowThreads();
31605 result = (wxEventLoop *)new wxEventLoop();
31606 wxPyEndAllowThreads(__tstate);
31607 if (PyErr_Occurred()) SWIG_fail;
31608 }
31609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31610 return resultobj;
31611 fail:
31612 return NULL;
31613 }
31614
31615
31616 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31617 PyObject *resultobj = 0;
31618 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31619 void *argp1 = 0 ;
31620 int res1 = 0 ;
31621 PyObject *swig_obj[1] ;
31622
31623 if (!args) SWIG_fail;
31624 swig_obj[0] = args;
31625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31626 if (!SWIG_IsOK(res1)) {
31627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31628 }
31629 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31630 {
31631 PyThreadState* __tstate = wxPyBeginAllowThreads();
31632 delete arg1;
31633
31634 wxPyEndAllowThreads(__tstate);
31635 if (PyErr_Occurred()) SWIG_fail;
31636 }
31637 resultobj = SWIG_Py_Void();
31638 return resultobj;
31639 fail:
31640 return NULL;
31641 }
31642
31643
31644 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31645 PyObject *resultobj = 0;
31646 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31647 int result;
31648 void *argp1 = 0 ;
31649 int res1 = 0 ;
31650 PyObject *swig_obj[1] ;
31651
31652 if (!args) SWIG_fail;
31653 swig_obj[0] = args;
31654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31655 if (!SWIG_IsOK(res1)) {
31656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31657 }
31658 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31659 {
31660 PyThreadState* __tstate = wxPyBeginAllowThreads();
31661 result = (int)(arg1)->Run();
31662 wxPyEndAllowThreads(__tstate);
31663 if (PyErr_Occurred()) SWIG_fail;
31664 }
31665 resultobj = SWIG_From_int(static_cast< int >(result));
31666 return resultobj;
31667 fail:
31668 return NULL;
31669 }
31670
31671
31672 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31673 PyObject *resultobj = 0;
31674 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31675 int arg2 = (int) 0 ;
31676 void *argp1 = 0 ;
31677 int res1 = 0 ;
31678 int val2 ;
31679 int ecode2 = 0 ;
31680 PyObject * obj0 = 0 ;
31681 PyObject * obj1 = 0 ;
31682 char * kwnames[] = {
31683 (char *) "self",(char *) "rc", NULL
31684 };
31685
31686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31688 if (!SWIG_IsOK(res1)) {
31689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31690 }
31691 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31692 if (obj1) {
31693 ecode2 = SWIG_AsVal_int(obj1, &val2);
31694 if (!SWIG_IsOK(ecode2)) {
31695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31696 }
31697 arg2 = static_cast< int >(val2);
31698 }
31699 {
31700 PyThreadState* __tstate = wxPyBeginAllowThreads();
31701 (arg1)->Exit(arg2);
31702 wxPyEndAllowThreads(__tstate);
31703 if (PyErr_Occurred()) SWIG_fail;
31704 }
31705 resultobj = SWIG_Py_Void();
31706 return resultobj;
31707 fail:
31708 return NULL;
31709 }
31710
31711
31712 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31713 PyObject *resultobj = 0;
31714 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31715 bool result;
31716 void *argp1 = 0 ;
31717 int res1 = 0 ;
31718 PyObject *swig_obj[1] ;
31719
31720 if (!args) SWIG_fail;
31721 swig_obj[0] = args;
31722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31723 if (!SWIG_IsOK(res1)) {
31724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31725 }
31726 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31727 {
31728 PyThreadState* __tstate = wxPyBeginAllowThreads();
31729 result = (bool)((wxEventLoop const *)arg1)->Pending();
31730 wxPyEndAllowThreads(__tstate);
31731 if (PyErr_Occurred()) SWIG_fail;
31732 }
31733 {
31734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31735 }
31736 return resultobj;
31737 fail:
31738 return NULL;
31739 }
31740
31741
31742 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31743 PyObject *resultobj = 0;
31744 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31745 bool result;
31746 void *argp1 = 0 ;
31747 int res1 = 0 ;
31748 PyObject *swig_obj[1] ;
31749
31750 if (!args) SWIG_fail;
31751 swig_obj[0] = args;
31752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31753 if (!SWIG_IsOK(res1)) {
31754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31755 }
31756 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31757 {
31758 PyThreadState* __tstate = wxPyBeginAllowThreads();
31759 result = (bool)(arg1)->Dispatch();
31760 wxPyEndAllowThreads(__tstate);
31761 if (PyErr_Occurred()) SWIG_fail;
31762 }
31763 {
31764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31765 }
31766 return resultobj;
31767 fail:
31768 return NULL;
31769 }
31770
31771
31772 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31773 PyObject *resultobj = 0;
31774 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31775 bool result;
31776 void *argp1 = 0 ;
31777 int res1 = 0 ;
31778 PyObject *swig_obj[1] ;
31779
31780 if (!args) SWIG_fail;
31781 swig_obj[0] = args;
31782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31783 if (!SWIG_IsOK(res1)) {
31784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31785 }
31786 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31787 {
31788 PyThreadState* __tstate = wxPyBeginAllowThreads();
31789 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31790 wxPyEndAllowThreads(__tstate);
31791 if (PyErr_Occurred()) SWIG_fail;
31792 }
31793 {
31794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31795 }
31796 return resultobj;
31797 fail:
31798 return NULL;
31799 }
31800
31801
31802 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31803 PyObject *resultobj = 0;
31804 wxEventLoop *result = 0 ;
31805
31806 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31807 {
31808 PyThreadState* __tstate = wxPyBeginAllowThreads();
31809 result = (wxEventLoop *)wxEventLoop::GetActive();
31810 wxPyEndAllowThreads(__tstate);
31811 if (PyErr_Occurred()) SWIG_fail;
31812 }
31813 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
31814 return resultobj;
31815 fail:
31816 return NULL;
31817 }
31818
31819
31820 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31821 PyObject *resultobj = 0;
31822 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31823 void *argp1 = 0 ;
31824 int res1 = 0 ;
31825 PyObject * obj0 = 0 ;
31826 char * kwnames[] = {
31827 (char *) "loop", NULL
31828 };
31829
31830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
31831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31832 if (!SWIG_IsOK(res1)) {
31833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31834 }
31835 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31836 {
31837 PyThreadState* __tstate = wxPyBeginAllowThreads();
31838 wxEventLoop::SetActive(arg1);
31839 wxPyEndAllowThreads(__tstate);
31840 if (PyErr_Occurred()) SWIG_fail;
31841 }
31842 resultobj = SWIG_Py_Void();
31843 return resultobj;
31844 fail:
31845 return NULL;
31846 }
31847
31848
31849 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31850 PyObject *obj;
31851 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31852 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
31853 return SWIG_Py_Void();
31854 }
31855
31856 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31857 return SWIG_Python_InitShadowInstance(args);
31858 }
31859
31860 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31861 PyObject *resultobj = 0;
31862 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31863 wxEventLoopActivator *result = 0 ;
31864 void *argp1 = 0 ;
31865 int res1 = 0 ;
31866 PyObject * obj0 = 0 ;
31867 char * kwnames[] = {
31868 (char *) "evtLoop", NULL
31869 };
31870
31871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
31872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31873 if (!SWIG_IsOK(res1)) {
31874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31875 }
31876 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31877 {
31878 PyThreadState* __tstate = wxPyBeginAllowThreads();
31879 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
31880 wxPyEndAllowThreads(__tstate);
31881 if (PyErr_Occurred()) SWIG_fail;
31882 }
31883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
31884 return resultobj;
31885 fail:
31886 return NULL;
31887 }
31888
31889
31890 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31891 PyObject *resultobj = 0;
31892 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
31893 void *argp1 = 0 ;
31894 int res1 = 0 ;
31895 PyObject *swig_obj[1] ;
31896
31897 if (!args) SWIG_fail;
31898 swig_obj[0] = args;
31899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
31900 if (!SWIG_IsOK(res1)) {
31901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
31902 }
31903 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
31904 {
31905 PyThreadState* __tstate = wxPyBeginAllowThreads();
31906 delete arg1;
31907
31908 wxPyEndAllowThreads(__tstate);
31909 if (PyErr_Occurred()) SWIG_fail;
31910 }
31911 resultobj = SWIG_Py_Void();
31912 return resultobj;
31913 fail:
31914 return NULL;
31915 }
31916
31917
31918 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31919 PyObject *obj;
31920 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31921 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
31922 return SWIG_Py_Void();
31923 }
31924
31925 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31926 return SWIG_Python_InitShadowInstance(args);
31927 }
31928
31929 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31930 PyObject *resultobj = 0;
31931 int arg1 = (int) 0 ;
31932 int arg2 = (int) 0 ;
31933 int arg3 = (int) 0 ;
31934 wxAcceleratorEntry *result = 0 ;
31935 int val1 ;
31936 int ecode1 = 0 ;
31937 int val2 ;
31938 int ecode2 = 0 ;
31939 int val3 ;
31940 int ecode3 = 0 ;
31941 PyObject * obj0 = 0 ;
31942 PyObject * obj1 = 0 ;
31943 PyObject * obj2 = 0 ;
31944 char * kwnames[] = {
31945 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
31946 };
31947
31948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31949 if (obj0) {
31950 ecode1 = SWIG_AsVal_int(obj0, &val1);
31951 if (!SWIG_IsOK(ecode1)) {
31952 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
31953 }
31954 arg1 = static_cast< int >(val1);
31955 }
31956 if (obj1) {
31957 ecode2 = SWIG_AsVal_int(obj1, &val2);
31958 if (!SWIG_IsOK(ecode2)) {
31959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
31960 }
31961 arg2 = static_cast< int >(val2);
31962 }
31963 if (obj2) {
31964 ecode3 = SWIG_AsVal_int(obj2, &val3);
31965 if (!SWIG_IsOK(ecode3)) {
31966 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
31967 }
31968 arg3 = static_cast< int >(val3);
31969 }
31970 {
31971 PyThreadState* __tstate = wxPyBeginAllowThreads();
31972 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
31973 wxPyEndAllowThreads(__tstate);
31974 if (PyErr_Occurred()) SWIG_fail;
31975 }
31976 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
31977 return resultobj;
31978 fail:
31979 return NULL;
31980 }
31981
31982
31983 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31984 PyObject *resultobj = 0;
31985 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
31986 void *argp1 = 0 ;
31987 int res1 = 0 ;
31988 PyObject *swig_obj[1] ;
31989
31990 if (!args) SWIG_fail;
31991 swig_obj[0] = args;
31992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
31993 if (!SWIG_IsOK(res1)) {
31994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
31995 }
31996 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
31997 {
31998 PyThreadState* __tstate = wxPyBeginAllowThreads();
31999 delete arg1;
32000
32001 wxPyEndAllowThreads(__tstate);
32002 if (PyErr_Occurred()) SWIG_fail;
32003 }
32004 resultobj = SWIG_Py_Void();
32005 return resultobj;
32006 fail:
32007 return NULL;
32008 }
32009
32010
32011 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32012 PyObject *resultobj = 0;
32013 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32014 int arg2 ;
32015 int arg3 ;
32016 int arg4 ;
32017 void *argp1 = 0 ;
32018 int res1 = 0 ;
32019 int val2 ;
32020 int ecode2 = 0 ;
32021 int val3 ;
32022 int ecode3 = 0 ;
32023 int val4 ;
32024 int ecode4 = 0 ;
32025 PyObject * obj0 = 0 ;
32026 PyObject * obj1 = 0 ;
32027 PyObject * obj2 = 0 ;
32028 PyObject * obj3 = 0 ;
32029 char * kwnames[] = {
32030 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32031 };
32032
32033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32035 if (!SWIG_IsOK(res1)) {
32036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32037 }
32038 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32039 ecode2 = SWIG_AsVal_int(obj1, &val2);
32040 if (!SWIG_IsOK(ecode2)) {
32041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32042 }
32043 arg2 = static_cast< int >(val2);
32044 ecode3 = SWIG_AsVal_int(obj2, &val3);
32045 if (!SWIG_IsOK(ecode3)) {
32046 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32047 }
32048 arg3 = static_cast< int >(val3);
32049 ecode4 = SWIG_AsVal_int(obj3, &val4);
32050 if (!SWIG_IsOK(ecode4)) {
32051 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32052 }
32053 arg4 = static_cast< int >(val4);
32054 {
32055 PyThreadState* __tstate = wxPyBeginAllowThreads();
32056 (arg1)->Set(arg2,arg3,arg4);
32057 wxPyEndAllowThreads(__tstate);
32058 if (PyErr_Occurred()) SWIG_fail;
32059 }
32060 resultobj = SWIG_Py_Void();
32061 return resultobj;
32062 fail:
32063 return NULL;
32064 }
32065
32066
32067 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32068 PyObject *resultobj = 0;
32069 wxString *arg1 = 0 ;
32070 wxAcceleratorEntry *result = 0 ;
32071 bool temp1 = false ;
32072 PyObject * obj0 = 0 ;
32073 char * kwnames[] = {
32074 (char *) "str", NULL
32075 };
32076
32077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32078 {
32079 arg1 = wxString_in_helper(obj0);
32080 if (arg1 == NULL) SWIG_fail;
32081 temp1 = true;
32082 }
32083 {
32084 PyThreadState* __tstate = wxPyBeginAllowThreads();
32085 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32086 wxPyEndAllowThreads(__tstate);
32087 if (PyErr_Occurred()) SWIG_fail;
32088 }
32089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32090 {
32091 if (temp1)
32092 delete arg1;
32093 }
32094 return resultobj;
32095 fail:
32096 {
32097 if (temp1)
32098 delete arg1;
32099 }
32100 return NULL;
32101 }
32102
32103
32104 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32105 PyObject *resultobj = 0;
32106 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32107 int result;
32108 void *argp1 = 0 ;
32109 int res1 = 0 ;
32110 PyObject *swig_obj[1] ;
32111
32112 if (!args) SWIG_fail;
32113 swig_obj[0] = args;
32114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32115 if (!SWIG_IsOK(res1)) {
32116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32117 }
32118 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32119 {
32120 PyThreadState* __tstate = wxPyBeginAllowThreads();
32121 result = (int)(arg1)->GetFlags();
32122 wxPyEndAllowThreads(__tstate);
32123 if (PyErr_Occurred()) SWIG_fail;
32124 }
32125 resultobj = SWIG_From_int(static_cast< int >(result));
32126 return resultobj;
32127 fail:
32128 return NULL;
32129 }
32130
32131
32132 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32133 PyObject *resultobj = 0;
32134 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32135 int result;
32136 void *argp1 = 0 ;
32137 int res1 = 0 ;
32138 PyObject *swig_obj[1] ;
32139
32140 if (!args) SWIG_fail;
32141 swig_obj[0] = args;
32142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32143 if (!SWIG_IsOK(res1)) {
32144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32145 }
32146 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32147 {
32148 PyThreadState* __tstate = wxPyBeginAllowThreads();
32149 result = (int)(arg1)->GetKeyCode();
32150 wxPyEndAllowThreads(__tstate);
32151 if (PyErr_Occurred()) SWIG_fail;
32152 }
32153 resultobj = SWIG_From_int(static_cast< int >(result));
32154 return resultobj;
32155 fail:
32156 return NULL;
32157 }
32158
32159
32160 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32161 PyObject *resultobj = 0;
32162 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32163 int result;
32164 void *argp1 = 0 ;
32165 int res1 = 0 ;
32166 PyObject *swig_obj[1] ;
32167
32168 if (!args) SWIG_fail;
32169 swig_obj[0] = args;
32170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32171 if (!SWIG_IsOK(res1)) {
32172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32173 }
32174 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32175 {
32176 PyThreadState* __tstate = wxPyBeginAllowThreads();
32177 result = (int)(arg1)->GetCommand();
32178 wxPyEndAllowThreads(__tstate);
32179 if (PyErr_Occurred()) SWIG_fail;
32180 }
32181 resultobj = SWIG_From_int(static_cast< int >(result));
32182 return resultobj;
32183 fail:
32184 return NULL;
32185 }
32186
32187
32188 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32189 PyObject *resultobj = 0;
32190 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32191 bool result;
32192 void *argp1 = 0 ;
32193 int res1 = 0 ;
32194 PyObject *swig_obj[1] ;
32195
32196 if (!args) SWIG_fail;
32197 swig_obj[0] = args;
32198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32199 if (!SWIG_IsOK(res1)) {
32200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32201 }
32202 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32203 {
32204 PyThreadState* __tstate = wxPyBeginAllowThreads();
32205 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32206 wxPyEndAllowThreads(__tstate);
32207 if (PyErr_Occurred()) SWIG_fail;
32208 }
32209 {
32210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32211 }
32212 return resultobj;
32213 fail:
32214 return NULL;
32215 }
32216
32217
32218 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32219 PyObject *resultobj = 0;
32220 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32221 wxString result;
32222 void *argp1 = 0 ;
32223 int res1 = 0 ;
32224 PyObject *swig_obj[1] ;
32225
32226 if (!args) SWIG_fail;
32227 swig_obj[0] = args;
32228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32229 if (!SWIG_IsOK(res1)) {
32230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32231 }
32232 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32233 {
32234 PyThreadState* __tstate = wxPyBeginAllowThreads();
32235 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32236 wxPyEndAllowThreads(__tstate);
32237 if (PyErr_Occurred()) SWIG_fail;
32238 }
32239 {
32240 #if wxUSE_UNICODE
32241 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32242 #else
32243 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32244 #endif
32245 }
32246 return resultobj;
32247 fail:
32248 return NULL;
32249 }
32250
32251
32252 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32253 PyObject *resultobj = 0;
32254 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32255 wxString *arg2 = 0 ;
32256 bool result;
32257 void *argp1 = 0 ;
32258 int res1 = 0 ;
32259 bool temp2 = false ;
32260 PyObject * obj0 = 0 ;
32261 PyObject * obj1 = 0 ;
32262 char * kwnames[] = {
32263 (char *) "self",(char *) "str", NULL
32264 };
32265
32266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32268 if (!SWIG_IsOK(res1)) {
32269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32270 }
32271 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32272 {
32273 arg2 = wxString_in_helper(obj1);
32274 if (arg2 == NULL) SWIG_fail;
32275 temp2 = true;
32276 }
32277 {
32278 PyThreadState* __tstate = wxPyBeginAllowThreads();
32279 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32280 wxPyEndAllowThreads(__tstate);
32281 if (PyErr_Occurred()) SWIG_fail;
32282 }
32283 {
32284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32285 }
32286 {
32287 if (temp2)
32288 delete arg2;
32289 }
32290 return resultobj;
32291 fail:
32292 {
32293 if (temp2)
32294 delete arg2;
32295 }
32296 return NULL;
32297 }
32298
32299
32300 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32301 PyObject *obj;
32302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32303 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32304 return SWIG_Py_Void();
32305 }
32306
32307 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32308 return SWIG_Python_InitShadowInstance(args);
32309 }
32310
32311 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32312 PyObject *resultobj = 0;
32313 int arg1 ;
32314 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32315 wxAcceleratorTable *result = 0 ;
32316 PyObject * obj0 = 0 ;
32317 char * kwnames[] = {
32318 (char *) "n", NULL
32319 };
32320
32321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32322 {
32323 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32324 if (arg2) arg1 = PyList_Size(obj0);
32325 else arg1 = 0;
32326 }
32327 {
32328 PyThreadState* __tstate = wxPyBeginAllowThreads();
32329 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32330 wxPyEndAllowThreads(__tstate);
32331 if (PyErr_Occurred()) SWIG_fail;
32332 }
32333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32334 return resultobj;
32335 fail:
32336 return NULL;
32337 }
32338
32339
32340 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32341 PyObject *resultobj = 0;
32342 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32343 void *argp1 = 0 ;
32344 int res1 = 0 ;
32345 PyObject *swig_obj[1] ;
32346
32347 if (!args) SWIG_fail;
32348 swig_obj[0] = args;
32349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32350 if (!SWIG_IsOK(res1)) {
32351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32352 }
32353 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32354 {
32355 PyThreadState* __tstate = wxPyBeginAllowThreads();
32356 delete arg1;
32357
32358 wxPyEndAllowThreads(__tstate);
32359 if (PyErr_Occurred()) SWIG_fail;
32360 }
32361 resultobj = SWIG_Py_Void();
32362 return resultobj;
32363 fail:
32364 return NULL;
32365 }
32366
32367
32368 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32369 PyObject *resultobj = 0;
32370 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32371 bool result;
32372 void *argp1 = 0 ;
32373 int res1 = 0 ;
32374 PyObject *swig_obj[1] ;
32375
32376 if (!args) SWIG_fail;
32377 swig_obj[0] = args;
32378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32379 if (!SWIG_IsOK(res1)) {
32380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32381 }
32382 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32383 {
32384 PyThreadState* __tstate = wxPyBeginAllowThreads();
32385 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32386 wxPyEndAllowThreads(__tstate);
32387 if (PyErr_Occurred()) SWIG_fail;
32388 }
32389 {
32390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32391 }
32392 return resultobj;
32393 fail:
32394 return NULL;
32395 }
32396
32397
32398 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32399 PyObject *obj;
32400 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32401 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32402 return SWIG_Py_Void();
32403 }
32404
32405 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32406 return SWIG_Python_InitShadowInstance(args);
32407 }
32408
32409 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32410 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32411 return 1;
32412 }
32413
32414
32415 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32416 PyObject *pyobj = 0;
32417
32418 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32419 return pyobj;
32420 }
32421
32422
32423 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32424 PyObject *resultobj = 0;
32425 wxString *arg1 = 0 ;
32426 wxAcceleratorEntry *result = 0 ;
32427 bool temp1 = false ;
32428 PyObject * obj0 = 0 ;
32429 char * kwnames[] = {
32430 (char *) "label", NULL
32431 };
32432
32433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
32434 {
32435 arg1 = wxString_in_helper(obj0);
32436 if (arg1 == NULL) SWIG_fail;
32437 temp1 = true;
32438 }
32439 {
32440 PyThreadState* __tstate = wxPyBeginAllowThreads();
32441 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
32442 wxPyEndAllowThreads(__tstate);
32443 if (PyErr_Occurred()) SWIG_fail;
32444 }
32445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32446 {
32447 if (temp1)
32448 delete arg1;
32449 }
32450 return resultobj;
32451 fail:
32452 {
32453 if (temp1)
32454 delete arg1;
32455 }
32456 return NULL;
32457 }
32458
32459
32460 SWIGINTERN int PanelNameStr_set(PyObject *) {
32461 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32462 return 1;
32463 }
32464
32465
32466 SWIGINTERN PyObject *PanelNameStr_get(void) {
32467 PyObject *pyobj = 0;
32468
32469 {
32470 #if wxUSE_UNICODE
32471 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32472 #else
32473 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32474 #endif
32475 }
32476 return pyobj;
32477 }
32478
32479
32480 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32481 PyObject *resultobj = 0;
32482 wxVisualAttributes *result = 0 ;
32483
32484 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32485 {
32486 PyThreadState* __tstate = wxPyBeginAllowThreads();
32487 result = (wxVisualAttributes *)new_wxVisualAttributes();
32488 wxPyEndAllowThreads(__tstate);
32489 if (PyErr_Occurred()) SWIG_fail;
32490 }
32491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32492 return resultobj;
32493 fail:
32494 return NULL;
32495 }
32496
32497
32498 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32499 PyObject *resultobj = 0;
32500 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32501 void *argp1 = 0 ;
32502 int res1 = 0 ;
32503 PyObject *swig_obj[1] ;
32504
32505 if (!args) SWIG_fail;
32506 swig_obj[0] = args;
32507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32508 if (!SWIG_IsOK(res1)) {
32509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32510 }
32511 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32512 {
32513 PyThreadState* __tstate = wxPyBeginAllowThreads();
32514 delete_wxVisualAttributes(arg1);
32515
32516 wxPyEndAllowThreads(__tstate);
32517 if (PyErr_Occurred()) SWIG_fail;
32518 }
32519 resultobj = SWIG_Py_Void();
32520 return resultobj;
32521 fail:
32522 return NULL;
32523 }
32524
32525
32526 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32527 PyObject *resultobj = 0;
32528 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32529 wxFont *arg2 = (wxFont *) 0 ;
32530 void *argp1 = 0 ;
32531 int res1 = 0 ;
32532 void *argp2 = 0 ;
32533 int res2 = 0 ;
32534 PyObject *swig_obj[2] ;
32535
32536 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32538 if (!SWIG_IsOK(res1)) {
32539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32540 }
32541 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32542 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32543 if (!SWIG_IsOK(res2)) {
32544 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32545 }
32546 arg2 = reinterpret_cast< wxFont * >(argp2);
32547 if (arg1) (arg1)->font = *arg2;
32548
32549 resultobj = SWIG_Py_Void();
32550 return resultobj;
32551 fail:
32552 return NULL;
32553 }
32554
32555
32556 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32557 PyObject *resultobj = 0;
32558 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32559 wxFont *result = 0 ;
32560 void *argp1 = 0 ;
32561 int res1 = 0 ;
32562 PyObject *swig_obj[1] ;
32563
32564 if (!args) SWIG_fail;
32565 swig_obj[0] = args;
32566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32567 if (!SWIG_IsOK(res1)) {
32568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32569 }
32570 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32571 result = (wxFont *)& ((arg1)->font);
32572 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32573 return resultobj;
32574 fail:
32575 return NULL;
32576 }
32577
32578
32579 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32580 PyObject *resultobj = 0;
32581 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32582 wxColour *arg2 = (wxColour *) 0 ;
32583 void *argp1 = 0 ;
32584 int res1 = 0 ;
32585 void *argp2 = 0 ;
32586 int res2 = 0 ;
32587 PyObject *swig_obj[2] ;
32588
32589 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32591 if (!SWIG_IsOK(res1)) {
32592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32593 }
32594 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32595 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32596 if (!SWIG_IsOK(res2)) {
32597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32598 }
32599 arg2 = reinterpret_cast< wxColour * >(argp2);
32600 if (arg1) (arg1)->colFg = *arg2;
32601
32602 resultobj = SWIG_Py_Void();
32603 return resultobj;
32604 fail:
32605 return NULL;
32606 }
32607
32608
32609 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32610 PyObject *resultobj = 0;
32611 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32612 wxColour *result = 0 ;
32613 void *argp1 = 0 ;
32614 int res1 = 0 ;
32615 PyObject *swig_obj[1] ;
32616
32617 if (!args) SWIG_fail;
32618 swig_obj[0] = args;
32619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32620 if (!SWIG_IsOK(res1)) {
32621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32622 }
32623 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32624 result = (wxColour *)& ((arg1)->colFg);
32625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32626 return resultobj;
32627 fail:
32628 return NULL;
32629 }
32630
32631
32632 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32633 PyObject *resultobj = 0;
32634 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32635 wxColour *arg2 = (wxColour *) 0 ;
32636 void *argp1 = 0 ;
32637 int res1 = 0 ;
32638 void *argp2 = 0 ;
32639 int res2 = 0 ;
32640 PyObject *swig_obj[2] ;
32641
32642 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32644 if (!SWIG_IsOK(res1)) {
32645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32646 }
32647 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32648 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32649 if (!SWIG_IsOK(res2)) {
32650 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32651 }
32652 arg2 = reinterpret_cast< wxColour * >(argp2);
32653 if (arg1) (arg1)->colBg = *arg2;
32654
32655 resultobj = SWIG_Py_Void();
32656 return resultobj;
32657 fail:
32658 return NULL;
32659 }
32660
32661
32662 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32663 PyObject *resultobj = 0;
32664 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32665 wxColour *result = 0 ;
32666 void *argp1 = 0 ;
32667 int res1 = 0 ;
32668 PyObject *swig_obj[1] ;
32669
32670 if (!args) SWIG_fail;
32671 swig_obj[0] = args;
32672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32673 if (!SWIG_IsOK(res1)) {
32674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32675 }
32676 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32677 result = (wxColour *)& ((arg1)->colBg);
32678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32679 return resultobj;
32680 fail:
32681 return NULL;
32682 }
32683
32684
32685 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32686 PyObject *obj;
32687 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32688 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32689 return SWIG_Py_Void();
32690 }
32691
32692 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32693 return SWIG_Python_InitShadowInstance(args);
32694 }
32695
32696 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32697 PyObject *resultobj = 0;
32698 wxWindow *arg1 = (wxWindow *) 0 ;
32699 int arg2 = (int) (int)-1 ;
32700 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32701 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32702 wxSize const &arg4_defvalue = wxDefaultSize ;
32703 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32704 long arg5 = (long) 0 ;
32705 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32706 wxString *arg6 = (wxString *) &arg6_defvalue ;
32707 wxWindow *result = 0 ;
32708 void *argp1 = 0 ;
32709 int res1 = 0 ;
32710 int val2 ;
32711 int ecode2 = 0 ;
32712 wxPoint temp3 ;
32713 wxSize temp4 ;
32714 long val5 ;
32715 int ecode5 = 0 ;
32716 bool temp6 = false ;
32717 PyObject * obj0 = 0 ;
32718 PyObject * obj1 = 0 ;
32719 PyObject * obj2 = 0 ;
32720 PyObject * obj3 = 0 ;
32721 PyObject * obj4 = 0 ;
32722 PyObject * obj5 = 0 ;
32723 char * kwnames[] = {
32724 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32725 };
32726
32727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32729 if (!SWIG_IsOK(res1)) {
32730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32731 }
32732 arg1 = reinterpret_cast< wxWindow * >(argp1);
32733 if (obj1) {
32734 ecode2 = SWIG_AsVal_int(obj1, &val2);
32735 if (!SWIG_IsOK(ecode2)) {
32736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32737 }
32738 arg2 = static_cast< int >(val2);
32739 }
32740 if (obj2) {
32741 {
32742 arg3 = &temp3;
32743 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32744 }
32745 }
32746 if (obj3) {
32747 {
32748 arg4 = &temp4;
32749 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32750 }
32751 }
32752 if (obj4) {
32753 ecode5 = SWIG_AsVal_long(obj4, &val5);
32754 if (!SWIG_IsOK(ecode5)) {
32755 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32756 }
32757 arg5 = static_cast< long >(val5);
32758 }
32759 if (obj5) {
32760 {
32761 arg6 = wxString_in_helper(obj5);
32762 if (arg6 == NULL) SWIG_fail;
32763 temp6 = true;
32764 }
32765 }
32766 {
32767 if (!wxPyCheckForApp()) SWIG_fail;
32768 PyThreadState* __tstate = wxPyBeginAllowThreads();
32769 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32770 wxPyEndAllowThreads(__tstate);
32771 if (PyErr_Occurred()) SWIG_fail;
32772 }
32773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32774 {
32775 if (temp6)
32776 delete arg6;
32777 }
32778 return resultobj;
32779 fail:
32780 {
32781 if (temp6)
32782 delete arg6;
32783 }
32784 return NULL;
32785 }
32786
32787
32788 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32789 PyObject *resultobj = 0;
32790 wxWindow *result = 0 ;
32791
32792 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32793 {
32794 if (!wxPyCheckForApp()) SWIG_fail;
32795 PyThreadState* __tstate = wxPyBeginAllowThreads();
32796 result = (wxWindow *)new wxWindow();
32797 wxPyEndAllowThreads(__tstate);
32798 if (PyErr_Occurred()) SWIG_fail;
32799 }
32800 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32801 return resultobj;
32802 fail:
32803 return NULL;
32804 }
32805
32806
32807 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32808 PyObject *resultobj = 0;
32809 wxWindow *arg1 = (wxWindow *) 0 ;
32810 wxWindow *arg2 = (wxWindow *) 0 ;
32811 int arg3 = (int) (int)-1 ;
32812 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32813 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32814 wxSize const &arg5_defvalue = wxDefaultSize ;
32815 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32816 long arg6 = (long) 0 ;
32817 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32818 wxString *arg7 = (wxString *) &arg7_defvalue ;
32819 bool result;
32820 void *argp1 = 0 ;
32821 int res1 = 0 ;
32822 void *argp2 = 0 ;
32823 int res2 = 0 ;
32824 int val3 ;
32825 int ecode3 = 0 ;
32826 wxPoint temp4 ;
32827 wxSize temp5 ;
32828 long val6 ;
32829 int ecode6 = 0 ;
32830 bool temp7 = false ;
32831 PyObject * obj0 = 0 ;
32832 PyObject * obj1 = 0 ;
32833 PyObject * obj2 = 0 ;
32834 PyObject * obj3 = 0 ;
32835 PyObject * obj4 = 0 ;
32836 PyObject * obj5 = 0 ;
32837 PyObject * obj6 = 0 ;
32838 char * kwnames[] = {
32839 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32840 };
32841
32842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32844 if (!SWIG_IsOK(res1)) {
32845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
32846 }
32847 arg1 = reinterpret_cast< wxWindow * >(argp1);
32848 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32849 if (!SWIG_IsOK(res2)) {
32850 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
32851 }
32852 arg2 = reinterpret_cast< wxWindow * >(argp2);
32853 if (obj2) {
32854 ecode3 = SWIG_AsVal_int(obj2, &val3);
32855 if (!SWIG_IsOK(ecode3)) {
32856 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
32857 }
32858 arg3 = static_cast< int >(val3);
32859 }
32860 if (obj3) {
32861 {
32862 arg4 = &temp4;
32863 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32864 }
32865 }
32866 if (obj4) {
32867 {
32868 arg5 = &temp5;
32869 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
32870 }
32871 }
32872 if (obj5) {
32873 ecode6 = SWIG_AsVal_long(obj5, &val6);
32874 if (!SWIG_IsOK(ecode6)) {
32875 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
32876 }
32877 arg6 = static_cast< long >(val6);
32878 }
32879 if (obj6) {
32880 {
32881 arg7 = wxString_in_helper(obj6);
32882 if (arg7 == NULL) SWIG_fail;
32883 temp7 = true;
32884 }
32885 }
32886 {
32887 PyThreadState* __tstate = wxPyBeginAllowThreads();
32888 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
32889 wxPyEndAllowThreads(__tstate);
32890 if (PyErr_Occurred()) SWIG_fail;
32891 }
32892 {
32893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32894 }
32895 {
32896 if (temp7)
32897 delete arg7;
32898 }
32899 return resultobj;
32900 fail:
32901 {
32902 if (temp7)
32903 delete arg7;
32904 }
32905 return NULL;
32906 }
32907
32908
32909 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32910 PyObject *resultobj = 0;
32911 wxWindow *arg1 = (wxWindow *) 0 ;
32912 bool arg2 = (bool) false ;
32913 bool result;
32914 void *argp1 = 0 ;
32915 int res1 = 0 ;
32916 bool val2 ;
32917 int ecode2 = 0 ;
32918 PyObject * obj0 = 0 ;
32919 PyObject * obj1 = 0 ;
32920 char * kwnames[] = {
32921 (char *) "self",(char *) "force", NULL
32922 };
32923
32924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
32925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32926 if (!SWIG_IsOK(res1)) {
32927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
32928 }
32929 arg1 = reinterpret_cast< wxWindow * >(argp1);
32930 if (obj1) {
32931 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32932 if (!SWIG_IsOK(ecode2)) {
32933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
32934 }
32935 arg2 = static_cast< bool >(val2);
32936 }
32937 {
32938 PyThreadState* __tstate = wxPyBeginAllowThreads();
32939 result = (bool)(arg1)->Close(arg2);
32940 wxPyEndAllowThreads(__tstate);
32941 if (PyErr_Occurred()) SWIG_fail;
32942 }
32943 {
32944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32945 }
32946 return resultobj;
32947 fail:
32948 return NULL;
32949 }
32950
32951
32952 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32953 PyObject *resultobj = 0;
32954 wxWindow *arg1 = (wxWindow *) 0 ;
32955 bool result;
32956 void *argp1 = 0 ;
32957 int res1 = 0 ;
32958 PyObject *swig_obj[1] ;
32959
32960 if (!args) SWIG_fail;
32961 swig_obj[0] = args;
32962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32963 if (!SWIG_IsOK(res1)) {
32964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
32965 }
32966 arg1 = reinterpret_cast< wxWindow * >(argp1);
32967 {
32968 PyThreadState* __tstate = wxPyBeginAllowThreads();
32969 result = (bool)(arg1)->Destroy();
32970 wxPyEndAllowThreads(__tstate);
32971 if (PyErr_Occurred()) SWIG_fail;
32972 }
32973 {
32974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32975 }
32976 return resultobj;
32977 fail:
32978 return NULL;
32979 }
32980
32981
32982 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32983 PyObject *resultobj = 0;
32984 wxWindow *arg1 = (wxWindow *) 0 ;
32985 bool result;
32986 void *argp1 = 0 ;
32987 int res1 = 0 ;
32988 PyObject *swig_obj[1] ;
32989
32990 if (!args) SWIG_fail;
32991 swig_obj[0] = args;
32992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32993 if (!SWIG_IsOK(res1)) {
32994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32995 }
32996 arg1 = reinterpret_cast< wxWindow * >(argp1);
32997 {
32998 PyThreadState* __tstate = wxPyBeginAllowThreads();
32999 result = (bool)(arg1)->DestroyChildren();
33000 wxPyEndAllowThreads(__tstate);
33001 if (PyErr_Occurred()) SWIG_fail;
33002 }
33003 {
33004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33005 }
33006 return resultobj;
33007 fail:
33008 return NULL;
33009 }
33010
33011
33012 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33013 PyObject *resultobj = 0;
33014 wxWindow *arg1 = (wxWindow *) 0 ;
33015 bool result;
33016 void *argp1 = 0 ;
33017 int res1 = 0 ;
33018 PyObject *swig_obj[1] ;
33019
33020 if (!args) SWIG_fail;
33021 swig_obj[0] = args;
33022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33023 if (!SWIG_IsOK(res1)) {
33024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33025 }
33026 arg1 = reinterpret_cast< wxWindow * >(argp1);
33027 {
33028 PyThreadState* __tstate = wxPyBeginAllowThreads();
33029 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33030 wxPyEndAllowThreads(__tstate);
33031 if (PyErr_Occurred()) SWIG_fail;
33032 }
33033 {
33034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33035 }
33036 return resultobj;
33037 fail:
33038 return NULL;
33039 }
33040
33041
33042 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33043 PyObject *resultobj = 0;
33044 wxWindow *arg1 = (wxWindow *) 0 ;
33045 wxString *arg2 = 0 ;
33046 void *argp1 = 0 ;
33047 int res1 = 0 ;
33048 bool temp2 = false ;
33049 PyObject * obj0 = 0 ;
33050 PyObject * obj1 = 0 ;
33051 char * kwnames[] = {
33052 (char *) "self",(char *) "label", NULL
33053 };
33054
33055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33057 if (!SWIG_IsOK(res1)) {
33058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33059 }
33060 arg1 = reinterpret_cast< wxWindow * >(argp1);
33061 {
33062 arg2 = wxString_in_helper(obj1);
33063 if (arg2 == NULL) SWIG_fail;
33064 temp2 = true;
33065 }
33066 {
33067 PyThreadState* __tstate = wxPyBeginAllowThreads();
33068 (arg1)->SetLabel((wxString const &)*arg2);
33069 wxPyEndAllowThreads(__tstate);
33070 if (PyErr_Occurred()) SWIG_fail;
33071 }
33072 resultobj = SWIG_Py_Void();
33073 {
33074 if (temp2)
33075 delete arg2;
33076 }
33077 return resultobj;
33078 fail:
33079 {
33080 if (temp2)
33081 delete arg2;
33082 }
33083 return NULL;
33084 }
33085
33086
33087 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33088 PyObject *resultobj = 0;
33089 wxWindow *arg1 = (wxWindow *) 0 ;
33090 wxString result;
33091 void *argp1 = 0 ;
33092 int res1 = 0 ;
33093 PyObject *swig_obj[1] ;
33094
33095 if (!args) SWIG_fail;
33096 swig_obj[0] = args;
33097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33098 if (!SWIG_IsOK(res1)) {
33099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33100 }
33101 arg1 = reinterpret_cast< wxWindow * >(argp1);
33102 {
33103 PyThreadState* __tstate = wxPyBeginAllowThreads();
33104 result = ((wxWindow const *)arg1)->GetLabel();
33105 wxPyEndAllowThreads(__tstate);
33106 if (PyErr_Occurred()) SWIG_fail;
33107 }
33108 {
33109 #if wxUSE_UNICODE
33110 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33111 #else
33112 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33113 #endif
33114 }
33115 return resultobj;
33116 fail:
33117 return NULL;
33118 }
33119
33120
33121 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33122 PyObject *resultobj = 0;
33123 wxWindow *arg1 = (wxWindow *) 0 ;
33124 wxString *arg2 = 0 ;
33125 void *argp1 = 0 ;
33126 int res1 = 0 ;
33127 bool temp2 = false ;
33128 PyObject * obj0 = 0 ;
33129 PyObject * obj1 = 0 ;
33130 char * kwnames[] = {
33131 (char *) "self",(char *) "name", NULL
33132 };
33133
33134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33136 if (!SWIG_IsOK(res1)) {
33137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33138 }
33139 arg1 = reinterpret_cast< wxWindow * >(argp1);
33140 {
33141 arg2 = wxString_in_helper(obj1);
33142 if (arg2 == NULL) SWIG_fail;
33143 temp2 = true;
33144 }
33145 {
33146 PyThreadState* __tstate = wxPyBeginAllowThreads();
33147 (arg1)->SetName((wxString const &)*arg2);
33148 wxPyEndAllowThreads(__tstate);
33149 if (PyErr_Occurred()) SWIG_fail;
33150 }
33151 resultobj = SWIG_Py_Void();
33152 {
33153 if (temp2)
33154 delete arg2;
33155 }
33156 return resultobj;
33157 fail:
33158 {
33159 if (temp2)
33160 delete arg2;
33161 }
33162 return NULL;
33163 }
33164
33165
33166 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33167 PyObject *resultobj = 0;
33168 wxWindow *arg1 = (wxWindow *) 0 ;
33169 wxString result;
33170 void *argp1 = 0 ;
33171 int res1 = 0 ;
33172 PyObject *swig_obj[1] ;
33173
33174 if (!args) SWIG_fail;
33175 swig_obj[0] = args;
33176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33177 if (!SWIG_IsOK(res1)) {
33178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33179 }
33180 arg1 = reinterpret_cast< wxWindow * >(argp1);
33181 {
33182 PyThreadState* __tstate = wxPyBeginAllowThreads();
33183 result = ((wxWindow const *)arg1)->GetName();
33184 wxPyEndAllowThreads(__tstate);
33185 if (PyErr_Occurred()) SWIG_fail;
33186 }
33187 {
33188 #if wxUSE_UNICODE
33189 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33190 #else
33191 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33192 #endif
33193 }
33194 return resultobj;
33195 fail:
33196 return NULL;
33197 }
33198
33199
33200 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33201 PyObject *resultobj = 0;
33202 wxWindow *arg1 = (wxWindow *) 0 ;
33203 wxWindowVariant arg2 ;
33204 void *argp1 = 0 ;
33205 int res1 = 0 ;
33206 int val2 ;
33207 int ecode2 = 0 ;
33208 PyObject * obj0 = 0 ;
33209 PyObject * obj1 = 0 ;
33210 char * kwnames[] = {
33211 (char *) "self",(char *) "variant", NULL
33212 };
33213
33214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33216 if (!SWIG_IsOK(res1)) {
33217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33218 }
33219 arg1 = reinterpret_cast< wxWindow * >(argp1);
33220 ecode2 = SWIG_AsVal_int(obj1, &val2);
33221 if (!SWIG_IsOK(ecode2)) {
33222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33223 }
33224 arg2 = static_cast< wxWindowVariant >(val2);
33225 {
33226 PyThreadState* __tstate = wxPyBeginAllowThreads();
33227 (arg1)->SetWindowVariant(arg2);
33228 wxPyEndAllowThreads(__tstate);
33229 if (PyErr_Occurred()) SWIG_fail;
33230 }
33231 resultobj = SWIG_Py_Void();
33232 return resultobj;
33233 fail:
33234 return NULL;
33235 }
33236
33237
33238 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33239 PyObject *resultobj = 0;
33240 wxWindow *arg1 = (wxWindow *) 0 ;
33241 wxWindowVariant result;
33242 void *argp1 = 0 ;
33243 int res1 = 0 ;
33244 PyObject *swig_obj[1] ;
33245
33246 if (!args) SWIG_fail;
33247 swig_obj[0] = args;
33248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33249 if (!SWIG_IsOK(res1)) {
33250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33251 }
33252 arg1 = reinterpret_cast< wxWindow * >(argp1);
33253 {
33254 PyThreadState* __tstate = wxPyBeginAllowThreads();
33255 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33256 wxPyEndAllowThreads(__tstate);
33257 if (PyErr_Occurred()) SWIG_fail;
33258 }
33259 resultobj = SWIG_From_int(static_cast< int >(result));
33260 return resultobj;
33261 fail:
33262 return NULL;
33263 }
33264
33265
33266 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33267 PyObject *resultobj = 0;
33268 wxWindow *arg1 = (wxWindow *) 0 ;
33269 int arg2 ;
33270 void *argp1 = 0 ;
33271 int res1 = 0 ;
33272 int val2 ;
33273 int ecode2 = 0 ;
33274 PyObject * obj0 = 0 ;
33275 PyObject * obj1 = 0 ;
33276 char * kwnames[] = {
33277 (char *) "self",(char *) "winid", NULL
33278 };
33279
33280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33282 if (!SWIG_IsOK(res1)) {
33283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33284 }
33285 arg1 = reinterpret_cast< wxWindow * >(argp1);
33286 ecode2 = SWIG_AsVal_int(obj1, &val2);
33287 if (!SWIG_IsOK(ecode2)) {
33288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33289 }
33290 arg2 = static_cast< int >(val2);
33291 {
33292 PyThreadState* __tstate = wxPyBeginAllowThreads();
33293 (arg1)->SetId(arg2);
33294 wxPyEndAllowThreads(__tstate);
33295 if (PyErr_Occurred()) SWIG_fail;
33296 }
33297 resultobj = SWIG_Py_Void();
33298 return resultobj;
33299 fail:
33300 return NULL;
33301 }
33302
33303
33304 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33305 PyObject *resultobj = 0;
33306 wxWindow *arg1 = (wxWindow *) 0 ;
33307 int result;
33308 void *argp1 = 0 ;
33309 int res1 = 0 ;
33310 PyObject *swig_obj[1] ;
33311
33312 if (!args) SWIG_fail;
33313 swig_obj[0] = args;
33314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33315 if (!SWIG_IsOK(res1)) {
33316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33317 }
33318 arg1 = reinterpret_cast< wxWindow * >(argp1);
33319 {
33320 PyThreadState* __tstate = wxPyBeginAllowThreads();
33321 result = (int)((wxWindow const *)arg1)->GetId();
33322 wxPyEndAllowThreads(__tstate);
33323 if (PyErr_Occurred()) SWIG_fail;
33324 }
33325 resultobj = SWIG_From_int(static_cast< int >(result));
33326 return resultobj;
33327 fail:
33328 return NULL;
33329 }
33330
33331
33332 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33333 PyObject *resultobj = 0;
33334 int result;
33335
33336 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33337 {
33338 PyThreadState* __tstate = wxPyBeginAllowThreads();
33339 result = (int)wxWindow::NewControlId();
33340 wxPyEndAllowThreads(__tstate);
33341 if (PyErr_Occurred()) SWIG_fail;
33342 }
33343 resultobj = SWIG_From_int(static_cast< int >(result));
33344 return resultobj;
33345 fail:
33346 return NULL;
33347 }
33348
33349
33350 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33351 PyObject *resultobj = 0;
33352 int arg1 ;
33353 int result;
33354 int val1 ;
33355 int ecode1 = 0 ;
33356 PyObject * obj0 = 0 ;
33357 char * kwnames[] = {
33358 (char *) "winid", NULL
33359 };
33360
33361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33362 ecode1 = SWIG_AsVal_int(obj0, &val1);
33363 if (!SWIG_IsOK(ecode1)) {
33364 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33365 }
33366 arg1 = static_cast< int >(val1);
33367 {
33368 PyThreadState* __tstate = wxPyBeginAllowThreads();
33369 result = (int)wxWindow::NextControlId(arg1);
33370 wxPyEndAllowThreads(__tstate);
33371 if (PyErr_Occurred()) SWIG_fail;
33372 }
33373 resultobj = SWIG_From_int(static_cast< int >(result));
33374 return resultobj;
33375 fail:
33376 return NULL;
33377 }
33378
33379
33380 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33381 PyObject *resultobj = 0;
33382 int arg1 ;
33383 int result;
33384 int val1 ;
33385 int ecode1 = 0 ;
33386 PyObject * obj0 = 0 ;
33387 char * kwnames[] = {
33388 (char *) "winid", NULL
33389 };
33390
33391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33392 ecode1 = SWIG_AsVal_int(obj0, &val1);
33393 if (!SWIG_IsOK(ecode1)) {
33394 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33395 }
33396 arg1 = static_cast< int >(val1);
33397 {
33398 PyThreadState* __tstate = wxPyBeginAllowThreads();
33399 result = (int)wxWindow::PrevControlId(arg1);
33400 wxPyEndAllowThreads(__tstate);
33401 if (PyErr_Occurred()) SWIG_fail;
33402 }
33403 resultobj = SWIG_From_int(static_cast< int >(result));
33404 return resultobj;
33405 fail:
33406 return NULL;
33407 }
33408
33409
33410 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33411 PyObject *resultobj = 0;
33412 wxWindow *arg1 = (wxWindow *) 0 ;
33413 wxLayoutDirection result;
33414 void *argp1 = 0 ;
33415 int res1 = 0 ;
33416 PyObject *swig_obj[1] ;
33417
33418 if (!args) SWIG_fail;
33419 swig_obj[0] = args;
33420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33421 if (!SWIG_IsOK(res1)) {
33422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33423 }
33424 arg1 = reinterpret_cast< wxWindow * >(argp1);
33425 {
33426 PyThreadState* __tstate = wxPyBeginAllowThreads();
33427 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33428 wxPyEndAllowThreads(__tstate);
33429 if (PyErr_Occurred()) SWIG_fail;
33430 }
33431 resultobj = SWIG_From_int(static_cast< int >(result));
33432 return resultobj;
33433 fail:
33434 return NULL;
33435 }
33436
33437
33438 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33439 PyObject *resultobj = 0;
33440 wxWindow *arg1 = (wxWindow *) 0 ;
33441 wxLayoutDirection arg2 ;
33442 void *argp1 = 0 ;
33443 int res1 = 0 ;
33444 int val2 ;
33445 int ecode2 = 0 ;
33446 PyObject * obj0 = 0 ;
33447 PyObject * obj1 = 0 ;
33448 char * kwnames[] = {
33449 (char *) "self",(char *) "dir", NULL
33450 };
33451
33452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33454 if (!SWIG_IsOK(res1)) {
33455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33456 }
33457 arg1 = reinterpret_cast< wxWindow * >(argp1);
33458 ecode2 = SWIG_AsVal_int(obj1, &val2);
33459 if (!SWIG_IsOK(ecode2)) {
33460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33461 }
33462 arg2 = static_cast< wxLayoutDirection >(val2);
33463 {
33464 PyThreadState* __tstate = wxPyBeginAllowThreads();
33465 (arg1)->SetLayoutDirection(arg2);
33466 wxPyEndAllowThreads(__tstate);
33467 if (PyErr_Occurred()) SWIG_fail;
33468 }
33469 resultobj = SWIG_Py_Void();
33470 return resultobj;
33471 fail:
33472 return NULL;
33473 }
33474
33475
33476 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33477 PyObject *resultobj = 0;
33478 wxWindow *arg1 = (wxWindow *) 0 ;
33479 int arg2 ;
33480 int arg3 ;
33481 int arg4 ;
33482 int result;
33483 void *argp1 = 0 ;
33484 int res1 = 0 ;
33485 int val2 ;
33486 int ecode2 = 0 ;
33487 int val3 ;
33488 int ecode3 = 0 ;
33489 int val4 ;
33490 int ecode4 = 0 ;
33491 PyObject * obj0 = 0 ;
33492 PyObject * obj1 = 0 ;
33493 PyObject * obj2 = 0 ;
33494 PyObject * obj3 = 0 ;
33495 char * kwnames[] = {
33496 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33497 };
33498
33499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33501 if (!SWIG_IsOK(res1)) {
33502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33503 }
33504 arg1 = reinterpret_cast< wxWindow * >(argp1);
33505 ecode2 = SWIG_AsVal_int(obj1, &val2);
33506 if (!SWIG_IsOK(ecode2)) {
33507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33508 }
33509 arg2 = static_cast< int >(val2);
33510 ecode3 = SWIG_AsVal_int(obj2, &val3);
33511 if (!SWIG_IsOK(ecode3)) {
33512 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33513 }
33514 arg3 = static_cast< int >(val3);
33515 ecode4 = SWIG_AsVal_int(obj3, &val4);
33516 if (!SWIG_IsOK(ecode4)) {
33517 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33518 }
33519 arg4 = static_cast< int >(val4);
33520 {
33521 PyThreadState* __tstate = wxPyBeginAllowThreads();
33522 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33523 wxPyEndAllowThreads(__tstate);
33524 if (PyErr_Occurred()) SWIG_fail;
33525 }
33526 resultobj = SWIG_From_int(static_cast< int >(result));
33527 return resultobj;
33528 fail:
33529 return NULL;
33530 }
33531
33532
33533 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33534 PyObject *resultobj = 0;
33535 wxWindow *arg1 = (wxWindow *) 0 ;
33536 wxSize *arg2 = 0 ;
33537 void *argp1 = 0 ;
33538 int res1 = 0 ;
33539 wxSize temp2 ;
33540 PyObject * obj0 = 0 ;
33541 PyObject * obj1 = 0 ;
33542 char * kwnames[] = {
33543 (char *) "self",(char *) "size", NULL
33544 };
33545
33546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33548 if (!SWIG_IsOK(res1)) {
33549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33550 }
33551 arg1 = reinterpret_cast< wxWindow * >(argp1);
33552 {
33553 arg2 = &temp2;
33554 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33555 }
33556 {
33557 PyThreadState* __tstate = wxPyBeginAllowThreads();
33558 (arg1)->SetSize((wxSize const &)*arg2);
33559 wxPyEndAllowThreads(__tstate);
33560 if (PyErr_Occurred()) SWIG_fail;
33561 }
33562 resultobj = SWIG_Py_Void();
33563 return resultobj;
33564 fail:
33565 return NULL;
33566 }
33567
33568
33569 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33570 PyObject *resultobj = 0;
33571 wxWindow *arg1 = (wxWindow *) 0 ;
33572 int arg2 ;
33573 int arg3 ;
33574 int arg4 ;
33575 int arg5 ;
33576 int arg6 = (int) wxSIZE_AUTO ;
33577 void *argp1 = 0 ;
33578 int res1 = 0 ;
33579 int val2 ;
33580 int ecode2 = 0 ;
33581 int val3 ;
33582 int ecode3 = 0 ;
33583 int val4 ;
33584 int ecode4 = 0 ;
33585 int val5 ;
33586 int ecode5 = 0 ;
33587 int val6 ;
33588 int ecode6 = 0 ;
33589 PyObject * obj0 = 0 ;
33590 PyObject * obj1 = 0 ;
33591 PyObject * obj2 = 0 ;
33592 PyObject * obj3 = 0 ;
33593 PyObject * obj4 = 0 ;
33594 PyObject * obj5 = 0 ;
33595 char * kwnames[] = {
33596 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33597 };
33598
33599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33601 if (!SWIG_IsOK(res1)) {
33602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33603 }
33604 arg1 = reinterpret_cast< wxWindow * >(argp1);
33605 ecode2 = SWIG_AsVal_int(obj1, &val2);
33606 if (!SWIG_IsOK(ecode2)) {
33607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33608 }
33609 arg2 = static_cast< int >(val2);
33610 ecode3 = SWIG_AsVal_int(obj2, &val3);
33611 if (!SWIG_IsOK(ecode3)) {
33612 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33613 }
33614 arg3 = static_cast< int >(val3);
33615 ecode4 = SWIG_AsVal_int(obj3, &val4);
33616 if (!SWIG_IsOK(ecode4)) {
33617 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33618 }
33619 arg4 = static_cast< int >(val4);
33620 ecode5 = SWIG_AsVal_int(obj4, &val5);
33621 if (!SWIG_IsOK(ecode5)) {
33622 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33623 }
33624 arg5 = static_cast< int >(val5);
33625 if (obj5) {
33626 ecode6 = SWIG_AsVal_int(obj5, &val6);
33627 if (!SWIG_IsOK(ecode6)) {
33628 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33629 }
33630 arg6 = static_cast< int >(val6);
33631 }
33632 {
33633 PyThreadState* __tstate = wxPyBeginAllowThreads();
33634 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
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_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33646 PyObject *resultobj = 0;
33647 wxWindow *arg1 = (wxWindow *) 0 ;
33648 wxRect *arg2 = 0 ;
33649 int arg3 = (int) wxSIZE_AUTO ;
33650 void *argp1 = 0 ;
33651 int res1 = 0 ;
33652 wxRect temp2 ;
33653 int val3 ;
33654 int ecode3 = 0 ;
33655 PyObject * obj0 = 0 ;
33656 PyObject * obj1 = 0 ;
33657 PyObject * obj2 = 0 ;
33658 char * kwnames[] = {
33659 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33660 };
33661
33662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33664 if (!SWIG_IsOK(res1)) {
33665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33666 }
33667 arg1 = reinterpret_cast< wxWindow * >(argp1);
33668 {
33669 arg2 = &temp2;
33670 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33671 }
33672 if (obj2) {
33673 ecode3 = SWIG_AsVal_int(obj2, &val3);
33674 if (!SWIG_IsOK(ecode3)) {
33675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33676 }
33677 arg3 = static_cast< int >(val3);
33678 }
33679 {
33680 PyThreadState* __tstate = wxPyBeginAllowThreads();
33681 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33682 wxPyEndAllowThreads(__tstate);
33683 if (PyErr_Occurred()) SWIG_fail;
33684 }
33685 resultobj = SWIG_Py_Void();
33686 return resultobj;
33687 fail:
33688 return NULL;
33689 }
33690
33691
33692 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33693 PyObject *resultobj = 0;
33694 wxWindow *arg1 = (wxWindow *) 0 ;
33695 int arg2 ;
33696 int arg3 ;
33697 void *argp1 = 0 ;
33698 int res1 = 0 ;
33699 int val2 ;
33700 int ecode2 = 0 ;
33701 int val3 ;
33702 int ecode3 = 0 ;
33703 PyObject * obj0 = 0 ;
33704 PyObject * obj1 = 0 ;
33705 PyObject * obj2 = 0 ;
33706 char * kwnames[] = {
33707 (char *) "self",(char *) "width",(char *) "height", NULL
33708 };
33709
33710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33712 if (!SWIG_IsOK(res1)) {
33713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33714 }
33715 arg1 = reinterpret_cast< wxWindow * >(argp1);
33716 ecode2 = SWIG_AsVal_int(obj1, &val2);
33717 if (!SWIG_IsOK(ecode2)) {
33718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33719 }
33720 arg2 = static_cast< int >(val2);
33721 ecode3 = SWIG_AsVal_int(obj2, &val3);
33722 if (!SWIG_IsOK(ecode3)) {
33723 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33724 }
33725 arg3 = static_cast< int >(val3);
33726 {
33727 PyThreadState* __tstate = wxPyBeginAllowThreads();
33728 (arg1)->SetSize(arg2,arg3);
33729 wxPyEndAllowThreads(__tstate);
33730 if (PyErr_Occurred()) SWIG_fail;
33731 }
33732 resultobj = SWIG_Py_Void();
33733 return resultobj;
33734 fail:
33735 return NULL;
33736 }
33737
33738
33739 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33740 PyObject *resultobj = 0;
33741 wxWindow *arg1 = (wxWindow *) 0 ;
33742 wxPoint *arg2 = 0 ;
33743 int arg3 = (int) wxSIZE_USE_EXISTING ;
33744 void *argp1 = 0 ;
33745 int res1 = 0 ;
33746 wxPoint temp2 ;
33747 int val3 ;
33748 int ecode3 = 0 ;
33749 PyObject * obj0 = 0 ;
33750 PyObject * obj1 = 0 ;
33751 PyObject * obj2 = 0 ;
33752 char * kwnames[] = {
33753 (char *) "self",(char *) "pt",(char *) "flags", NULL
33754 };
33755
33756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33758 if (!SWIG_IsOK(res1)) {
33759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33760 }
33761 arg1 = reinterpret_cast< wxWindow * >(argp1);
33762 {
33763 arg2 = &temp2;
33764 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33765 }
33766 if (obj2) {
33767 ecode3 = SWIG_AsVal_int(obj2, &val3);
33768 if (!SWIG_IsOK(ecode3)) {
33769 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33770 }
33771 arg3 = static_cast< int >(val3);
33772 }
33773 {
33774 PyThreadState* __tstate = wxPyBeginAllowThreads();
33775 (arg1)->Move((wxPoint const &)*arg2,arg3);
33776 wxPyEndAllowThreads(__tstate);
33777 if (PyErr_Occurred()) SWIG_fail;
33778 }
33779 resultobj = SWIG_Py_Void();
33780 return resultobj;
33781 fail:
33782 return NULL;
33783 }
33784
33785
33786 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33787 PyObject *resultobj = 0;
33788 wxWindow *arg1 = (wxWindow *) 0 ;
33789 int arg2 ;
33790 int arg3 ;
33791 int arg4 = (int) wxSIZE_USE_EXISTING ;
33792 void *argp1 = 0 ;
33793 int res1 = 0 ;
33794 int val2 ;
33795 int ecode2 = 0 ;
33796 int val3 ;
33797 int ecode3 = 0 ;
33798 int val4 ;
33799 int ecode4 = 0 ;
33800 PyObject * obj0 = 0 ;
33801 PyObject * obj1 = 0 ;
33802 PyObject * obj2 = 0 ;
33803 PyObject * obj3 = 0 ;
33804 char * kwnames[] = {
33805 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33806 };
33807
33808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33810 if (!SWIG_IsOK(res1)) {
33811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33812 }
33813 arg1 = reinterpret_cast< wxWindow * >(argp1);
33814 ecode2 = SWIG_AsVal_int(obj1, &val2);
33815 if (!SWIG_IsOK(ecode2)) {
33816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33817 }
33818 arg2 = static_cast< int >(val2);
33819 ecode3 = SWIG_AsVal_int(obj2, &val3);
33820 if (!SWIG_IsOK(ecode3)) {
33821 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33822 }
33823 arg3 = static_cast< int >(val3);
33824 if (obj3) {
33825 ecode4 = SWIG_AsVal_int(obj3, &val4);
33826 if (!SWIG_IsOK(ecode4)) {
33827 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33828 }
33829 arg4 = static_cast< int >(val4);
33830 }
33831 {
33832 PyThreadState* __tstate = wxPyBeginAllowThreads();
33833 (arg1)->Move(arg2,arg3,arg4);
33834 wxPyEndAllowThreads(__tstate);
33835 if (PyErr_Occurred()) SWIG_fail;
33836 }
33837 resultobj = SWIG_Py_Void();
33838 return resultobj;
33839 fail:
33840 return NULL;
33841 }
33842
33843
33844 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33845 PyObject *resultobj = 0;
33846 wxWindow *arg1 = (wxWindow *) 0 ;
33847 wxSize const &arg2_defvalue = wxDefaultSize ;
33848 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
33849 void *argp1 = 0 ;
33850 int res1 = 0 ;
33851 wxSize temp2 ;
33852 PyObject * obj0 = 0 ;
33853 PyObject * obj1 = 0 ;
33854 char * kwnames[] = {
33855 (char *) "self",(char *) "size", NULL
33856 };
33857
33858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
33859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33860 if (!SWIG_IsOK(res1)) {
33861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33862 }
33863 arg1 = reinterpret_cast< wxWindow * >(argp1);
33864 if (obj1) {
33865 {
33866 arg2 = &temp2;
33867 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33868 }
33869 }
33870 {
33871 PyThreadState* __tstate = wxPyBeginAllowThreads();
33872 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
33873 wxPyEndAllowThreads(__tstate);
33874 if (PyErr_Occurred()) SWIG_fail;
33875 }
33876 resultobj = SWIG_Py_Void();
33877 return resultobj;
33878 fail:
33879 return NULL;
33880 }
33881
33882
33883 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33884 PyObject *resultobj = 0;
33885 wxWindow *arg1 = (wxWindow *) 0 ;
33886 void *argp1 = 0 ;
33887 int res1 = 0 ;
33888 PyObject *swig_obj[1] ;
33889
33890 if (!args) SWIG_fail;
33891 swig_obj[0] = args;
33892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33893 if (!SWIG_IsOK(res1)) {
33894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
33895 }
33896 arg1 = reinterpret_cast< wxWindow * >(argp1);
33897 {
33898 PyThreadState* __tstate = wxPyBeginAllowThreads();
33899 (arg1)->Raise();
33900 wxPyEndAllowThreads(__tstate);
33901 if (PyErr_Occurred()) SWIG_fail;
33902 }
33903 resultobj = SWIG_Py_Void();
33904 return resultobj;
33905 fail:
33906 return NULL;
33907 }
33908
33909
33910 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33911 PyObject *resultobj = 0;
33912 wxWindow *arg1 = (wxWindow *) 0 ;
33913 void *argp1 = 0 ;
33914 int res1 = 0 ;
33915 PyObject *swig_obj[1] ;
33916
33917 if (!args) SWIG_fail;
33918 swig_obj[0] = args;
33919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33920 if (!SWIG_IsOK(res1)) {
33921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
33922 }
33923 arg1 = reinterpret_cast< wxWindow * >(argp1);
33924 {
33925 PyThreadState* __tstate = wxPyBeginAllowThreads();
33926 (arg1)->Lower();
33927 wxPyEndAllowThreads(__tstate);
33928 if (PyErr_Occurred()) SWIG_fail;
33929 }
33930 resultobj = SWIG_Py_Void();
33931 return resultobj;
33932 fail:
33933 return NULL;
33934 }
33935
33936
33937 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33938 PyObject *resultobj = 0;
33939 wxWindow *arg1 = (wxWindow *) 0 ;
33940 wxSize *arg2 = 0 ;
33941 void *argp1 = 0 ;
33942 int res1 = 0 ;
33943 wxSize temp2 ;
33944 PyObject * obj0 = 0 ;
33945 PyObject * obj1 = 0 ;
33946 char * kwnames[] = {
33947 (char *) "self",(char *) "size", NULL
33948 };
33949
33950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
33951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33952 if (!SWIG_IsOK(res1)) {
33953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33954 }
33955 arg1 = reinterpret_cast< wxWindow * >(argp1);
33956 {
33957 arg2 = &temp2;
33958 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33959 }
33960 {
33961 PyThreadState* __tstate = wxPyBeginAllowThreads();
33962 (arg1)->SetClientSize((wxSize const &)*arg2);
33963 wxPyEndAllowThreads(__tstate);
33964 if (PyErr_Occurred()) SWIG_fail;
33965 }
33966 resultobj = SWIG_Py_Void();
33967 return resultobj;
33968 fail:
33969 return NULL;
33970 }
33971
33972
33973 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33974 PyObject *resultobj = 0;
33975 wxWindow *arg1 = (wxWindow *) 0 ;
33976 int arg2 ;
33977 int arg3 ;
33978 void *argp1 = 0 ;
33979 int res1 = 0 ;
33980 int val2 ;
33981 int ecode2 = 0 ;
33982 int val3 ;
33983 int ecode3 = 0 ;
33984 PyObject * obj0 = 0 ;
33985 PyObject * obj1 = 0 ;
33986 PyObject * obj2 = 0 ;
33987 char * kwnames[] = {
33988 (char *) "self",(char *) "width",(char *) "height", NULL
33989 };
33990
33991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33993 if (!SWIG_IsOK(res1)) {
33994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33995 }
33996 arg1 = reinterpret_cast< wxWindow * >(argp1);
33997 ecode2 = SWIG_AsVal_int(obj1, &val2);
33998 if (!SWIG_IsOK(ecode2)) {
33999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
34000 }
34001 arg2 = static_cast< int >(val2);
34002 ecode3 = SWIG_AsVal_int(obj2, &val3);
34003 if (!SWIG_IsOK(ecode3)) {
34004 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
34005 }
34006 arg3 = static_cast< int >(val3);
34007 {
34008 PyThreadState* __tstate = wxPyBeginAllowThreads();
34009 (arg1)->SetClientSize(arg2,arg3);
34010 wxPyEndAllowThreads(__tstate);
34011 if (PyErr_Occurred()) SWIG_fail;
34012 }
34013 resultobj = SWIG_Py_Void();
34014 return resultobj;
34015 fail:
34016 return NULL;
34017 }
34018
34019
34020 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34021 PyObject *resultobj = 0;
34022 wxWindow *arg1 = (wxWindow *) 0 ;
34023 wxRect *arg2 = 0 ;
34024 void *argp1 = 0 ;
34025 int res1 = 0 ;
34026 wxRect temp2 ;
34027 PyObject * obj0 = 0 ;
34028 PyObject * obj1 = 0 ;
34029 char * kwnames[] = {
34030 (char *) "self",(char *) "rect", NULL
34031 };
34032
34033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34035 if (!SWIG_IsOK(res1)) {
34036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34037 }
34038 arg1 = reinterpret_cast< wxWindow * >(argp1);
34039 {
34040 arg2 = &temp2;
34041 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34042 }
34043 {
34044 PyThreadState* __tstate = wxPyBeginAllowThreads();
34045 (arg1)->SetClientSize((wxRect const &)*arg2);
34046 wxPyEndAllowThreads(__tstate);
34047 if (PyErr_Occurred()) SWIG_fail;
34048 }
34049 resultobj = SWIG_Py_Void();
34050 return resultobj;
34051 fail:
34052 return NULL;
34053 }
34054
34055
34056 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34057 PyObject *resultobj = 0;
34058 wxWindow *arg1 = (wxWindow *) 0 ;
34059 wxPoint result;
34060 void *argp1 = 0 ;
34061 int res1 = 0 ;
34062 PyObject *swig_obj[1] ;
34063
34064 if (!args) SWIG_fail;
34065 swig_obj[0] = args;
34066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34067 if (!SWIG_IsOK(res1)) {
34068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34069 }
34070 arg1 = reinterpret_cast< wxWindow * >(argp1);
34071 {
34072 PyThreadState* __tstate = wxPyBeginAllowThreads();
34073 result = ((wxWindow const *)arg1)->GetPosition();
34074 wxPyEndAllowThreads(__tstate);
34075 if (PyErr_Occurred()) SWIG_fail;
34076 }
34077 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34078 return resultobj;
34079 fail:
34080 return NULL;
34081 }
34082
34083
34084 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34085 PyObject *resultobj = 0;
34086 wxWindow *arg1 = (wxWindow *) 0 ;
34087 int *arg2 = (int *) 0 ;
34088 int *arg3 = (int *) 0 ;
34089 void *argp1 = 0 ;
34090 int res1 = 0 ;
34091 int temp2 ;
34092 int res2 = SWIG_TMPOBJ ;
34093 int temp3 ;
34094 int res3 = SWIG_TMPOBJ ;
34095 PyObject *swig_obj[1] ;
34096
34097 arg2 = &temp2;
34098 arg3 = &temp3;
34099 if (!args) SWIG_fail;
34100 swig_obj[0] = args;
34101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34102 if (!SWIG_IsOK(res1)) {
34103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34104 }
34105 arg1 = reinterpret_cast< wxWindow * >(argp1);
34106 {
34107 PyThreadState* __tstate = wxPyBeginAllowThreads();
34108 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34109 wxPyEndAllowThreads(__tstate);
34110 if (PyErr_Occurred()) SWIG_fail;
34111 }
34112 resultobj = SWIG_Py_Void();
34113 if (SWIG_IsTmpObj(res2)) {
34114 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34115 } else {
34116 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34117 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34118 }
34119 if (SWIG_IsTmpObj(res3)) {
34120 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34121 } else {
34122 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34123 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34124 }
34125 return resultobj;
34126 fail:
34127 return NULL;
34128 }
34129
34130
34131 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34132 PyObject *resultobj = 0;
34133 wxWindow *arg1 = (wxWindow *) 0 ;
34134 wxPoint result;
34135 void *argp1 = 0 ;
34136 int res1 = 0 ;
34137 PyObject *swig_obj[1] ;
34138
34139 if (!args) SWIG_fail;
34140 swig_obj[0] = args;
34141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34142 if (!SWIG_IsOK(res1)) {
34143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34144 }
34145 arg1 = reinterpret_cast< wxWindow * >(argp1);
34146 {
34147 PyThreadState* __tstate = wxPyBeginAllowThreads();
34148 result = ((wxWindow const *)arg1)->GetScreenPosition();
34149 wxPyEndAllowThreads(__tstate);
34150 if (PyErr_Occurred()) SWIG_fail;
34151 }
34152 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34153 return resultobj;
34154 fail:
34155 return NULL;
34156 }
34157
34158
34159 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34160 PyObject *resultobj = 0;
34161 wxWindow *arg1 = (wxWindow *) 0 ;
34162 int *arg2 = (int *) 0 ;
34163 int *arg3 = (int *) 0 ;
34164 void *argp1 = 0 ;
34165 int res1 = 0 ;
34166 int temp2 ;
34167 int res2 = SWIG_TMPOBJ ;
34168 int temp3 ;
34169 int res3 = SWIG_TMPOBJ ;
34170 PyObject *swig_obj[1] ;
34171
34172 arg2 = &temp2;
34173 arg3 = &temp3;
34174 if (!args) SWIG_fail;
34175 swig_obj[0] = args;
34176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34177 if (!SWIG_IsOK(res1)) {
34178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34179 }
34180 arg1 = reinterpret_cast< wxWindow * >(argp1);
34181 {
34182 PyThreadState* __tstate = wxPyBeginAllowThreads();
34183 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34184 wxPyEndAllowThreads(__tstate);
34185 if (PyErr_Occurred()) SWIG_fail;
34186 }
34187 resultobj = SWIG_Py_Void();
34188 if (SWIG_IsTmpObj(res2)) {
34189 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34190 } else {
34191 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34192 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34193 }
34194 if (SWIG_IsTmpObj(res3)) {
34195 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34196 } else {
34197 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34198 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34199 }
34200 return resultobj;
34201 fail:
34202 return NULL;
34203 }
34204
34205
34206 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34207 PyObject *resultobj = 0;
34208 wxWindow *arg1 = (wxWindow *) 0 ;
34209 wxRect result;
34210 void *argp1 = 0 ;
34211 int res1 = 0 ;
34212 PyObject *swig_obj[1] ;
34213
34214 if (!args) SWIG_fail;
34215 swig_obj[0] = args;
34216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34217 if (!SWIG_IsOK(res1)) {
34218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34219 }
34220 arg1 = reinterpret_cast< wxWindow * >(argp1);
34221 {
34222 PyThreadState* __tstate = wxPyBeginAllowThreads();
34223 result = ((wxWindow const *)arg1)->GetScreenRect();
34224 wxPyEndAllowThreads(__tstate);
34225 if (PyErr_Occurred()) SWIG_fail;
34226 }
34227 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34228 return resultobj;
34229 fail:
34230 return NULL;
34231 }
34232
34233
34234 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34235 PyObject *resultobj = 0;
34236 wxWindow *arg1 = (wxWindow *) 0 ;
34237 wxSize result;
34238 void *argp1 = 0 ;
34239 int res1 = 0 ;
34240 PyObject *swig_obj[1] ;
34241
34242 if (!args) SWIG_fail;
34243 swig_obj[0] = args;
34244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34245 if (!SWIG_IsOK(res1)) {
34246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34247 }
34248 arg1 = reinterpret_cast< wxWindow * >(argp1);
34249 {
34250 PyThreadState* __tstate = wxPyBeginAllowThreads();
34251 result = ((wxWindow const *)arg1)->GetSize();
34252 wxPyEndAllowThreads(__tstate);
34253 if (PyErr_Occurred()) SWIG_fail;
34254 }
34255 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34256 return resultobj;
34257 fail:
34258 return NULL;
34259 }
34260
34261
34262 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34263 PyObject *resultobj = 0;
34264 wxWindow *arg1 = (wxWindow *) 0 ;
34265 int *arg2 = (int *) 0 ;
34266 int *arg3 = (int *) 0 ;
34267 void *argp1 = 0 ;
34268 int res1 = 0 ;
34269 int temp2 ;
34270 int res2 = SWIG_TMPOBJ ;
34271 int temp3 ;
34272 int res3 = SWIG_TMPOBJ ;
34273 PyObject *swig_obj[1] ;
34274
34275 arg2 = &temp2;
34276 arg3 = &temp3;
34277 if (!args) SWIG_fail;
34278 swig_obj[0] = args;
34279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34280 if (!SWIG_IsOK(res1)) {
34281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34282 }
34283 arg1 = reinterpret_cast< wxWindow * >(argp1);
34284 {
34285 PyThreadState* __tstate = wxPyBeginAllowThreads();
34286 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34287 wxPyEndAllowThreads(__tstate);
34288 if (PyErr_Occurred()) SWIG_fail;
34289 }
34290 resultobj = SWIG_Py_Void();
34291 if (SWIG_IsTmpObj(res2)) {
34292 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34293 } else {
34294 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34295 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34296 }
34297 if (SWIG_IsTmpObj(res3)) {
34298 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34299 } else {
34300 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34301 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34302 }
34303 return resultobj;
34304 fail:
34305 return NULL;
34306 }
34307
34308
34309 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34310 PyObject *resultobj = 0;
34311 wxWindow *arg1 = (wxWindow *) 0 ;
34312 wxRect result;
34313 void *argp1 = 0 ;
34314 int res1 = 0 ;
34315 PyObject *swig_obj[1] ;
34316
34317 if (!args) SWIG_fail;
34318 swig_obj[0] = args;
34319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34320 if (!SWIG_IsOK(res1)) {
34321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34322 }
34323 arg1 = reinterpret_cast< wxWindow * >(argp1);
34324 {
34325 PyThreadState* __tstate = wxPyBeginAllowThreads();
34326 result = ((wxWindow const *)arg1)->GetRect();
34327 wxPyEndAllowThreads(__tstate);
34328 if (PyErr_Occurred()) SWIG_fail;
34329 }
34330 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34331 return resultobj;
34332 fail:
34333 return NULL;
34334 }
34335
34336
34337 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34338 PyObject *resultobj = 0;
34339 wxWindow *arg1 = (wxWindow *) 0 ;
34340 wxSize result;
34341 void *argp1 = 0 ;
34342 int res1 = 0 ;
34343 PyObject *swig_obj[1] ;
34344
34345 if (!args) SWIG_fail;
34346 swig_obj[0] = args;
34347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34348 if (!SWIG_IsOK(res1)) {
34349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34350 }
34351 arg1 = reinterpret_cast< wxWindow * >(argp1);
34352 {
34353 PyThreadState* __tstate = wxPyBeginAllowThreads();
34354 result = ((wxWindow const *)arg1)->GetClientSize();
34355 wxPyEndAllowThreads(__tstate);
34356 if (PyErr_Occurred()) SWIG_fail;
34357 }
34358 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34359 return resultobj;
34360 fail:
34361 return NULL;
34362 }
34363
34364
34365 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34366 PyObject *resultobj = 0;
34367 wxWindow *arg1 = (wxWindow *) 0 ;
34368 int *arg2 = (int *) 0 ;
34369 int *arg3 = (int *) 0 ;
34370 void *argp1 = 0 ;
34371 int res1 = 0 ;
34372 int temp2 ;
34373 int res2 = SWIG_TMPOBJ ;
34374 int temp3 ;
34375 int res3 = SWIG_TMPOBJ ;
34376 PyObject *swig_obj[1] ;
34377
34378 arg2 = &temp2;
34379 arg3 = &temp3;
34380 if (!args) SWIG_fail;
34381 swig_obj[0] = args;
34382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34383 if (!SWIG_IsOK(res1)) {
34384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34385 }
34386 arg1 = reinterpret_cast< wxWindow * >(argp1);
34387 {
34388 PyThreadState* __tstate = wxPyBeginAllowThreads();
34389 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34390 wxPyEndAllowThreads(__tstate);
34391 if (PyErr_Occurred()) SWIG_fail;
34392 }
34393 resultobj = SWIG_Py_Void();
34394 if (SWIG_IsTmpObj(res2)) {
34395 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34396 } else {
34397 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34398 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34399 }
34400 if (SWIG_IsTmpObj(res3)) {
34401 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34402 } else {
34403 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34404 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34405 }
34406 return resultobj;
34407 fail:
34408 return NULL;
34409 }
34410
34411
34412 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34413 PyObject *resultobj = 0;
34414 wxWindow *arg1 = (wxWindow *) 0 ;
34415 wxPoint result;
34416 void *argp1 = 0 ;
34417 int res1 = 0 ;
34418 PyObject *swig_obj[1] ;
34419
34420 if (!args) SWIG_fail;
34421 swig_obj[0] = args;
34422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34423 if (!SWIG_IsOK(res1)) {
34424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34425 }
34426 arg1 = reinterpret_cast< wxWindow * >(argp1);
34427 {
34428 PyThreadState* __tstate = wxPyBeginAllowThreads();
34429 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34430 wxPyEndAllowThreads(__tstate);
34431 if (PyErr_Occurred()) SWIG_fail;
34432 }
34433 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34434 return resultobj;
34435 fail:
34436 return NULL;
34437 }
34438
34439
34440 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34441 PyObject *resultobj = 0;
34442 wxWindow *arg1 = (wxWindow *) 0 ;
34443 wxRect result;
34444 void *argp1 = 0 ;
34445 int res1 = 0 ;
34446 PyObject *swig_obj[1] ;
34447
34448 if (!args) SWIG_fail;
34449 swig_obj[0] = args;
34450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34451 if (!SWIG_IsOK(res1)) {
34452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34453 }
34454 arg1 = reinterpret_cast< wxWindow * >(argp1);
34455 {
34456 PyThreadState* __tstate = wxPyBeginAllowThreads();
34457 result = ((wxWindow const *)arg1)->GetClientRect();
34458 wxPyEndAllowThreads(__tstate);
34459 if (PyErr_Occurred()) SWIG_fail;
34460 }
34461 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34462 return resultobj;
34463 fail:
34464 return NULL;
34465 }
34466
34467
34468 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34469 PyObject *resultobj = 0;
34470 wxWindow *arg1 = (wxWindow *) 0 ;
34471 wxSize result;
34472 void *argp1 = 0 ;
34473 int res1 = 0 ;
34474 PyObject *swig_obj[1] ;
34475
34476 if (!args) SWIG_fail;
34477 swig_obj[0] = args;
34478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34479 if (!SWIG_IsOK(res1)) {
34480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34481 }
34482 arg1 = reinterpret_cast< wxWindow * >(argp1);
34483 {
34484 PyThreadState* __tstate = wxPyBeginAllowThreads();
34485 result = ((wxWindow const *)arg1)->GetBestSize();
34486 wxPyEndAllowThreads(__tstate);
34487 if (PyErr_Occurred()) SWIG_fail;
34488 }
34489 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34490 return resultobj;
34491 fail:
34492 return NULL;
34493 }
34494
34495
34496 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34497 PyObject *resultobj = 0;
34498 wxWindow *arg1 = (wxWindow *) 0 ;
34499 int *arg2 = (int *) 0 ;
34500 int *arg3 = (int *) 0 ;
34501 void *argp1 = 0 ;
34502 int res1 = 0 ;
34503 int temp2 ;
34504 int res2 = SWIG_TMPOBJ ;
34505 int temp3 ;
34506 int res3 = SWIG_TMPOBJ ;
34507 PyObject *swig_obj[1] ;
34508
34509 arg2 = &temp2;
34510 arg3 = &temp3;
34511 if (!args) SWIG_fail;
34512 swig_obj[0] = args;
34513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34514 if (!SWIG_IsOK(res1)) {
34515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34516 }
34517 arg1 = reinterpret_cast< wxWindow * >(argp1);
34518 {
34519 PyThreadState* __tstate = wxPyBeginAllowThreads();
34520 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34521 wxPyEndAllowThreads(__tstate);
34522 if (PyErr_Occurred()) SWIG_fail;
34523 }
34524 resultobj = SWIG_Py_Void();
34525 if (SWIG_IsTmpObj(res2)) {
34526 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34527 } else {
34528 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34529 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34530 }
34531 if (SWIG_IsTmpObj(res3)) {
34532 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34533 } else {
34534 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34535 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34536 }
34537 return resultobj;
34538 fail:
34539 return NULL;
34540 }
34541
34542
34543 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34544 PyObject *resultobj = 0;
34545 wxWindow *arg1 = (wxWindow *) 0 ;
34546 void *argp1 = 0 ;
34547 int res1 = 0 ;
34548 PyObject *swig_obj[1] ;
34549
34550 if (!args) SWIG_fail;
34551 swig_obj[0] = args;
34552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34553 if (!SWIG_IsOK(res1)) {
34554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34555 }
34556 arg1 = reinterpret_cast< wxWindow * >(argp1);
34557 {
34558 PyThreadState* __tstate = wxPyBeginAllowThreads();
34559 (arg1)->InvalidateBestSize();
34560 wxPyEndAllowThreads(__tstate);
34561 if (PyErr_Occurred()) SWIG_fail;
34562 }
34563 resultobj = SWIG_Py_Void();
34564 return resultobj;
34565 fail:
34566 return NULL;
34567 }
34568
34569
34570 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34571 PyObject *resultobj = 0;
34572 wxWindow *arg1 = (wxWindow *) 0 ;
34573 wxSize *arg2 = 0 ;
34574 void *argp1 = 0 ;
34575 int res1 = 0 ;
34576 wxSize temp2 ;
34577 PyObject * obj0 = 0 ;
34578 PyObject * obj1 = 0 ;
34579 char * kwnames[] = {
34580 (char *) "self",(char *) "size", NULL
34581 };
34582
34583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34585 if (!SWIG_IsOK(res1)) {
34586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34587 }
34588 arg1 = reinterpret_cast< wxWindow * >(argp1);
34589 {
34590 arg2 = &temp2;
34591 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34592 }
34593 {
34594 PyThreadState* __tstate = wxPyBeginAllowThreads();
34595 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34596 wxPyEndAllowThreads(__tstate);
34597 if (PyErr_Occurred()) SWIG_fail;
34598 }
34599 resultobj = SWIG_Py_Void();
34600 return resultobj;
34601 fail:
34602 return NULL;
34603 }
34604
34605
34606 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34607 PyObject *resultobj = 0;
34608 wxWindow *arg1 = (wxWindow *) 0 ;
34609 wxSize result;
34610 void *argp1 = 0 ;
34611 int res1 = 0 ;
34612 PyObject *swig_obj[1] ;
34613
34614 if (!args) SWIG_fail;
34615 swig_obj[0] = args;
34616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34617 if (!SWIG_IsOK(res1)) {
34618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34619 }
34620 arg1 = reinterpret_cast< wxWindow * >(argp1);
34621 {
34622 PyThreadState* __tstate = wxPyBeginAllowThreads();
34623 result = ((wxWindow const *)arg1)->GetBestFittingSize();
34624 wxPyEndAllowThreads(__tstate);
34625 if (PyErr_Occurred()) SWIG_fail;
34626 }
34627 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34628 return resultobj;
34629 fail:
34630 return NULL;
34631 }
34632
34633
34634 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34635 PyObject *resultobj = 0;
34636 wxWindow *arg1 = (wxWindow *) 0 ;
34637 wxSize result;
34638 void *argp1 = 0 ;
34639 int res1 = 0 ;
34640 PyObject *swig_obj[1] ;
34641
34642 if (!args) SWIG_fail;
34643 swig_obj[0] = args;
34644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34645 if (!SWIG_IsOK(res1)) {
34646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34647 }
34648 arg1 = reinterpret_cast< wxWindow * >(argp1);
34649 {
34650 PyThreadState* __tstate = wxPyBeginAllowThreads();
34651 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
34652 wxPyEndAllowThreads(__tstate);
34653 if (PyErr_Occurred()) SWIG_fail;
34654 }
34655 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34656 return resultobj;
34657 fail:
34658 return NULL;
34659 }
34660
34661
34662 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34663 PyObject *resultobj = 0;
34664 wxWindow *arg1 = (wxWindow *) 0 ;
34665 int arg2 = (int) wxBOTH ;
34666 void *argp1 = 0 ;
34667 int res1 = 0 ;
34668 int val2 ;
34669 int ecode2 = 0 ;
34670 PyObject * obj0 = 0 ;
34671 PyObject * obj1 = 0 ;
34672 char * kwnames[] = {
34673 (char *) "self",(char *) "direction", NULL
34674 };
34675
34676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34678 if (!SWIG_IsOK(res1)) {
34679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34680 }
34681 arg1 = reinterpret_cast< wxWindow * >(argp1);
34682 if (obj1) {
34683 ecode2 = SWIG_AsVal_int(obj1, &val2);
34684 if (!SWIG_IsOK(ecode2)) {
34685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34686 }
34687 arg2 = static_cast< int >(val2);
34688 }
34689 {
34690 PyThreadState* __tstate = wxPyBeginAllowThreads();
34691 (arg1)->Center(arg2);
34692 wxPyEndAllowThreads(__tstate);
34693 if (PyErr_Occurred()) SWIG_fail;
34694 }
34695 resultobj = SWIG_Py_Void();
34696 return resultobj;
34697 fail:
34698 return NULL;
34699 }
34700
34701
34702 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34703 PyObject *resultobj = 0;
34704 wxWindow *arg1 = (wxWindow *) 0 ;
34705 int arg2 = (int) wxBOTH ;
34706 void *argp1 = 0 ;
34707 int res1 = 0 ;
34708 int val2 ;
34709 int ecode2 = 0 ;
34710 PyObject * obj0 = 0 ;
34711 PyObject * obj1 = 0 ;
34712 char * kwnames[] = {
34713 (char *) "self",(char *) "dir", NULL
34714 };
34715
34716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34718 if (!SWIG_IsOK(res1)) {
34719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34720 }
34721 arg1 = reinterpret_cast< wxWindow * >(argp1);
34722 if (obj1) {
34723 ecode2 = SWIG_AsVal_int(obj1, &val2);
34724 if (!SWIG_IsOK(ecode2)) {
34725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34726 }
34727 arg2 = static_cast< int >(val2);
34728 }
34729 {
34730 PyThreadState* __tstate = wxPyBeginAllowThreads();
34731 (arg1)->CenterOnParent(arg2);
34732 wxPyEndAllowThreads(__tstate);
34733 if (PyErr_Occurred()) SWIG_fail;
34734 }
34735 resultobj = SWIG_Py_Void();
34736 return resultobj;
34737 fail:
34738 return NULL;
34739 }
34740
34741
34742 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34743 PyObject *resultobj = 0;
34744 wxWindow *arg1 = (wxWindow *) 0 ;
34745 void *argp1 = 0 ;
34746 int res1 = 0 ;
34747 PyObject *swig_obj[1] ;
34748
34749 if (!args) SWIG_fail;
34750 swig_obj[0] = args;
34751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34752 if (!SWIG_IsOK(res1)) {
34753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34754 }
34755 arg1 = reinterpret_cast< wxWindow * >(argp1);
34756 {
34757 PyThreadState* __tstate = wxPyBeginAllowThreads();
34758 (arg1)->Fit();
34759 wxPyEndAllowThreads(__tstate);
34760 if (PyErr_Occurred()) SWIG_fail;
34761 }
34762 resultobj = SWIG_Py_Void();
34763 return resultobj;
34764 fail:
34765 return NULL;
34766 }
34767
34768
34769 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34770 PyObject *resultobj = 0;
34771 wxWindow *arg1 = (wxWindow *) 0 ;
34772 void *argp1 = 0 ;
34773 int res1 = 0 ;
34774 PyObject *swig_obj[1] ;
34775
34776 if (!args) SWIG_fail;
34777 swig_obj[0] = args;
34778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34779 if (!SWIG_IsOK(res1)) {
34780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34781 }
34782 arg1 = reinterpret_cast< wxWindow * >(argp1);
34783 {
34784 PyThreadState* __tstate = wxPyBeginAllowThreads();
34785 (arg1)->FitInside();
34786 wxPyEndAllowThreads(__tstate);
34787 if (PyErr_Occurred()) SWIG_fail;
34788 }
34789 resultobj = SWIG_Py_Void();
34790 return resultobj;
34791 fail:
34792 return NULL;
34793 }
34794
34795
34796 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34797 PyObject *resultobj = 0;
34798 wxWindow *arg1 = (wxWindow *) 0 ;
34799 int arg2 ;
34800 int arg3 ;
34801 int arg4 = (int) -1 ;
34802 int arg5 = (int) -1 ;
34803 int arg6 = (int) -1 ;
34804 int arg7 = (int) -1 ;
34805 void *argp1 = 0 ;
34806 int res1 = 0 ;
34807 int val2 ;
34808 int ecode2 = 0 ;
34809 int val3 ;
34810 int ecode3 = 0 ;
34811 int val4 ;
34812 int ecode4 = 0 ;
34813 int val5 ;
34814 int ecode5 = 0 ;
34815 int val6 ;
34816 int ecode6 = 0 ;
34817 int val7 ;
34818 int ecode7 = 0 ;
34819 PyObject * obj0 = 0 ;
34820 PyObject * obj1 = 0 ;
34821 PyObject * obj2 = 0 ;
34822 PyObject * obj3 = 0 ;
34823 PyObject * obj4 = 0 ;
34824 PyObject * obj5 = 0 ;
34825 PyObject * obj6 = 0 ;
34826 char * kwnames[] = {
34827 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34828 };
34829
34830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34832 if (!SWIG_IsOK(res1)) {
34833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34834 }
34835 arg1 = reinterpret_cast< wxWindow * >(argp1);
34836 ecode2 = SWIG_AsVal_int(obj1, &val2);
34837 if (!SWIG_IsOK(ecode2)) {
34838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34839 }
34840 arg2 = static_cast< int >(val2);
34841 ecode3 = SWIG_AsVal_int(obj2, &val3);
34842 if (!SWIG_IsOK(ecode3)) {
34843 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34844 }
34845 arg3 = static_cast< int >(val3);
34846 if (obj3) {
34847 ecode4 = SWIG_AsVal_int(obj3, &val4);
34848 if (!SWIG_IsOK(ecode4)) {
34849 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34850 }
34851 arg4 = static_cast< int >(val4);
34852 }
34853 if (obj4) {
34854 ecode5 = SWIG_AsVal_int(obj4, &val5);
34855 if (!SWIG_IsOK(ecode5)) {
34856 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34857 }
34858 arg5 = static_cast< int >(val5);
34859 }
34860 if (obj5) {
34861 ecode6 = SWIG_AsVal_int(obj5, &val6);
34862 if (!SWIG_IsOK(ecode6)) {
34863 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34864 }
34865 arg6 = static_cast< int >(val6);
34866 }
34867 if (obj6) {
34868 ecode7 = SWIG_AsVal_int(obj6, &val7);
34869 if (!SWIG_IsOK(ecode7)) {
34870 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34871 }
34872 arg7 = static_cast< int >(val7);
34873 }
34874 {
34875 PyThreadState* __tstate = wxPyBeginAllowThreads();
34876 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
34877 wxPyEndAllowThreads(__tstate);
34878 if (PyErr_Occurred()) SWIG_fail;
34879 }
34880 resultobj = SWIG_Py_Void();
34881 return resultobj;
34882 fail:
34883 return NULL;
34884 }
34885
34886
34887 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34888 PyObject *resultobj = 0;
34889 wxWindow *arg1 = (wxWindow *) 0 ;
34890 wxSize *arg2 = 0 ;
34891 wxSize const &arg3_defvalue = wxDefaultSize ;
34892 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34893 wxSize const &arg4_defvalue = wxDefaultSize ;
34894 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
34895 void *argp1 = 0 ;
34896 int res1 = 0 ;
34897 wxSize temp2 ;
34898 wxSize temp3 ;
34899 wxSize temp4 ;
34900 PyObject * obj0 = 0 ;
34901 PyObject * obj1 = 0 ;
34902 PyObject * obj2 = 0 ;
34903 PyObject * obj3 = 0 ;
34904 char * kwnames[] = {
34905 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
34906 };
34907
34908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34910 if (!SWIG_IsOK(res1)) {
34911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34912 }
34913 arg1 = reinterpret_cast< wxWindow * >(argp1);
34914 {
34915 arg2 = &temp2;
34916 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34917 }
34918 if (obj2) {
34919 {
34920 arg3 = &temp3;
34921 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34922 }
34923 }
34924 if (obj3) {
34925 {
34926 arg4 = &temp4;
34927 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
34928 }
34929 }
34930 {
34931 PyThreadState* __tstate = wxPyBeginAllowThreads();
34932 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
34933 wxPyEndAllowThreads(__tstate);
34934 if (PyErr_Occurred()) SWIG_fail;
34935 }
34936 resultobj = SWIG_Py_Void();
34937 return resultobj;
34938 fail:
34939 return NULL;
34940 }
34941
34942
34943 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34944 PyObject *resultobj = 0;
34945 wxWindow *arg1 = (wxWindow *) 0 ;
34946 int arg2 ;
34947 int arg3 ;
34948 int arg4 = (int) -1 ;
34949 int arg5 = (int) -1 ;
34950 void *argp1 = 0 ;
34951 int res1 = 0 ;
34952 int val2 ;
34953 int ecode2 = 0 ;
34954 int val3 ;
34955 int ecode3 = 0 ;
34956 int val4 ;
34957 int ecode4 = 0 ;
34958 int val5 ;
34959 int ecode5 = 0 ;
34960 PyObject * obj0 = 0 ;
34961 PyObject * obj1 = 0 ;
34962 PyObject * obj2 = 0 ;
34963 PyObject * obj3 = 0 ;
34964 PyObject * obj4 = 0 ;
34965 char * kwnames[] = {
34966 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
34967 };
34968
34969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34971 if (!SWIG_IsOK(res1)) {
34972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34973 }
34974 arg1 = reinterpret_cast< wxWindow * >(argp1);
34975 ecode2 = SWIG_AsVal_int(obj1, &val2);
34976 if (!SWIG_IsOK(ecode2)) {
34977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
34978 }
34979 arg2 = static_cast< int >(val2);
34980 ecode3 = SWIG_AsVal_int(obj2, &val3);
34981 if (!SWIG_IsOK(ecode3)) {
34982 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
34983 }
34984 arg3 = static_cast< int >(val3);
34985 if (obj3) {
34986 ecode4 = SWIG_AsVal_int(obj3, &val4);
34987 if (!SWIG_IsOK(ecode4)) {
34988 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
34989 }
34990 arg4 = static_cast< int >(val4);
34991 }
34992 if (obj4) {
34993 ecode5 = SWIG_AsVal_int(obj4, &val5);
34994 if (!SWIG_IsOK(ecode5)) {
34995 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
34996 }
34997 arg5 = static_cast< int >(val5);
34998 }
34999 {
35000 PyThreadState* __tstate = wxPyBeginAllowThreads();
35001 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
35002 wxPyEndAllowThreads(__tstate);
35003 if (PyErr_Occurred()) SWIG_fail;
35004 }
35005 resultobj = SWIG_Py_Void();
35006 return resultobj;
35007 fail:
35008 return NULL;
35009 }
35010
35011
35012 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35013 PyObject *resultobj = 0;
35014 wxWindow *arg1 = (wxWindow *) 0 ;
35015 wxSize *arg2 = 0 ;
35016 wxSize const &arg3_defvalue = wxDefaultSize ;
35017 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35018 void *argp1 = 0 ;
35019 int res1 = 0 ;
35020 wxSize temp2 ;
35021 wxSize temp3 ;
35022 PyObject * obj0 = 0 ;
35023 PyObject * obj1 = 0 ;
35024 PyObject * obj2 = 0 ;
35025 char * kwnames[] = {
35026 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
35027 };
35028
35029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35031 if (!SWIG_IsOK(res1)) {
35032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35033 }
35034 arg1 = reinterpret_cast< wxWindow * >(argp1);
35035 {
35036 arg2 = &temp2;
35037 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35038 }
35039 if (obj2) {
35040 {
35041 arg3 = &temp3;
35042 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35043 }
35044 }
35045 {
35046 PyThreadState* __tstate = wxPyBeginAllowThreads();
35047 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35048 wxPyEndAllowThreads(__tstate);
35049 if (PyErr_Occurred()) SWIG_fail;
35050 }
35051 resultobj = SWIG_Py_Void();
35052 return resultobj;
35053 fail:
35054 return NULL;
35055 }
35056
35057
35058 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35059 PyObject *resultobj = 0;
35060 wxWindow *arg1 = (wxWindow *) 0 ;
35061 wxSize result;
35062 void *argp1 = 0 ;
35063 int res1 = 0 ;
35064 PyObject *swig_obj[1] ;
35065
35066 if (!args) SWIG_fail;
35067 swig_obj[0] = args;
35068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35069 if (!SWIG_IsOK(res1)) {
35070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35071 }
35072 arg1 = reinterpret_cast< wxWindow * >(argp1);
35073 {
35074 PyThreadState* __tstate = wxPyBeginAllowThreads();
35075 result = ((wxWindow const *)arg1)->GetMaxSize();
35076 wxPyEndAllowThreads(__tstate);
35077 if (PyErr_Occurred()) SWIG_fail;
35078 }
35079 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35080 return resultobj;
35081 fail:
35082 return NULL;
35083 }
35084
35085
35086 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35087 PyObject *resultobj = 0;
35088 wxWindow *arg1 = (wxWindow *) 0 ;
35089 wxSize result;
35090 void *argp1 = 0 ;
35091 int res1 = 0 ;
35092 PyObject *swig_obj[1] ;
35093
35094 if (!args) SWIG_fail;
35095 swig_obj[0] = args;
35096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35097 if (!SWIG_IsOK(res1)) {
35098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35099 }
35100 arg1 = reinterpret_cast< wxWindow * >(argp1);
35101 {
35102 PyThreadState* __tstate = wxPyBeginAllowThreads();
35103 result = ((wxWindow const *)arg1)->GetMinSize();
35104 wxPyEndAllowThreads(__tstate);
35105 if (PyErr_Occurred()) SWIG_fail;
35106 }
35107 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35108 return resultobj;
35109 fail:
35110 return NULL;
35111 }
35112
35113
35114 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35115 PyObject *resultobj = 0;
35116 wxWindow *arg1 = (wxWindow *) 0 ;
35117 wxSize *arg2 = 0 ;
35118 void *argp1 = 0 ;
35119 int res1 = 0 ;
35120 wxSize temp2 ;
35121 PyObject * obj0 = 0 ;
35122 PyObject * obj1 = 0 ;
35123 char * kwnames[] = {
35124 (char *) "self",(char *) "minSize", NULL
35125 };
35126
35127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35129 if (!SWIG_IsOK(res1)) {
35130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35131 }
35132 arg1 = reinterpret_cast< wxWindow * >(argp1);
35133 {
35134 arg2 = &temp2;
35135 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35136 }
35137 {
35138 PyThreadState* __tstate = wxPyBeginAllowThreads();
35139 (arg1)->SetMinSize((wxSize const &)*arg2);
35140 wxPyEndAllowThreads(__tstate);
35141 if (PyErr_Occurred()) SWIG_fail;
35142 }
35143 resultobj = SWIG_Py_Void();
35144 return resultobj;
35145 fail:
35146 return NULL;
35147 }
35148
35149
35150 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35151 PyObject *resultobj = 0;
35152 wxWindow *arg1 = (wxWindow *) 0 ;
35153 wxSize *arg2 = 0 ;
35154 void *argp1 = 0 ;
35155 int res1 = 0 ;
35156 wxSize temp2 ;
35157 PyObject * obj0 = 0 ;
35158 PyObject * obj1 = 0 ;
35159 char * kwnames[] = {
35160 (char *) "self",(char *) "maxSize", NULL
35161 };
35162
35163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35165 if (!SWIG_IsOK(res1)) {
35166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35167 }
35168 arg1 = reinterpret_cast< wxWindow * >(argp1);
35169 {
35170 arg2 = &temp2;
35171 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35172 }
35173 {
35174 PyThreadState* __tstate = wxPyBeginAllowThreads();
35175 (arg1)->SetMaxSize((wxSize const &)*arg2);
35176 wxPyEndAllowThreads(__tstate);
35177 if (PyErr_Occurred()) SWIG_fail;
35178 }
35179 resultobj = SWIG_Py_Void();
35180 return resultobj;
35181 fail:
35182 return NULL;
35183 }
35184
35185
35186 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35187 PyObject *resultobj = 0;
35188 wxWindow *arg1 = (wxWindow *) 0 ;
35189 int result;
35190 void *argp1 = 0 ;
35191 int res1 = 0 ;
35192 PyObject *swig_obj[1] ;
35193
35194 if (!args) SWIG_fail;
35195 swig_obj[0] = args;
35196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35197 if (!SWIG_IsOK(res1)) {
35198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35199 }
35200 arg1 = reinterpret_cast< wxWindow * >(argp1);
35201 {
35202 PyThreadState* __tstate = wxPyBeginAllowThreads();
35203 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35204 wxPyEndAllowThreads(__tstate);
35205 if (PyErr_Occurred()) SWIG_fail;
35206 }
35207 resultobj = SWIG_From_int(static_cast< int >(result));
35208 return resultobj;
35209 fail:
35210 return NULL;
35211 }
35212
35213
35214 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35215 PyObject *resultobj = 0;
35216 wxWindow *arg1 = (wxWindow *) 0 ;
35217 int result;
35218 void *argp1 = 0 ;
35219 int res1 = 0 ;
35220 PyObject *swig_obj[1] ;
35221
35222 if (!args) SWIG_fail;
35223 swig_obj[0] = args;
35224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35225 if (!SWIG_IsOK(res1)) {
35226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35227 }
35228 arg1 = reinterpret_cast< wxWindow * >(argp1);
35229 {
35230 PyThreadState* __tstate = wxPyBeginAllowThreads();
35231 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35232 wxPyEndAllowThreads(__tstate);
35233 if (PyErr_Occurred()) SWIG_fail;
35234 }
35235 resultobj = SWIG_From_int(static_cast< int >(result));
35236 return resultobj;
35237 fail:
35238 return NULL;
35239 }
35240
35241
35242 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35243 PyObject *resultobj = 0;
35244 wxWindow *arg1 = (wxWindow *) 0 ;
35245 int result;
35246 void *argp1 = 0 ;
35247 int res1 = 0 ;
35248 PyObject *swig_obj[1] ;
35249
35250 if (!args) SWIG_fail;
35251 swig_obj[0] = args;
35252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35253 if (!SWIG_IsOK(res1)) {
35254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35255 }
35256 arg1 = reinterpret_cast< wxWindow * >(argp1);
35257 {
35258 PyThreadState* __tstate = wxPyBeginAllowThreads();
35259 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35260 wxPyEndAllowThreads(__tstate);
35261 if (PyErr_Occurred()) SWIG_fail;
35262 }
35263 resultobj = SWIG_From_int(static_cast< int >(result));
35264 return resultobj;
35265 fail:
35266 return NULL;
35267 }
35268
35269
35270 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35271 PyObject *resultobj = 0;
35272 wxWindow *arg1 = (wxWindow *) 0 ;
35273 int result;
35274 void *argp1 = 0 ;
35275 int res1 = 0 ;
35276 PyObject *swig_obj[1] ;
35277
35278 if (!args) SWIG_fail;
35279 swig_obj[0] = args;
35280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35281 if (!SWIG_IsOK(res1)) {
35282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35283 }
35284 arg1 = reinterpret_cast< wxWindow * >(argp1);
35285 {
35286 PyThreadState* __tstate = wxPyBeginAllowThreads();
35287 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35288 wxPyEndAllowThreads(__tstate);
35289 if (PyErr_Occurred()) SWIG_fail;
35290 }
35291 resultobj = SWIG_From_int(static_cast< int >(result));
35292 return resultobj;
35293 fail:
35294 return NULL;
35295 }
35296
35297
35298 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35299 PyObject *resultobj = 0;
35300 wxWindow *arg1 = (wxWindow *) 0 ;
35301 wxSize *arg2 = 0 ;
35302 void *argp1 = 0 ;
35303 int res1 = 0 ;
35304 wxSize temp2 ;
35305 PyObject * obj0 = 0 ;
35306 PyObject * obj1 = 0 ;
35307 char * kwnames[] = {
35308 (char *) "self",(char *) "size", NULL
35309 };
35310
35311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35313 if (!SWIG_IsOK(res1)) {
35314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35315 }
35316 arg1 = reinterpret_cast< wxWindow * >(argp1);
35317 {
35318 arg2 = &temp2;
35319 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35320 }
35321 {
35322 PyThreadState* __tstate = wxPyBeginAllowThreads();
35323 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35324 wxPyEndAllowThreads(__tstate);
35325 if (PyErr_Occurred()) SWIG_fail;
35326 }
35327 resultobj = SWIG_Py_Void();
35328 return resultobj;
35329 fail:
35330 return NULL;
35331 }
35332
35333
35334 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35335 PyObject *resultobj = 0;
35336 wxWindow *arg1 = (wxWindow *) 0 ;
35337 int arg2 ;
35338 int arg3 ;
35339 void *argp1 = 0 ;
35340 int res1 = 0 ;
35341 int val2 ;
35342 int ecode2 = 0 ;
35343 int val3 ;
35344 int ecode3 = 0 ;
35345 PyObject * obj0 = 0 ;
35346 PyObject * obj1 = 0 ;
35347 PyObject * obj2 = 0 ;
35348 char * kwnames[] = {
35349 (char *) "self",(char *) "w",(char *) "h", NULL
35350 };
35351
35352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35354 if (!SWIG_IsOK(res1)) {
35355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35356 }
35357 arg1 = reinterpret_cast< wxWindow * >(argp1);
35358 ecode2 = SWIG_AsVal_int(obj1, &val2);
35359 if (!SWIG_IsOK(ecode2)) {
35360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35361 }
35362 arg2 = static_cast< int >(val2);
35363 ecode3 = SWIG_AsVal_int(obj2, &val3);
35364 if (!SWIG_IsOK(ecode3)) {
35365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35366 }
35367 arg3 = static_cast< int >(val3);
35368 {
35369 PyThreadState* __tstate = wxPyBeginAllowThreads();
35370 (arg1)->SetVirtualSize(arg2,arg3);
35371 wxPyEndAllowThreads(__tstate);
35372 if (PyErr_Occurred()) SWIG_fail;
35373 }
35374 resultobj = SWIG_Py_Void();
35375 return resultobj;
35376 fail:
35377 return NULL;
35378 }
35379
35380
35381 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35382 PyObject *resultobj = 0;
35383 wxWindow *arg1 = (wxWindow *) 0 ;
35384 wxSize result;
35385 void *argp1 = 0 ;
35386 int res1 = 0 ;
35387 PyObject *swig_obj[1] ;
35388
35389 if (!args) SWIG_fail;
35390 swig_obj[0] = args;
35391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35392 if (!SWIG_IsOK(res1)) {
35393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35394 }
35395 arg1 = reinterpret_cast< wxWindow * >(argp1);
35396 {
35397 PyThreadState* __tstate = wxPyBeginAllowThreads();
35398 result = ((wxWindow const *)arg1)->GetVirtualSize();
35399 wxPyEndAllowThreads(__tstate);
35400 if (PyErr_Occurred()) SWIG_fail;
35401 }
35402 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35403 return resultobj;
35404 fail:
35405 return NULL;
35406 }
35407
35408
35409 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35410 PyObject *resultobj = 0;
35411 wxWindow *arg1 = (wxWindow *) 0 ;
35412 int *arg2 = (int *) 0 ;
35413 int *arg3 = (int *) 0 ;
35414 void *argp1 = 0 ;
35415 int res1 = 0 ;
35416 int temp2 ;
35417 int res2 = SWIG_TMPOBJ ;
35418 int temp3 ;
35419 int res3 = SWIG_TMPOBJ ;
35420 PyObject *swig_obj[1] ;
35421
35422 arg2 = &temp2;
35423 arg3 = &temp3;
35424 if (!args) SWIG_fail;
35425 swig_obj[0] = args;
35426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35427 if (!SWIG_IsOK(res1)) {
35428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35429 }
35430 arg1 = reinterpret_cast< wxWindow * >(argp1);
35431 {
35432 PyThreadState* __tstate = wxPyBeginAllowThreads();
35433 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35434 wxPyEndAllowThreads(__tstate);
35435 if (PyErr_Occurred()) SWIG_fail;
35436 }
35437 resultobj = SWIG_Py_Void();
35438 if (SWIG_IsTmpObj(res2)) {
35439 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35440 } else {
35441 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35442 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35443 }
35444 if (SWIG_IsTmpObj(res3)) {
35445 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35446 } else {
35447 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35448 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35449 }
35450 return resultobj;
35451 fail:
35452 return NULL;
35453 }
35454
35455
35456 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35457 PyObject *resultobj = 0;
35458 wxWindow *arg1 = (wxWindow *) 0 ;
35459 wxSize result;
35460 void *argp1 = 0 ;
35461 int res1 = 0 ;
35462 PyObject *swig_obj[1] ;
35463
35464 if (!args) SWIG_fail;
35465 swig_obj[0] = args;
35466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35467 if (!SWIG_IsOK(res1)) {
35468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35469 }
35470 arg1 = reinterpret_cast< wxWindow * >(argp1);
35471 {
35472 PyThreadState* __tstate = wxPyBeginAllowThreads();
35473 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35474 wxPyEndAllowThreads(__tstate);
35475 if (PyErr_Occurred()) SWIG_fail;
35476 }
35477 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35478 return resultobj;
35479 fail:
35480 return NULL;
35481 }
35482
35483
35484 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35485 PyObject *resultobj = 0;
35486 wxWindow *arg1 = (wxWindow *) 0 ;
35487 bool arg2 = (bool) true ;
35488 bool result;
35489 void *argp1 = 0 ;
35490 int res1 = 0 ;
35491 bool val2 ;
35492 int ecode2 = 0 ;
35493 PyObject * obj0 = 0 ;
35494 PyObject * obj1 = 0 ;
35495 char * kwnames[] = {
35496 (char *) "self",(char *) "show", NULL
35497 };
35498
35499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35501 if (!SWIG_IsOK(res1)) {
35502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35503 }
35504 arg1 = reinterpret_cast< wxWindow * >(argp1);
35505 if (obj1) {
35506 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35507 if (!SWIG_IsOK(ecode2)) {
35508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35509 }
35510 arg2 = static_cast< bool >(val2);
35511 }
35512 {
35513 PyThreadState* __tstate = wxPyBeginAllowThreads();
35514 result = (bool)(arg1)->Show(arg2);
35515 wxPyEndAllowThreads(__tstate);
35516 if (PyErr_Occurred()) SWIG_fail;
35517 }
35518 {
35519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35520 }
35521 return resultobj;
35522 fail:
35523 return NULL;
35524 }
35525
35526
35527 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35528 PyObject *resultobj = 0;
35529 wxWindow *arg1 = (wxWindow *) 0 ;
35530 bool result;
35531 void *argp1 = 0 ;
35532 int res1 = 0 ;
35533 PyObject *swig_obj[1] ;
35534
35535 if (!args) SWIG_fail;
35536 swig_obj[0] = args;
35537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35538 if (!SWIG_IsOK(res1)) {
35539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35540 }
35541 arg1 = reinterpret_cast< wxWindow * >(argp1);
35542 {
35543 PyThreadState* __tstate = wxPyBeginAllowThreads();
35544 result = (bool)(arg1)->Hide();
35545 wxPyEndAllowThreads(__tstate);
35546 if (PyErr_Occurred()) SWIG_fail;
35547 }
35548 {
35549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35550 }
35551 return resultobj;
35552 fail:
35553 return NULL;
35554 }
35555
35556
35557 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35558 PyObject *resultobj = 0;
35559 wxWindow *arg1 = (wxWindow *) 0 ;
35560 bool arg2 = (bool) true ;
35561 bool result;
35562 void *argp1 = 0 ;
35563 int res1 = 0 ;
35564 bool val2 ;
35565 int ecode2 = 0 ;
35566 PyObject * obj0 = 0 ;
35567 PyObject * obj1 = 0 ;
35568 char * kwnames[] = {
35569 (char *) "self",(char *) "enable", NULL
35570 };
35571
35572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35574 if (!SWIG_IsOK(res1)) {
35575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35576 }
35577 arg1 = reinterpret_cast< wxWindow * >(argp1);
35578 if (obj1) {
35579 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35580 if (!SWIG_IsOK(ecode2)) {
35581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35582 }
35583 arg2 = static_cast< bool >(val2);
35584 }
35585 {
35586 PyThreadState* __tstate = wxPyBeginAllowThreads();
35587 result = (bool)(arg1)->Enable(arg2);
35588 wxPyEndAllowThreads(__tstate);
35589 if (PyErr_Occurred()) SWIG_fail;
35590 }
35591 {
35592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35593 }
35594 return resultobj;
35595 fail:
35596 return NULL;
35597 }
35598
35599
35600 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35601 PyObject *resultobj = 0;
35602 wxWindow *arg1 = (wxWindow *) 0 ;
35603 bool result;
35604 void *argp1 = 0 ;
35605 int res1 = 0 ;
35606 PyObject *swig_obj[1] ;
35607
35608 if (!args) SWIG_fail;
35609 swig_obj[0] = args;
35610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35611 if (!SWIG_IsOK(res1)) {
35612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35613 }
35614 arg1 = reinterpret_cast< wxWindow * >(argp1);
35615 {
35616 PyThreadState* __tstate = wxPyBeginAllowThreads();
35617 result = (bool)(arg1)->Disable();
35618 wxPyEndAllowThreads(__tstate);
35619 if (PyErr_Occurred()) SWIG_fail;
35620 }
35621 {
35622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35623 }
35624 return resultobj;
35625 fail:
35626 return NULL;
35627 }
35628
35629
35630 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35631 PyObject *resultobj = 0;
35632 wxWindow *arg1 = (wxWindow *) 0 ;
35633 bool result;
35634 void *argp1 = 0 ;
35635 int res1 = 0 ;
35636 PyObject *swig_obj[1] ;
35637
35638 if (!args) SWIG_fail;
35639 swig_obj[0] = args;
35640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35641 if (!SWIG_IsOK(res1)) {
35642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35643 }
35644 arg1 = reinterpret_cast< wxWindow * >(argp1);
35645 {
35646 PyThreadState* __tstate = wxPyBeginAllowThreads();
35647 result = (bool)((wxWindow const *)arg1)->IsShown();
35648 wxPyEndAllowThreads(__tstate);
35649 if (PyErr_Occurred()) SWIG_fail;
35650 }
35651 {
35652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35653 }
35654 return resultobj;
35655 fail:
35656 return NULL;
35657 }
35658
35659
35660 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35661 PyObject *resultobj = 0;
35662 wxWindow *arg1 = (wxWindow *) 0 ;
35663 bool result;
35664 void *argp1 = 0 ;
35665 int res1 = 0 ;
35666 PyObject *swig_obj[1] ;
35667
35668 if (!args) SWIG_fail;
35669 swig_obj[0] = args;
35670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35671 if (!SWIG_IsOK(res1)) {
35672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35673 }
35674 arg1 = reinterpret_cast< wxWindow * >(argp1);
35675 {
35676 PyThreadState* __tstate = wxPyBeginAllowThreads();
35677 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35678 wxPyEndAllowThreads(__tstate);
35679 if (PyErr_Occurred()) SWIG_fail;
35680 }
35681 {
35682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35683 }
35684 return resultobj;
35685 fail:
35686 return NULL;
35687 }
35688
35689
35690 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35691 PyObject *resultobj = 0;
35692 wxWindow *arg1 = (wxWindow *) 0 ;
35693 bool result;
35694 void *argp1 = 0 ;
35695 int res1 = 0 ;
35696 PyObject *swig_obj[1] ;
35697
35698 if (!args) SWIG_fail;
35699 swig_obj[0] = args;
35700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35701 if (!SWIG_IsOK(res1)) {
35702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35703 }
35704 arg1 = reinterpret_cast< wxWindow * >(argp1);
35705 {
35706 PyThreadState* __tstate = wxPyBeginAllowThreads();
35707 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35708 wxPyEndAllowThreads(__tstate);
35709 if (PyErr_Occurred()) SWIG_fail;
35710 }
35711 {
35712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35713 }
35714 return resultobj;
35715 fail:
35716 return NULL;
35717 }
35718
35719
35720 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35721 PyObject *resultobj = 0;
35722 wxWindow *arg1 = (wxWindow *) 0 ;
35723 long arg2 ;
35724 void *argp1 = 0 ;
35725 int res1 = 0 ;
35726 long val2 ;
35727 int ecode2 = 0 ;
35728 PyObject * obj0 = 0 ;
35729 PyObject * obj1 = 0 ;
35730 char * kwnames[] = {
35731 (char *) "self",(char *) "style", NULL
35732 };
35733
35734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35736 if (!SWIG_IsOK(res1)) {
35737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35738 }
35739 arg1 = reinterpret_cast< wxWindow * >(argp1);
35740 ecode2 = SWIG_AsVal_long(obj1, &val2);
35741 if (!SWIG_IsOK(ecode2)) {
35742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35743 }
35744 arg2 = static_cast< long >(val2);
35745 {
35746 PyThreadState* __tstate = wxPyBeginAllowThreads();
35747 (arg1)->SetWindowStyleFlag(arg2);
35748 wxPyEndAllowThreads(__tstate);
35749 if (PyErr_Occurred()) SWIG_fail;
35750 }
35751 resultobj = SWIG_Py_Void();
35752 return resultobj;
35753 fail:
35754 return NULL;
35755 }
35756
35757
35758 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35759 PyObject *resultobj = 0;
35760 wxWindow *arg1 = (wxWindow *) 0 ;
35761 long result;
35762 void *argp1 = 0 ;
35763 int res1 = 0 ;
35764 PyObject *swig_obj[1] ;
35765
35766 if (!args) SWIG_fail;
35767 swig_obj[0] = args;
35768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35769 if (!SWIG_IsOK(res1)) {
35770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35771 }
35772 arg1 = reinterpret_cast< wxWindow * >(argp1);
35773 {
35774 PyThreadState* __tstate = wxPyBeginAllowThreads();
35775 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35776 wxPyEndAllowThreads(__tstate);
35777 if (PyErr_Occurred()) SWIG_fail;
35778 }
35779 resultobj = SWIG_From_long(static_cast< long >(result));
35780 return resultobj;
35781 fail:
35782 return NULL;
35783 }
35784
35785
35786 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35787 PyObject *resultobj = 0;
35788 wxWindow *arg1 = (wxWindow *) 0 ;
35789 int arg2 ;
35790 bool result;
35791 void *argp1 = 0 ;
35792 int res1 = 0 ;
35793 int val2 ;
35794 int ecode2 = 0 ;
35795 PyObject * obj0 = 0 ;
35796 PyObject * obj1 = 0 ;
35797 char * kwnames[] = {
35798 (char *) "self",(char *) "flag", NULL
35799 };
35800
35801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35803 if (!SWIG_IsOK(res1)) {
35804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35805 }
35806 arg1 = reinterpret_cast< wxWindow * >(argp1);
35807 ecode2 = SWIG_AsVal_int(obj1, &val2);
35808 if (!SWIG_IsOK(ecode2)) {
35809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35810 }
35811 arg2 = static_cast< int >(val2);
35812 {
35813 PyThreadState* __tstate = wxPyBeginAllowThreads();
35814 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35815 wxPyEndAllowThreads(__tstate);
35816 if (PyErr_Occurred()) SWIG_fail;
35817 }
35818 {
35819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35820 }
35821 return resultobj;
35822 fail:
35823 return NULL;
35824 }
35825
35826
35827 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35828 PyObject *resultobj = 0;
35829 wxWindow *arg1 = (wxWindow *) 0 ;
35830 bool result;
35831 void *argp1 = 0 ;
35832 int res1 = 0 ;
35833 PyObject *swig_obj[1] ;
35834
35835 if (!args) SWIG_fail;
35836 swig_obj[0] = args;
35837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35838 if (!SWIG_IsOK(res1)) {
35839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
35840 }
35841 arg1 = reinterpret_cast< wxWindow * >(argp1);
35842 {
35843 PyThreadState* __tstate = wxPyBeginAllowThreads();
35844 result = (bool)((wxWindow const *)arg1)->IsRetained();
35845 wxPyEndAllowThreads(__tstate);
35846 if (PyErr_Occurred()) SWIG_fail;
35847 }
35848 {
35849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35850 }
35851 return resultobj;
35852 fail:
35853 return NULL;
35854 }
35855
35856
35857 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35858 PyObject *resultobj = 0;
35859 wxWindow *arg1 = (wxWindow *) 0 ;
35860 long arg2 ;
35861 void *argp1 = 0 ;
35862 int res1 = 0 ;
35863 long val2 ;
35864 int ecode2 = 0 ;
35865 PyObject * obj0 = 0 ;
35866 PyObject * obj1 = 0 ;
35867 char * kwnames[] = {
35868 (char *) "self",(char *) "exStyle", NULL
35869 };
35870
35871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35873 if (!SWIG_IsOK(res1)) {
35874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35875 }
35876 arg1 = reinterpret_cast< wxWindow * >(argp1);
35877 ecode2 = SWIG_AsVal_long(obj1, &val2);
35878 if (!SWIG_IsOK(ecode2)) {
35879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
35880 }
35881 arg2 = static_cast< long >(val2);
35882 {
35883 PyThreadState* __tstate = wxPyBeginAllowThreads();
35884 (arg1)->SetExtraStyle(arg2);
35885 wxPyEndAllowThreads(__tstate);
35886 if (PyErr_Occurred()) SWIG_fail;
35887 }
35888 resultobj = SWIG_Py_Void();
35889 return resultobj;
35890 fail:
35891 return NULL;
35892 }
35893
35894
35895 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35896 PyObject *resultobj = 0;
35897 wxWindow *arg1 = (wxWindow *) 0 ;
35898 long result;
35899 void *argp1 = 0 ;
35900 int res1 = 0 ;
35901 PyObject *swig_obj[1] ;
35902
35903 if (!args) SWIG_fail;
35904 swig_obj[0] = args;
35905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35906 if (!SWIG_IsOK(res1)) {
35907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35908 }
35909 arg1 = reinterpret_cast< wxWindow * >(argp1);
35910 {
35911 PyThreadState* __tstate = wxPyBeginAllowThreads();
35912 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
35913 wxPyEndAllowThreads(__tstate);
35914 if (PyErr_Occurred()) SWIG_fail;
35915 }
35916 resultobj = SWIG_From_long(static_cast< long >(result));
35917 return resultobj;
35918 fail:
35919 return NULL;
35920 }
35921
35922
35923 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35924 PyObject *resultobj = 0;
35925 wxWindow *arg1 = (wxWindow *) 0 ;
35926 bool arg2 = (bool) true ;
35927 void *argp1 = 0 ;
35928 int res1 = 0 ;
35929 bool val2 ;
35930 int ecode2 = 0 ;
35931 PyObject * obj0 = 0 ;
35932 PyObject * obj1 = 0 ;
35933 char * kwnames[] = {
35934 (char *) "self",(char *) "modal", NULL
35935 };
35936
35937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
35938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35939 if (!SWIG_IsOK(res1)) {
35940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
35941 }
35942 arg1 = reinterpret_cast< wxWindow * >(argp1);
35943 if (obj1) {
35944 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35945 if (!SWIG_IsOK(ecode2)) {
35946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
35947 }
35948 arg2 = static_cast< bool >(val2);
35949 }
35950 {
35951 PyThreadState* __tstate = wxPyBeginAllowThreads();
35952 (arg1)->MakeModal(arg2);
35953 wxPyEndAllowThreads(__tstate);
35954 if (PyErr_Occurred()) SWIG_fail;
35955 }
35956 resultobj = SWIG_Py_Void();
35957 return resultobj;
35958 fail:
35959 return NULL;
35960 }
35961
35962
35963 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35964 PyObject *resultobj = 0;
35965 wxWindow *arg1 = (wxWindow *) 0 ;
35966 bool arg2 ;
35967 void *argp1 = 0 ;
35968 int res1 = 0 ;
35969 bool val2 ;
35970 int ecode2 = 0 ;
35971 PyObject * obj0 = 0 ;
35972 PyObject * obj1 = 0 ;
35973 char * kwnames[] = {
35974 (char *) "self",(char *) "enableTheme", NULL
35975 };
35976
35977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
35978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35979 if (!SWIG_IsOK(res1)) {
35980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
35981 }
35982 arg1 = reinterpret_cast< wxWindow * >(argp1);
35983 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35984 if (!SWIG_IsOK(ecode2)) {
35985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
35986 }
35987 arg2 = static_cast< bool >(val2);
35988 {
35989 PyThreadState* __tstate = wxPyBeginAllowThreads();
35990 (arg1)->SetThemeEnabled(arg2);
35991 wxPyEndAllowThreads(__tstate);
35992 if (PyErr_Occurred()) SWIG_fail;
35993 }
35994 resultobj = SWIG_Py_Void();
35995 return resultobj;
35996 fail:
35997 return NULL;
35998 }
35999
36000
36001 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36002 PyObject *resultobj = 0;
36003 wxWindow *arg1 = (wxWindow *) 0 ;
36004 bool result;
36005 void *argp1 = 0 ;
36006 int res1 = 0 ;
36007 PyObject *swig_obj[1] ;
36008
36009 if (!args) SWIG_fail;
36010 swig_obj[0] = args;
36011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36012 if (!SWIG_IsOK(res1)) {
36013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36014 }
36015 arg1 = reinterpret_cast< wxWindow * >(argp1);
36016 {
36017 PyThreadState* __tstate = wxPyBeginAllowThreads();
36018 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36019 wxPyEndAllowThreads(__tstate);
36020 if (PyErr_Occurred()) SWIG_fail;
36021 }
36022 {
36023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36024 }
36025 return resultobj;
36026 fail:
36027 return NULL;
36028 }
36029
36030
36031 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36032 PyObject *resultobj = 0;
36033 wxWindow *arg1 = (wxWindow *) 0 ;
36034 void *argp1 = 0 ;
36035 int res1 = 0 ;
36036 PyObject *swig_obj[1] ;
36037
36038 if (!args) SWIG_fail;
36039 swig_obj[0] = args;
36040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36041 if (!SWIG_IsOK(res1)) {
36042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36043 }
36044 arg1 = reinterpret_cast< wxWindow * >(argp1);
36045 {
36046 PyThreadState* __tstate = wxPyBeginAllowThreads();
36047 (arg1)->SetFocus();
36048 wxPyEndAllowThreads(__tstate);
36049 if (PyErr_Occurred()) SWIG_fail;
36050 }
36051 resultobj = SWIG_Py_Void();
36052 return resultobj;
36053 fail:
36054 return NULL;
36055 }
36056
36057
36058 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36059 PyObject *resultobj = 0;
36060 wxWindow *arg1 = (wxWindow *) 0 ;
36061 void *argp1 = 0 ;
36062 int res1 = 0 ;
36063 PyObject *swig_obj[1] ;
36064
36065 if (!args) SWIG_fail;
36066 swig_obj[0] = args;
36067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36068 if (!SWIG_IsOK(res1)) {
36069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36070 }
36071 arg1 = reinterpret_cast< wxWindow * >(argp1);
36072 {
36073 PyThreadState* __tstate = wxPyBeginAllowThreads();
36074 (arg1)->SetFocusFromKbd();
36075 wxPyEndAllowThreads(__tstate);
36076 if (PyErr_Occurred()) SWIG_fail;
36077 }
36078 resultobj = SWIG_Py_Void();
36079 return resultobj;
36080 fail:
36081 return NULL;
36082 }
36083
36084
36085 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36086 PyObject *resultobj = 0;
36087 wxWindow *result = 0 ;
36088
36089 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36090 {
36091 if (!wxPyCheckForApp()) SWIG_fail;
36092 PyThreadState* __tstate = wxPyBeginAllowThreads();
36093 result = (wxWindow *)wxWindow::FindFocus();
36094 wxPyEndAllowThreads(__tstate);
36095 if (PyErr_Occurred()) SWIG_fail;
36096 }
36097 {
36098 resultobj = wxPyMake_wxObject(result, 0);
36099 }
36100 return resultobj;
36101 fail:
36102 return NULL;
36103 }
36104
36105
36106 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36107 PyObject *resultobj = 0;
36108 wxWindow *arg1 = (wxWindow *) 0 ;
36109 bool result;
36110 void *argp1 = 0 ;
36111 int res1 = 0 ;
36112 PyObject *swig_obj[1] ;
36113
36114 if (!args) SWIG_fail;
36115 swig_obj[0] = args;
36116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36117 if (!SWIG_IsOK(res1)) {
36118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36119 }
36120 arg1 = reinterpret_cast< wxWindow * >(argp1);
36121 {
36122 PyThreadState* __tstate = wxPyBeginAllowThreads();
36123 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36124 wxPyEndAllowThreads(__tstate);
36125 if (PyErr_Occurred()) SWIG_fail;
36126 }
36127 {
36128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36129 }
36130 return resultobj;
36131 fail:
36132 return NULL;
36133 }
36134
36135
36136 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36137 PyObject *resultobj = 0;
36138 wxWindow *arg1 = (wxWindow *) 0 ;
36139 bool result;
36140 void *argp1 = 0 ;
36141 int res1 = 0 ;
36142 PyObject *swig_obj[1] ;
36143
36144 if (!args) SWIG_fail;
36145 swig_obj[0] = args;
36146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36147 if (!SWIG_IsOK(res1)) {
36148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36149 }
36150 arg1 = reinterpret_cast< wxWindow * >(argp1);
36151 {
36152 PyThreadState* __tstate = wxPyBeginAllowThreads();
36153 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36154 wxPyEndAllowThreads(__tstate);
36155 if (PyErr_Occurred()) SWIG_fail;
36156 }
36157 {
36158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36159 }
36160 return resultobj;
36161 fail:
36162 return NULL;
36163 }
36164
36165
36166 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36167 PyObject *resultobj = 0;
36168 wxWindow *arg1 = (wxWindow *) 0 ;
36169 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36170 bool result;
36171 void *argp1 = 0 ;
36172 int res1 = 0 ;
36173 int val2 ;
36174 int ecode2 = 0 ;
36175 PyObject * obj0 = 0 ;
36176 PyObject * obj1 = 0 ;
36177 char * kwnames[] = {
36178 (char *) "self",(char *) "flags", NULL
36179 };
36180
36181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36183 if (!SWIG_IsOK(res1)) {
36184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36185 }
36186 arg1 = reinterpret_cast< wxWindow * >(argp1);
36187 if (obj1) {
36188 ecode2 = SWIG_AsVal_int(obj1, &val2);
36189 if (!SWIG_IsOK(ecode2)) {
36190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36191 }
36192 arg2 = static_cast< int >(val2);
36193 }
36194 {
36195 PyThreadState* __tstate = wxPyBeginAllowThreads();
36196 result = (bool)(arg1)->Navigate(arg2);
36197 wxPyEndAllowThreads(__tstate);
36198 if (PyErr_Occurred()) SWIG_fail;
36199 }
36200 {
36201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36202 }
36203 return resultobj;
36204 fail:
36205 return NULL;
36206 }
36207
36208
36209 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36210 PyObject *resultobj = 0;
36211 wxWindow *arg1 = (wxWindow *) 0 ;
36212 wxWindow *arg2 = (wxWindow *) 0 ;
36213 void *argp1 = 0 ;
36214 int res1 = 0 ;
36215 void *argp2 = 0 ;
36216 int res2 = 0 ;
36217 PyObject * obj0 = 0 ;
36218 PyObject * obj1 = 0 ;
36219 char * kwnames[] = {
36220 (char *) "self",(char *) "win", NULL
36221 };
36222
36223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36225 if (!SWIG_IsOK(res1)) {
36226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36227 }
36228 arg1 = reinterpret_cast< wxWindow * >(argp1);
36229 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36230 if (!SWIG_IsOK(res2)) {
36231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36232 }
36233 arg2 = reinterpret_cast< wxWindow * >(argp2);
36234 {
36235 PyThreadState* __tstate = wxPyBeginAllowThreads();
36236 (arg1)->MoveAfterInTabOrder(arg2);
36237 wxPyEndAllowThreads(__tstate);
36238 if (PyErr_Occurred()) SWIG_fail;
36239 }
36240 resultobj = SWIG_Py_Void();
36241 return resultobj;
36242 fail:
36243 return NULL;
36244 }
36245
36246
36247 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36248 PyObject *resultobj = 0;
36249 wxWindow *arg1 = (wxWindow *) 0 ;
36250 wxWindow *arg2 = (wxWindow *) 0 ;
36251 void *argp1 = 0 ;
36252 int res1 = 0 ;
36253 void *argp2 = 0 ;
36254 int res2 = 0 ;
36255 PyObject * obj0 = 0 ;
36256 PyObject * obj1 = 0 ;
36257 char * kwnames[] = {
36258 (char *) "self",(char *) "win", NULL
36259 };
36260
36261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36263 if (!SWIG_IsOK(res1)) {
36264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36265 }
36266 arg1 = reinterpret_cast< wxWindow * >(argp1);
36267 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36268 if (!SWIG_IsOK(res2)) {
36269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36270 }
36271 arg2 = reinterpret_cast< wxWindow * >(argp2);
36272 {
36273 PyThreadState* __tstate = wxPyBeginAllowThreads();
36274 (arg1)->MoveBeforeInTabOrder(arg2);
36275 wxPyEndAllowThreads(__tstate);
36276 if (PyErr_Occurred()) SWIG_fail;
36277 }
36278 resultobj = SWIG_Py_Void();
36279 return resultobj;
36280 fail:
36281 return NULL;
36282 }
36283
36284
36285 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36286 PyObject *resultobj = 0;
36287 wxWindow *arg1 = (wxWindow *) 0 ;
36288 PyObject *result = 0 ;
36289 void *argp1 = 0 ;
36290 int res1 = 0 ;
36291 PyObject *swig_obj[1] ;
36292
36293 if (!args) SWIG_fail;
36294 swig_obj[0] = args;
36295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36296 if (!SWIG_IsOK(res1)) {
36297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36298 }
36299 arg1 = reinterpret_cast< wxWindow * >(argp1);
36300 {
36301 PyThreadState* __tstate = wxPyBeginAllowThreads();
36302 result = (PyObject *)wxWindow_GetChildren(arg1);
36303 wxPyEndAllowThreads(__tstate);
36304 if (PyErr_Occurred()) SWIG_fail;
36305 }
36306 resultobj = result;
36307 return resultobj;
36308 fail:
36309 return NULL;
36310 }
36311
36312
36313 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36314 PyObject *resultobj = 0;
36315 wxWindow *arg1 = (wxWindow *) 0 ;
36316 wxWindow *result = 0 ;
36317 void *argp1 = 0 ;
36318 int res1 = 0 ;
36319 PyObject *swig_obj[1] ;
36320
36321 if (!args) SWIG_fail;
36322 swig_obj[0] = args;
36323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36324 if (!SWIG_IsOK(res1)) {
36325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36326 }
36327 arg1 = reinterpret_cast< wxWindow * >(argp1);
36328 {
36329 PyThreadState* __tstate = wxPyBeginAllowThreads();
36330 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36331 wxPyEndAllowThreads(__tstate);
36332 if (PyErr_Occurred()) SWIG_fail;
36333 }
36334 {
36335 resultobj = wxPyMake_wxObject(result, 0);
36336 }
36337 return resultobj;
36338 fail:
36339 return NULL;
36340 }
36341
36342
36343 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36344 PyObject *resultobj = 0;
36345 wxWindow *arg1 = (wxWindow *) 0 ;
36346 wxWindow *result = 0 ;
36347 void *argp1 = 0 ;
36348 int res1 = 0 ;
36349 PyObject *swig_obj[1] ;
36350
36351 if (!args) SWIG_fail;
36352 swig_obj[0] = args;
36353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36354 if (!SWIG_IsOK(res1)) {
36355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36356 }
36357 arg1 = reinterpret_cast< wxWindow * >(argp1);
36358 {
36359 PyThreadState* __tstate = wxPyBeginAllowThreads();
36360 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36361 wxPyEndAllowThreads(__tstate);
36362 if (PyErr_Occurred()) SWIG_fail;
36363 }
36364 {
36365 resultobj = wxPyMake_wxObject(result, 0);
36366 }
36367 return resultobj;
36368 fail:
36369 return NULL;
36370 }
36371
36372
36373 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36374 PyObject *resultobj = 0;
36375 wxWindow *arg1 = (wxWindow *) 0 ;
36376 bool result;
36377 void *argp1 = 0 ;
36378 int res1 = 0 ;
36379 PyObject *swig_obj[1] ;
36380
36381 if (!args) SWIG_fail;
36382 swig_obj[0] = args;
36383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36384 if (!SWIG_IsOK(res1)) {
36385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36386 }
36387 arg1 = reinterpret_cast< wxWindow * >(argp1);
36388 {
36389 PyThreadState* __tstate = wxPyBeginAllowThreads();
36390 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36391 wxPyEndAllowThreads(__tstate);
36392 if (PyErr_Occurred()) SWIG_fail;
36393 }
36394 {
36395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36396 }
36397 return resultobj;
36398 fail:
36399 return NULL;
36400 }
36401
36402
36403 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36404 PyObject *resultobj = 0;
36405 wxWindow *arg1 = (wxWindow *) 0 ;
36406 wxWindow *arg2 = (wxWindow *) 0 ;
36407 bool result;
36408 void *argp1 = 0 ;
36409 int res1 = 0 ;
36410 void *argp2 = 0 ;
36411 int res2 = 0 ;
36412 PyObject * obj0 = 0 ;
36413 PyObject * obj1 = 0 ;
36414 char * kwnames[] = {
36415 (char *) "self",(char *) "newParent", NULL
36416 };
36417
36418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36420 if (!SWIG_IsOK(res1)) {
36421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36422 }
36423 arg1 = reinterpret_cast< wxWindow * >(argp1);
36424 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36425 if (!SWIG_IsOK(res2)) {
36426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36427 }
36428 arg2 = reinterpret_cast< wxWindow * >(argp2);
36429 {
36430 PyThreadState* __tstate = wxPyBeginAllowThreads();
36431 result = (bool)(arg1)->Reparent(arg2);
36432 wxPyEndAllowThreads(__tstate);
36433 if (PyErr_Occurred()) SWIG_fail;
36434 }
36435 {
36436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36437 }
36438 return resultobj;
36439 fail:
36440 return NULL;
36441 }
36442
36443
36444 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36445 PyObject *resultobj = 0;
36446 wxWindow *arg1 = (wxWindow *) 0 ;
36447 wxWindow *arg2 = (wxWindow *) 0 ;
36448 void *argp1 = 0 ;
36449 int res1 = 0 ;
36450 void *argp2 = 0 ;
36451 int res2 = 0 ;
36452 PyObject * obj0 = 0 ;
36453 PyObject * obj1 = 0 ;
36454 char * kwnames[] = {
36455 (char *) "self",(char *) "child", NULL
36456 };
36457
36458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36460 if (!SWIG_IsOK(res1)) {
36461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36462 }
36463 arg1 = reinterpret_cast< wxWindow * >(argp1);
36464 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36465 if (!SWIG_IsOK(res2)) {
36466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36467 }
36468 arg2 = reinterpret_cast< wxWindow * >(argp2);
36469 {
36470 PyThreadState* __tstate = wxPyBeginAllowThreads();
36471 (arg1)->AddChild(arg2);
36472 wxPyEndAllowThreads(__tstate);
36473 if (PyErr_Occurred()) SWIG_fail;
36474 }
36475 resultobj = SWIG_Py_Void();
36476 return resultobj;
36477 fail:
36478 return NULL;
36479 }
36480
36481
36482 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36483 PyObject *resultobj = 0;
36484 wxWindow *arg1 = (wxWindow *) 0 ;
36485 wxWindow *arg2 = (wxWindow *) 0 ;
36486 void *argp1 = 0 ;
36487 int res1 = 0 ;
36488 void *argp2 = 0 ;
36489 int res2 = 0 ;
36490 PyObject * obj0 = 0 ;
36491 PyObject * obj1 = 0 ;
36492 char * kwnames[] = {
36493 (char *) "self",(char *) "child", NULL
36494 };
36495
36496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36498 if (!SWIG_IsOK(res1)) {
36499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36500 }
36501 arg1 = reinterpret_cast< wxWindow * >(argp1);
36502 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36503 if (!SWIG_IsOK(res2)) {
36504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36505 }
36506 arg2 = reinterpret_cast< wxWindow * >(argp2);
36507 {
36508 PyThreadState* __tstate = wxPyBeginAllowThreads();
36509 (arg1)->RemoveChild(arg2);
36510 wxPyEndAllowThreads(__tstate);
36511 if (PyErr_Occurred()) SWIG_fail;
36512 }
36513 resultobj = SWIG_Py_Void();
36514 return resultobj;
36515 fail:
36516 return NULL;
36517 }
36518
36519
36520 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36521 PyObject *resultobj = 0;
36522 wxWindow *arg1 = (wxWindow *) 0 ;
36523 bool arg2 ;
36524 void *argp1 = 0 ;
36525 int res1 = 0 ;
36526 bool val2 ;
36527 int ecode2 = 0 ;
36528 PyObject * obj0 = 0 ;
36529 PyObject * obj1 = 0 ;
36530 char * kwnames[] = {
36531 (char *) "self",(char *) "on", NULL
36532 };
36533
36534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36536 if (!SWIG_IsOK(res1)) {
36537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36538 }
36539 arg1 = reinterpret_cast< wxWindow * >(argp1);
36540 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36541 if (!SWIG_IsOK(ecode2)) {
36542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36543 }
36544 arg2 = static_cast< bool >(val2);
36545 {
36546 PyThreadState* __tstate = wxPyBeginAllowThreads();
36547 (arg1)->SetDoubleBuffered(arg2);
36548 wxPyEndAllowThreads(__tstate);
36549 if (PyErr_Occurred()) SWIG_fail;
36550 }
36551 resultobj = SWIG_Py_Void();
36552 return resultobj;
36553 fail:
36554 return NULL;
36555 }
36556
36557
36558 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36559 PyObject *resultobj = 0;
36560 wxWindow *arg1 = (wxWindow *) 0 ;
36561 long arg2 ;
36562 wxWindow *result = 0 ;
36563 void *argp1 = 0 ;
36564 int res1 = 0 ;
36565 long val2 ;
36566 int ecode2 = 0 ;
36567 PyObject * obj0 = 0 ;
36568 PyObject * obj1 = 0 ;
36569 char * kwnames[] = {
36570 (char *) "self",(char *) "winid", NULL
36571 };
36572
36573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36575 if (!SWIG_IsOK(res1)) {
36576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36577 }
36578 arg1 = reinterpret_cast< wxWindow * >(argp1);
36579 ecode2 = SWIG_AsVal_long(obj1, &val2);
36580 if (!SWIG_IsOK(ecode2)) {
36581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36582 }
36583 arg2 = static_cast< long >(val2);
36584 {
36585 PyThreadState* __tstate = wxPyBeginAllowThreads();
36586 result = (wxWindow *)(arg1)->FindWindow(arg2);
36587 wxPyEndAllowThreads(__tstate);
36588 if (PyErr_Occurred()) SWIG_fail;
36589 }
36590 {
36591 resultobj = wxPyMake_wxObject(result, 0);
36592 }
36593 return resultobj;
36594 fail:
36595 return NULL;
36596 }
36597
36598
36599 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36600 PyObject *resultobj = 0;
36601 wxWindow *arg1 = (wxWindow *) 0 ;
36602 wxString *arg2 = 0 ;
36603 wxWindow *result = 0 ;
36604 void *argp1 = 0 ;
36605 int res1 = 0 ;
36606 bool temp2 = false ;
36607 PyObject * obj0 = 0 ;
36608 PyObject * obj1 = 0 ;
36609 char * kwnames[] = {
36610 (char *) "self",(char *) "name", NULL
36611 };
36612
36613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36615 if (!SWIG_IsOK(res1)) {
36616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36617 }
36618 arg1 = reinterpret_cast< wxWindow * >(argp1);
36619 {
36620 arg2 = wxString_in_helper(obj1);
36621 if (arg2 == NULL) SWIG_fail;
36622 temp2 = true;
36623 }
36624 {
36625 PyThreadState* __tstate = wxPyBeginAllowThreads();
36626 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36627 wxPyEndAllowThreads(__tstate);
36628 if (PyErr_Occurred()) SWIG_fail;
36629 }
36630 {
36631 resultobj = wxPyMake_wxObject(result, 0);
36632 }
36633 {
36634 if (temp2)
36635 delete arg2;
36636 }
36637 return resultobj;
36638 fail:
36639 {
36640 if (temp2)
36641 delete arg2;
36642 }
36643 return NULL;
36644 }
36645
36646
36647 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36648 PyObject *resultobj = 0;
36649 wxWindow *arg1 = (wxWindow *) 0 ;
36650 wxEvtHandler *result = 0 ;
36651 void *argp1 = 0 ;
36652 int res1 = 0 ;
36653 PyObject *swig_obj[1] ;
36654
36655 if (!args) SWIG_fail;
36656 swig_obj[0] = args;
36657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36658 if (!SWIG_IsOK(res1)) {
36659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36660 }
36661 arg1 = reinterpret_cast< wxWindow * >(argp1);
36662 {
36663 PyThreadState* __tstate = wxPyBeginAllowThreads();
36664 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36665 wxPyEndAllowThreads(__tstate);
36666 if (PyErr_Occurred()) SWIG_fail;
36667 }
36668 {
36669 resultobj = wxPyMake_wxObject(result, 0);
36670 }
36671 return resultobj;
36672 fail:
36673 return NULL;
36674 }
36675
36676
36677 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36678 PyObject *resultobj = 0;
36679 wxWindow *arg1 = (wxWindow *) 0 ;
36680 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36681 void *argp1 = 0 ;
36682 int res1 = 0 ;
36683 void *argp2 = 0 ;
36684 int res2 = 0 ;
36685 PyObject * obj0 = 0 ;
36686 PyObject * obj1 = 0 ;
36687 char * kwnames[] = {
36688 (char *) "self",(char *) "handler", NULL
36689 };
36690
36691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36693 if (!SWIG_IsOK(res1)) {
36694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36695 }
36696 arg1 = reinterpret_cast< wxWindow * >(argp1);
36697 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36698 if (!SWIG_IsOK(res2)) {
36699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36700 }
36701 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36702 {
36703 PyThreadState* __tstate = wxPyBeginAllowThreads();
36704 (arg1)->SetEventHandler(arg2);
36705 wxPyEndAllowThreads(__tstate);
36706 if (PyErr_Occurred()) SWIG_fail;
36707 }
36708 resultobj = SWIG_Py_Void();
36709 return resultobj;
36710 fail:
36711 return NULL;
36712 }
36713
36714
36715 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36716 PyObject *resultobj = 0;
36717 wxWindow *arg1 = (wxWindow *) 0 ;
36718 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36719 void *argp1 = 0 ;
36720 int res1 = 0 ;
36721 void *argp2 = 0 ;
36722 int res2 = 0 ;
36723 PyObject * obj0 = 0 ;
36724 PyObject * obj1 = 0 ;
36725 char * kwnames[] = {
36726 (char *) "self",(char *) "handler", NULL
36727 };
36728
36729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36731 if (!SWIG_IsOK(res1)) {
36732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36733 }
36734 arg1 = reinterpret_cast< wxWindow * >(argp1);
36735 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36736 if (!SWIG_IsOK(res2)) {
36737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36738 }
36739 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36740 {
36741 PyThreadState* __tstate = wxPyBeginAllowThreads();
36742 (arg1)->PushEventHandler(arg2);
36743 wxPyEndAllowThreads(__tstate);
36744 if (PyErr_Occurred()) SWIG_fail;
36745 }
36746 resultobj = SWIG_Py_Void();
36747 return resultobj;
36748 fail:
36749 return NULL;
36750 }
36751
36752
36753 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36754 PyObject *resultobj = 0;
36755 wxWindow *arg1 = (wxWindow *) 0 ;
36756 bool arg2 = (bool) false ;
36757 wxEvtHandler *result = 0 ;
36758 void *argp1 = 0 ;
36759 int res1 = 0 ;
36760 bool val2 ;
36761 int ecode2 = 0 ;
36762 PyObject * obj0 = 0 ;
36763 PyObject * obj1 = 0 ;
36764 char * kwnames[] = {
36765 (char *) "self",(char *) "deleteHandler", NULL
36766 };
36767
36768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36770 if (!SWIG_IsOK(res1)) {
36771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36772 }
36773 arg1 = reinterpret_cast< wxWindow * >(argp1);
36774 if (obj1) {
36775 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36776 if (!SWIG_IsOK(ecode2)) {
36777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
36778 }
36779 arg2 = static_cast< bool >(val2);
36780 }
36781 {
36782 PyThreadState* __tstate = wxPyBeginAllowThreads();
36783 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
36784 wxPyEndAllowThreads(__tstate);
36785 if (PyErr_Occurred()) SWIG_fail;
36786 }
36787 {
36788 resultobj = wxPyMake_wxObject(result, 0);
36789 }
36790 return resultobj;
36791 fail:
36792 return NULL;
36793 }
36794
36795
36796 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36797 PyObject *resultobj = 0;
36798 wxWindow *arg1 = (wxWindow *) 0 ;
36799 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36800 bool result;
36801 void *argp1 = 0 ;
36802 int res1 = 0 ;
36803 void *argp2 = 0 ;
36804 int res2 = 0 ;
36805 PyObject * obj0 = 0 ;
36806 PyObject * obj1 = 0 ;
36807 char * kwnames[] = {
36808 (char *) "self",(char *) "handler", NULL
36809 };
36810
36811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36813 if (!SWIG_IsOK(res1)) {
36814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36815 }
36816 arg1 = reinterpret_cast< wxWindow * >(argp1);
36817 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36818 if (!SWIG_IsOK(res2)) {
36819 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36820 }
36821 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36822 {
36823 PyThreadState* __tstate = wxPyBeginAllowThreads();
36824 result = (bool)(arg1)->RemoveEventHandler(arg2);
36825 wxPyEndAllowThreads(__tstate);
36826 if (PyErr_Occurred()) SWIG_fail;
36827 }
36828 {
36829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36830 }
36831 return resultobj;
36832 fail:
36833 return NULL;
36834 }
36835
36836
36837 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36838 PyObject *resultobj = 0;
36839 wxWindow *arg1 = (wxWindow *) 0 ;
36840 wxValidator *arg2 = 0 ;
36841 void *argp1 = 0 ;
36842 int res1 = 0 ;
36843 void *argp2 = 0 ;
36844 int res2 = 0 ;
36845 PyObject * obj0 = 0 ;
36846 PyObject * obj1 = 0 ;
36847 char * kwnames[] = {
36848 (char *) "self",(char *) "validator", NULL
36849 };
36850
36851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
36852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36853 if (!SWIG_IsOK(res1)) {
36854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36855 }
36856 arg1 = reinterpret_cast< wxWindow * >(argp1);
36857 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
36858 if (!SWIG_IsOK(res2)) {
36859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36860 }
36861 if (!argp2) {
36862 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36863 }
36864 arg2 = reinterpret_cast< wxValidator * >(argp2);
36865 {
36866 PyThreadState* __tstate = wxPyBeginAllowThreads();
36867 (arg1)->SetValidator((wxValidator const &)*arg2);
36868 wxPyEndAllowThreads(__tstate);
36869 if (PyErr_Occurred()) SWIG_fail;
36870 }
36871 resultobj = SWIG_Py_Void();
36872 return resultobj;
36873 fail:
36874 return NULL;
36875 }
36876
36877
36878 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36879 PyObject *resultobj = 0;
36880 wxWindow *arg1 = (wxWindow *) 0 ;
36881 wxValidator *result = 0 ;
36882 void *argp1 = 0 ;
36883 int res1 = 0 ;
36884 PyObject *swig_obj[1] ;
36885
36886 if (!args) SWIG_fail;
36887 swig_obj[0] = args;
36888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36889 if (!SWIG_IsOK(res1)) {
36890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36891 }
36892 arg1 = reinterpret_cast< wxWindow * >(argp1);
36893 {
36894 PyThreadState* __tstate = wxPyBeginAllowThreads();
36895 result = (wxValidator *)(arg1)->GetValidator();
36896 wxPyEndAllowThreads(__tstate);
36897 if (PyErr_Occurred()) SWIG_fail;
36898 }
36899 {
36900 resultobj = wxPyMake_wxObject(result, (bool)0);
36901 }
36902 return resultobj;
36903 fail:
36904 return NULL;
36905 }
36906
36907
36908 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36909 PyObject *resultobj = 0;
36910 wxWindow *arg1 = (wxWindow *) 0 ;
36911 bool result;
36912 void *argp1 = 0 ;
36913 int res1 = 0 ;
36914 PyObject *swig_obj[1] ;
36915
36916 if (!args) SWIG_fail;
36917 swig_obj[0] = args;
36918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36919 if (!SWIG_IsOK(res1)) {
36920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
36921 }
36922 arg1 = reinterpret_cast< wxWindow * >(argp1);
36923 {
36924 PyThreadState* __tstate = wxPyBeginAllowThreads();
36925 result = (bool)(arg1)->Validate();
36926 wxPyEndAllowThreads(__tstate);
36927 if (PyErr_Occurred()) SWIG_fail;
36928 }
36929 {
36930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36931 }
36932 return resultobj;
36933 fail:
36934 return NULL;
36935 }
36936
36937
36938 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36939 PyObject *resultobj = 0;
36940 wxWindow *arg1 = (wxWindow *) 0 ;
36941 bool result;
36942 void *argp1 = 0 ;
36943 int res1 = 0 ;
36944 PyObject *swig_obj[1] ;
36945
36946 if (!args) SWIG_fail;
36947 swig_obj[0] = args;
36948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36949 if (!SWIG_IsOK(res1)) {
36950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36951 }
36952 arg1 = reinterpret_cast< wxWindow * >(argp1);
36953 {
36954 PyThreadState* __tstate = wxPyBeginAllowThreads();
36955 result = (bool)(arg1)->TransferDataToWindow();
36956 wxPyEndAllowThreads(__tstate);
36957 if (PyErr_Occurred()) SWIG_fail;
36958 }
36959 {
36960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36961 }
36962 return resultobj;
36963 fail:
36964 return NULL;
36965 }
36966
36967
36968 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36969 PyObject *resultobj = 0;
36970 wxWindow *arg1 = (wxWindow *) 0 ;
36971 bool result;
36972 void *argp1 = 0 ;
36973 int res1 = 0 ;
36974 PyObject *swig_obj[1] ;
36975
36976 if (!args) SWIG_fail;
36977 swig_obj[0] = args;
36978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36979 if (!SWIG_IsOK(res1)) {
36980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36981 }
36982 arg1 = reinterpret_cast< wxWindow * >(argp1);
36983 {
36984 PyThreadState* __tstate = wxPyBeginAllowThreads();
36985 result = (bool)(arg1)->TransferDataFromWindow();
36986 wxPyEndAllowThreads(__tstate);
36987 if (PyErr_Occurred()) SWIG_fail;
36988 }
36989 {
36990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36991 }
36992 return resultobj;
36993 fail:
36994 return NULL;
36995 }
36996
36997
36998 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36999 PyObject *resultobj = 0;
37000 wxWindow *arg1 = (wxWindow *) 0 ;
37001 void *argp1 = 0 ;
37002 int res1 = 0 ;
37003 PyObject *swig_obj[1] ;
37004
37005 if (!args) SWIG_fail;
37006 swig_obj[0] = args;
37007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37008 if (!SWIG_IsOK(res1)) {
37009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37010 }
37011 arg1 = reinterpret_cast< wxWindow * >(argp1);
37012 {
37013 PyThreadState* __tstate = wxPyBeginAllowThreads();
37014 (arg1)->InitDialog();
37015 wxPyEndAllowThreads(__tstate);
37016 if (PyErr_Occurred()) SWIG_fail;
37017 }
37018 resultobj = SWIG_Py_Void();
37019 return resultobj;
37020 fail:
37021 return NULL;
37022 }
37023
37024
37025 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37026 PyObject *resultobj = 0;
37027 wxWindow *arg1 = (wxWindow *) 0 ;
37028 wxAcceleratorTable *arg2 = 0 ;
37029 void *argp1 = 0 ;
37030 int res1 = 0 ;
37031 void *argp2 = 0 ;
37032 int res2 = 0 ;
37033 PyObject * obj0 = 0 ;
37034 PyObject * obj1 = 0 ;
37035 char * kwnames[] = {
37036 (char *) "self",(char *) "accel", NULL
37037 };
37038
37039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37041 if (!SWIG_IsOK(res1)) {
37042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37043 }
37044 arg1 = reinterpret_cast< wxWindow * >(argp1);
37045 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37046 if (!SWIG_IsOK(res2)) {
37047 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37048 }
37049 if (!argp2) {
37050 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37051 }
37052 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37053 {
37054 PyThreadState* __tstate = wxPyBeginAllowThreads();
37055 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37056 wxPyEndAllowThreads(__tstate);
37057 if (PyErr_Occurred()) SWIG_fail;
37058 }
37059 resultobj = SWIG_Py_Void();
37060 return resultobj;
37061 fail:
37062 return NULL;
37063 }
37064
37065
37066 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37067 PyObject *resultobj = 0;
37068 wxWindow *arg1 = (wxWindow *) 0 ;
37069 wxAcceleratorTable *result = 0 ;
37070 void *argp1 = 0 ;
37071 int res1 = 0 ;
37072 PyObject *swig_obj[1] ;
37073
37074 if (!args) SWIG_fail;
37075 swig_obj[0] = args;
37076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37077 if (!SWIG_IsOK(res1)) {
37078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37079 }
37080 arg1 = reinterpret_cast< wxWindow * >(argp1);
37081 {
37082 PyThreadState* __tstate = wxPyBeginAllowThreads();
37083 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37084 wxPyEndAllowThreads(__tstate);
37085 if (PyErr_Occurred()) SWIG_fail;
37086 }
37087 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37088 return resultobj;
37089 fail:
37090 return NULL;
37091 }
37092
37093
37094 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37095 PyObject *resultobj = 0;
37096 wxWindow *arg1 = (wxWindow *) 0 ;
37097 int arg2 ;
37098 int arg3 ;
37099 int arg4 ;
37100 bool result;
37101 void *argp1 = 0 ;
37102 int res1 = 0 ;
37103 int val2 ;
37104 int ecode2 = 0 ;
37105 int val3 ;
37106 int ecode3 = 0 ;
37107 int val4 ;
37108 int ecode4 = 0 ;
37109 PyObject * obj0 = 0 ;
37110 PyObject * obj1 = 0 ;
37111 PyObject * obj2 = 0 ;
37112 PyObject * obj3 = 0 ;
37113 char * kwnames[] = {
37114 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37115 };
37116
37117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37119 if (!SWIG_IsOK(res1)) {
37120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37121 }
37122 arg1 = reinterpret_cast< wxWindow * >(argp1);
37123 ecode2 = SWIG_AsVal_int(obj1, &val2);
37124 if (!SWIG_IsOK(ecode2)) {
37125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37126 }
37127 arg2 = static_cast< int >(val2);
37128 ecode3 = SWIG_AsVal_int(obj2, &val3);
37129 if (!SWIG_IsOK(ecode3)) {
37130 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37131 }
37132 arg3 = static_cast< int >(val3);
37133 ecode4 = SWIG_AsVal_int(obj3, &val4);
37134 if (!SWIG_IsOK(ecode4)) {
37135 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37136 }
37137 arg4 = static_cast< int >(val4);
37138 {
37139 PyThreadState* __tstate = wxPyBeginAllowThreads();
37140 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37141 wxPyEndAllowThreads(__tstate);
37142 if (PyErr_Occurred()) SWIG_fail;
37143 }
37144 {
37145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37146 }
37147 return resultobj;
37148 fail:
37149 return NULL;
37150 }
37151
37152
37153 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37154 PyObject *resultobj = 0;
37155 wxWindow *arg1 = (wxWindow *) 0 ;
37156 int arg2 ;
37157 bool result;
37158 void *argp1 = 0 ;
37159 int res1 = 0 ;
37160 int val2 ;
37161 int ecode2 = 0 ;
37162 PyObject * obj0 = 0 ;
37163 PyObject * obj1 = 0 ;
37164 char * kwnames[] = {
37165 (char *) "self",(char *) "hotkeyId", NULL
37166 };
37167
37168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37170 if (!SWIG_IsOK(res1)) {
37171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37172 }
37173 arg1 = reinterpret_cast< wxWindow * >(argp1);
37174 ecode2 = SWIG_AsVal_int(obj1, &val2);
37175 if (!SWIG_IsOK(ecode2)) {
37176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37177 }
37178 arg2 = static_cast< int >(val2);
37179 {
37180 PyThreadState* __tstate = wxPyBeginAllowThreads();
37181 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37182 wxPyEndAllowThreads(__tstate);
37183 if (PyErr_Occurred()) SWIG_fail;
37184 }
37185 {
37186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37187 }
37188 return resultobj;
37189 fail:
37190 return NULL;
37191 }
37192
37193
37194 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37195 PyObject *resultobj = 0;
37196 wxWindow *arg1 = (wxWindow *) 0 ;
37197 wxPoint *arg2 = 0 ;
37198 wxPoint result;
37199 void *argp1 = 0 ;
37200 int res1 = 0 ;
37201 wxPoint temp2 ;
37202 PyObject * obj0 = 0 ;
37203 PyObject * obj1 = 0 ;
37204 char * kwnames[] = {
37205 (char *) "self",(char *) "pt", NULL
37206 };
37207
37208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37210 if (!SWIG_IsOK(res1)) {
37211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37212 }
37213 arg1 = reinterpret_cast< wxWindow * >(argp1);
37214 {
37215 arg2 = &temp2;
37216 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37217 }
37218 {
37219 PyThreadState* __tstate = wxPyBeginAllowThreads();
37220 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37221 wxPyEndAllowThreads(__tstate);
37222 if (PyErr_Occurred()) SWIG_fail;
37223 }
37224 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37225 return resultobj;
37226 fail:
37227 return NULL;
37228 }
37229
37230
37231 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37232 PyObject *resultobj = 0;
37233 wxWindow *arg1 = (wxWindow *) 0 ;
37234 wxSize *arg2 = 0 ;
37235 wxSize result;
37236 void *argp1 = 0 ;
37237 int res1 = 0 ;
37238 wxSize temp2 ;
37239 PyObject * obj0 = 0 ;
37240 PyObject * obj1 = 0 ;
37241 char * kwnames[] = {
37242 (char *) "self",(char *) "sz", NULL
37243 };
37244
37245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37247 if (!SWIG_IsOK(res1)) {
37248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37249 }
37250 arg1 = reinterpret_cast< wxWindow * >(argp1);
37251 {
37252 arg2 = &temp2;
37253 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37254 }
37255 {
37256 PyThreadState* __tstate = wxPyBeginAllowThreads();
37257 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37258 wxPyEndAllowThreads(__tstate);
37259 if (PyErr_Occurred()) SWIG_fail;
37260 }
37261 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37262 return resultobj;
37263 fail:
37264 return NULL;
37265 }
37266
37267
37268 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37269 PyObject *resultobj = 0;
37270 wxWindow *arg1 = (wxWindow *) 0 ;
37271 wxPoint *arg2 = 0 ;
37272 wxPoint result;
37273 void *argp1 = 0 ;
37274 int res1 = 0 ;
37275 wxPoint temp2 ;
37276 PyObject * obj0 = 0 ;
37277 PyObject * obj1 = 0 ;
37278 char * kwnames[] = {
37279 (char *) "self",(char *) "pt", NULL
37280 };
37281
37282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37284 if (!SWIG_IsOK(res1)) {
37285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37286 }
37287 arg1 = reinterpret_cast< wxWindow * >(argp1);
37288 {
37289 arg2 = &temp2;
37290 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37291 }
37292 {
37293 PyThreadState* __tstate = wxPyBeginAllowThreads();
37294 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37295 wxPyEndAllowThreads(__tstate);
37296 if (PyErr_Occurred()) SWIG_fail;
37297 }
37298 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37299 return resultobj;
37300 fail:
37301 return NULL;
37302 }
37303
37304
37305 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37306 PyObject *resultobj = 0;
37307 wxWindow *arg1 = (wxWindow *) 0 ;
37308 wxSize *arg2 = 0 ;
37309 wxSize result;
37310 void *argp1 = 0 ;
37311 int res1 = 0 ;
37312 wxSize temp2 ;
37313 PyObject * obj0 = 0 ;
37314 PyObject * obj1 = 0 ;
37315 char * kwnames[] = {
37316 (char *) "self",(char *) "sz", NULL
37317 };
37318
37319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37321 if (!SWIG_IsOK(res1)) {
37322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37323 }
37324 arg1 = reinterpret_cast< wxWindow * >(argp1);
37325 {
37326 arg2 = &temp2;
37327 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37328 }
37329 {
37330 PyThreadState* __tstate = wxPyBeginAllowThreads();
37331 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37332 wxPyEndAllowThreads(__tstate);
37333 if (PyErr_Occurred()) SWIG_fail;
37334 }
37335 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37336 return resultobj;
37337 fail:
37338 return NULL;
37339 }
37340
37341
37342 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37343 PyObject *resultobj = 0;
37344 wxWindow *arg1 = (wxWindow *) 0 ;
37345 wxPoint *arg2 = 0 ;
37346 wxPoint result;
37347 void *argp1 = 0 ;
37348 int res1 = 0 ;
37349 wxPoint temp2 ;
37350 PyObject * obj0 = 0 ;
37351 PyObject * obj1 = 0 ;
37352 char * kwnames[] = {
37353 (char *) "self",(char *) "pt", NULL
37354 };
37355
37356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37358 if (!SWIG_IsOK(res1)) {
37359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37360 }
37361 arg1 = reinterpret_cast< wxWindow * >(argp1);
37362 {
37363 arg2 = &temp2;
37364 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37365 }
37366 {
37367 PyThreadState* __tstate = wxPyBeginAllowThreads();
37368 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37369 wxPyEndAllowThreads(__tstate);
37370 if (PyErr_Occurred()) SWIG_fail;
37371 }
37372 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37373 return resultobj;
37374 fail:
37375 return NULL;
37376 }
37377
37378
37379 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37380 PyObject *resultobj = 0;
37381 wxWindow *arg1 = (wxWindow *) 0 ;
37382 wxSize *arg2 = 0 ;
37383 wxSize result;
37384 void *argp1 = 0 ;
37385 int res1 = 0 ;
37386 wxSize temp2 ;
37387 PyObject * obj0 = 0 ;
37388 PyObject * obj1 = 0 ;
37389 char * kwnames[] = {
37390 (char *) "self",(char *) "sz", NULL
37391 };
37392
37393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37395 if (!SWIG_IsOK(res1)) {
37396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37397 }
37398 arg1 = reinterpret_cast< wxWindow * >(argp1);
37399 {
37400 arg2 = &temp2;
37401 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37402 }
37403 {
37404 PyThreadState* __tstate = wxPyBeginAllowThreads();
37405 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37406 wxPyEndAllowThreads(__tstate);
37407 if (PyErr_Occurred()) SWIG_fail;
37408 }
37409 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37410 return resultobj;
37411 fail:
37412 return NULL;
37413 }
37414
37415
37416 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37417 PyObject *resultobj = 0;
37418 wxWindow *arg1 = (wxWindow *) 0 ;
37419 int arg2 ;
37420 int arg3 ;
37421 void *argp1 = 0 ;
37422 int res1 = 0 ;
37423 int val2 ;
37424 int ecode2 = 0 ;
37425 int val3 ;
37426 int ecode3 = 0 ;
37427 PyObject * obj0 = 0 ;
37428 PyObject * obj1 = 0 ;
37429 PyObject * obj2 = 0 ;
37430 char * kwnames[] = {
37431 (char *) "self",(char *) "x",(char *) "y", NULL
37432 };
37433
37434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37436 if (!SWIG_IsOK(res1)) {
37437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37438 }
37439 arg1 = reinterpret_cast< wxWindow * >(argp1);
37440 ecode2 = SWIG_AsVal_int(obj1, &val2);
37441 if (!SWIG_IsOK(ecode2)) {
37442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37443 }
37444 arg2 = static_cast< int >(val2);
37445 ecode3 = SWIG_AsVal_int(obj2, &val3);
37446 if (!SWIG_IsOK(ecode3)) {
37447 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37448 }
37449 arg3 = static_cast< int >(val3);
37450 {
37451 PyThreadState* __tstate = wxPyBeginAllowThreads();
37452 (arg1)->WarpPointer(arg2,arg3);
37453 wxPyEndAllowThreads(__tstate);
37454 if (PyErr_Occurred()) SWIG_fail;
37455 }
37456 resultobj = SWIG_Py_Void();
37457 return resultobj;
37458 fail:
37459 return NULL;
37460 }
37461
37462
37463 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37464 PyObject *resultobj = 0;
37465 wxWindow *arg1 = (wxWindow *) 0 ;
37466 void *argp1 = 0 ;
37467 int res1 = 0 ;
37468 PyObject *swig_obj[1] ;
37469
37470 if (!args) SWIG_fail;
37471 swig_obj[0] = args;
37472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37473 if (!SWIG_IsOK(res1)) {
37474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37475 }
37476 arg1 = reinterpret_cast< wxWindow * >(argp1);
37477 {
37478 PyThreadState* __tstate = wxPyBeginAllowThreads();
37479 (arg1)->CaptureMouse();
37480 wxPyEndAllowThreads(__tstate);
37481 if (PyErr_Occurred()) SWIG_fail;
37482 }
37483 resultobj = SWIG_Py_Void();
37484 return resultobj;
37485 fail:
37486 return NULL;
37487 }
37488
37489
37490 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37491 PyObject *resultobj = 0;
37492 wxWindow *arg1 = (wxWindow *) 0 ;
37493 void *argp1 = 0 ;
37494 int res1 = 0 ;
37495 PyObject *swig_obj[1] ;
37496
37497 if (!args) SWIG_fail;
37498 swig_obj[0] = args;
37499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37500 if (!SWIG_IsOK(res1)) {
37501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37502 }
37503 arg1 = reinterpret_cast< wxWindow * >(argp1);
37504 {
37505 PyThreadState* __tstate = wxPyBeginAllowThreads();
37506 (arg1)->ReleaseMouse();
37507 wxPyEndAllowThreads(__tstate);
37508 if (PyErr_Occurred()) SWIG_fail;
37509 }
37510 resultobj = SWIG_Py_Void();
37511 return resultobj;
37512 fail:
37513 return NULL;
37514 }
37515
37516
37517 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37518 PyObject *resultobj = 0;
37519 wxWindow *result = 0 ;
37520
37521 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37522 {
37523 if (!wxPyCheckForApp()) SWIG_fail;
37524 PyThreadState* __tstate = wxPyBeginAllowThreads();
37525 result = (wxWindow *)wxWindow::GetCapture();
37526 wxPyEndAllowThreads(__tstate);
37527 if (PyErr_Occurred()) SWIG_fail;
37528 }
37529 {
37530 resultobj = wxPyMake_wxObject(result, 0);
37531 }
37532 return resultobj;
37533 fail:
37534 return NULL;
37535 }
37536
37537
37538 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37539 PyObject *resultobj = 0;
37540 wxWindow *arg1 = (wxWindow *) 0 ;
37541 bool result;
37542 void *argp1 = 0 ;
37543 int res1 = 0 ;
37544 PyObject *swig_obj[1] ;
37545
37546 if (!args) SWIG_fail;
37547 swig_obj[0] = args;
37548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37549 if (!SWIG_IsOK(res1)) {
37550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37551 }
37552 arg1 = reinterpret_cast< wxWindow * >(argp1);
37553 {
37554 PyThreadState* __tstate = wxPyBeginAllowThreads();
37555 result = (bool)((wxWindow const *)arg1)->HasCapture();
37556 wxPyEndAllowThreads(__tstate);
37557 if (PyErr_Occurred()) SWIG_fail;
37558 }
37559 {
37560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37561 }
37562 return resultobj;
37563 fail:
37564 return NULL;
37565 }
37566
37567
37568 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37569 PyObject *resultobj = 0;
37570 wxWindow *arg1 = (wxWindow *) 0 ;
37571 bool arg2 = (bool) true ;
37572 wxRect *arg3 = (wxRect *) NULL ;
37573 void *argp1 = 0 ;
37574 int res1 = 0 ;
37575 bool val2 ;
37576 int ecode2 = 0 ;
37577 void *argp3 = 0 ;
37578 int res3 = 0 ;
37579 PyObject * obj0 = 0 ;
37580 PyObject * obj1 = 0 ;
37581 PyObject * obj2 = 0 ;
37582 char * kwnames[] = {
37583 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37584 };
37585
37586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37588 if (!SWIG_IsOK(res1)) {
37589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37590 }
37591 arg1 = reinterpret_cast< wxWindow * >(argp1);
37592 if (obj1) {
37593 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37594 if (!SWIG_IsOK(ecode2)) {
37595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37596 }
37597 arg2 = static_cast< bool >(val2);
37598 }
37599 if (obj2) {
37600 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37601 if (!SWIG_IsOK(res3)) {
37602 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37603 }
37604 arg3 = reinterpret_cast< wxRect * >(argp3);
37605 }
37606 {
37607 PyThreadState* __tstate = wxPyBeginAllowThreads();
37608 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37609 wxPyEndAllowThreads(__tstate);
37610 if (PyErr_Occurred()) SWIG_fail;
37611 }
37612 resultobj = SWIG_Py_Void();
37613 return resultobj;
37614 fail:
37615 return NULL;
37616 }
37617
37618
37619 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37620 PyObject *resultobj = 0;
37621 wxWindow *arg1 = (wxWindow *) 0 ;
37622 wxRect *arg2 = 0 ;
37623 bool arg3 = (bool) true ;
37624 void *argp1 = 0 ;
37625 int res1 = 0 ;
37626 wxRect temp2 ;
37627 bool val3 ;
37628 int ecode3 = 0 ;
37629 PyObject * obj0 = 0 ;
37630 PyObject * obj1 = 0 ;
37631 PyObject * obj2 = 0 ;
37632 char * kwnames[] = {
37633 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37634 };
37635
37636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37638 if (!SWIG_IsOK(res1)) {
37639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37640 }
37641 arg1 = reinterpret_cast< wxWindow * >(argp1);
37642 {
37643 arg2 = &temp2;
37644 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37645 }
37646 if (obj2) {
37647 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37648 if (!SWIG_IsOK(ecode3)) {
37649 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37650 }
37651 arg3 = static_cast< bool >(val3);
37652 }
37653 {
37654 PyThreadState* __tstate = wxPyBeginAllowThreads();
37655 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37656 wxPyEndAllowThreads(__tstate);
37657 if (PyErr_Occurred()) SWIG_fail;
37658 }
37659 resultobj = SWIG_Py_Void();
37660 return resultobj;
37661 fail:
37662 return NULL;
37663 }
37664
37665
37666 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37667 PyObject *resultobj = 0;
37668 wxWindow *arg1 = (wxWindow *) 0 ;
37669 void *argp1 = 0 ;
37670 int res1 = 0 ;
37671 PyObject *swig_obj[1] ;
37672
37673 if (!args) SWIG_fail;
37674 swig_obj[0] = args;
37675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37676 if (!SWIG_IsOK(res1)) {
37677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
37678 }
37679 arg1 = reinterpret_cast< wxWindow * >(argp1);
37680 {
37681 PyThreadState* __tstate = wxPyBeginAllowThreads();
37682 (arg1)->Update();
37683 wxPyEndAllowThreads(__tstate);
37684 if (PyErr_Occurred()) SWIG_fail;
37685 }
37686 resultobj = SWIG_Py_Void();
37687 return resultobj;
37688 fail:
37689 return NULL;
37690 }
37691
37692
37693 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37694 PyObject *resultobj = 0;
37695 wxWindow *arg1 = (wxWindow *) 0 ;
37696 void *argp1 = 0 ;
37697 int res1 = 0 ;
37698 PyObject *swig_obj[1] ;
37699
37700 if (!args) SWIG_fail;
37701 swig_obj[0] = args;
37702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37703 if (!SWIG_IsOK(res1)) {
37704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
37705 }
37706 arg1 = reinterpret_cast< wxWindow * >(argp1);
37707 {
37708 PyThreadState* __tstate = wxPyBeginAllowThreads();
37709 (arg1)->ClearBackground();
37710 wxPyEndAllowThreads(__tstate);
37711 if (PyErr_Occurred()) SWIG_fail;
37712 }
37713 resultobj = SWIG_Py_Void();
37714 return resultobj;
37715 fail:
37716 return NULL;
37717 }
37718
37719
37720 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37721 PyObject *resultobj = 0;
37722 wxWindow *arg1 = (wxWindow *) 0 ;
37723 void *argp1 = 0 ;
37724 int res1 = 0 ;
37725 PyObject *swig_obj[1] ;
37726
37727 if (!args) SWIG_fail;
37728 swig_obj[0] = args;
37729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37730 if (!SWIG_IsOK(res1)) {
37731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
37732 }
37733 arg1 = reinterpret_cast< wxWindow * >(argp1);
37734 {
37735 PyThreadState* __tstate = wxPyBeginAllowThreads();
37736 (arg1)->Freeze();
37737 wxPyEndAllowThreads(__tstate);
37738 if (PyErr_Occurred()) SWIG_fail;
37739 }
37740 resultobj = SWIG_Py_Void();
37741 return resultobj;
37742 fail:
37743 return NULL;
37744 }
37745
37746
37747 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37748 PyObject *resultobj = 0;
37749 wxWindow *arg1 = (wxWindow *) 0 ;
37750 bool result;
37751 void *argp1 = 0 ;
37752 int res1 = 0 ;
37753 PyObject *swig_obj[1] ;
37754
37755 if (!args) SWIG_fail;
37756 swig_obj[0] = args;
37757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37758 if (!SWIG_IsOK(res1)) {
37759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37760 }
37761 arg1 = reinterpret_cast< wxWindow * >(argp1);
37762 {
37763 PyThreadState* __tstate = wxPyBeginAllowThreads();
37764 result = (bool)((wxWindow const *)arg1)->IsFrozen();
37765 wxPyEndAllowThreads(__tstate);
37766 if (PyErr_Occurred()) SWIG_fail;
37767 }
37768 {
37769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37770 }
37771 return resultobj;
37772 fail:
37773 return NULL;
37774 }
37775
37776
37777 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37778 PyObject *resultobj = 0;
37779 wxWindow *arg1 = (wxWindow *) 0 ;
37780 void *argp1 = 0 ;
37781 int res1 = 0 ;
37782 PyObject *swig_obj[1] ;
37783
37784 if (!args) SWIG_fail;
37785 swig_obj[0] = args;
37786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37787 if (!SWIG_IsOK(res1)) {
37788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
37789 }
37790 arg1 = reinterpret_cast< wxWindow * >(argp1);
37791 {
37792 PyThreadState* __tstate = wxPyBeginAllowThreads();
37793 (arg1)->Thaw();
37794 wxPyEndAllowThreads(__tstate);
37795 if (PyErr_Occurred()) SWIG_fail;
37796 }
37797 resultobj = SWIG_Py_Void();
37798 return resultobj;
37799 fail:
37800 return NULL;
37801 }
37802
37803
37804 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37805 PyObject *resultobj = 0;
37806 wxWindow *arg1 = (wxWindow *) 0 ;
37807 wxDC *arg2 = 0 ;
37808 void *argp1 = 0 ;
37809 int res1 = 0 ;
37810 void *argp2 = 0 ;
37811 int res2 = 0 ;
37812 PyObject * obj0 = 0 ;
37813 PyObject * obj1 = 0 ;
37814 char * kwnames[] = {
37815 (char *) "self",(char *) "dc", NULL
37816 };
37817
37818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
37819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37820 if (!SWIG_IsOK(res1)) {
37821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
37822 }
37823 arg1 = reinterpret_cast< wxWindow * >(argp1);
37824 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
37825 if (!SWIG_IsOK(res2)) {
37826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37827 }
37828 if (!argp2) {
37829 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37830 }
37831 arg2 = reinterpret_cast< wxDC * >(argp2);
37832 {
37833 PyThreadState* __tstate = wxPyBeginAllowThreads();
37834 (arg1)->PrepareDC(*arg2);
37835 wxPyEndAllowThreads(__tstate);
37836 if (PyErr_Occurred()) SWIG_fail;
37837 }
37838 resultobj = SWIG_Py_Void();
37839 return resultobj;
37840 fail:
37841 return NULL;
37842 }
37843
37844
37845 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37846 PyObject *resultobj = 0;
37847 wxWindow *arg1 = (wxWindow *) 0 ;
37848 bool result;
37849 void *argp1 = 0 ;
37850 int res1 = 0 ;
37851 PyObject *swig_obj[1] ;
37852
37853 if (!args) SWIG_fail;
37854 swig_obj[0] = args;
37855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37856 if (!SWIG_IsOK(res1)) {
37857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
37858 }
37859 arg1 = reinterpret_cast< wxWindow * >(argp1);
37860 {
37861 PyThreadState* __tstate = wxPyBeginAllowThreads();
37862 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
37863 wxPyEndAllowThreads(__tstate);
37864 if (PyErr_Occurred()) SWIG_fail;
37865 }
37866 {
37867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37868 }
37869 return resultobj;
37870 fail:
37871 return NULL;
37872 }
37873
37874
37875 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37876 PyObject *resultobj = 0;
37877 wxWindow *arg1 = (wxWindow *) 0 ;
37878 wxRegion *result = 0 ;
37879 void *argp1 = 0 ;
37880 int res1 = 0 ;
37881 PyObject *swig_obj[1] ;
37882
37883 if (!args) SWIG_fail;
37884 swig_obj[0] = args;
37885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37886 if (!SWIG_IsOK(res1)) {
37887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
37888 }
37889 arg1 = reinterpret_cast< wxWindow * >(argp1);
37890 {
37891 PyThreadState* __tstate = wxPyBeginAllowThreads();
37892 {
37893 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
37894 result = (wxRegion *) &_result_ref;
37895 }
37896 wxPyEndAllowThreads(__tstate);
37897 if (PyErr_Occurred()) SWIG_fail;
37898 }
37899 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
37900 return resultobj;
37901 fail:
37902 return NULL;
37903 }
37904
37905
37906 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37907 PyObject *resultobj = 0;
37908 wxWindow *arg1 = (wxWindow *) 0 ;
37909 wxRect result;
37910 void *argp1 = 0 ;
37911 int res1 = 0 ;
37912 PyObject *swig_obj[1] ;
37913
37914 if (!args) SWIG_fail;
37915 swig_obj[0] = args;
37916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37917 if (!SWIG_IsOK(res1)) {
37918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
37919 }
37920 arg1 = reinterpret_cast< wxWindow * >(argp1);
37921 {
37922 PyThreadState* __tstate = wxPyBeginAllowThreads();
37923 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
37924 wxPyEndAllowThreads(__tstate);
37925 if (PyErr_Occurred()) SWIG_fail;
37926 }
37927 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
37928 return resultobj;
37929 fail:
37930 return NULL;
37931 }
37932
37933
37934 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37935 PyObject *resultobj = 0;
37936 wxWindow *arg1 = (wxWindow *) 0 ;
37937 int arg2 ;
37938 int arg3 ;
37939 int arg4 = (int) 1 ;
37940 int arg5 = (int) 1 ;
37941 bool result;
37942 void *argp1 = 0 ;
37943 int res1 = 0 ;
37944 int val2 ;
37945 int ecode2 = 0 ;
37946 int val3 ;
37947 int ecode3 = 0 ;
37948 int val4 ;
37949 int ecode4 = 0 ;
37950 int val5 ;
37951 int ecode5 = 0 ;
37952 PyObject * obj0 = 0 ;
37953 PyObject * obj1 = 0 ;
37954 PyObject * obj2 = 0 ;
37955 PyObject * obj3 = 0 ;
37956 PyObject * obj4 = 0 ;
37957 char * kwnames[] = {
37958 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
37959 };
37960
37961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37963 if (!SWIG_IsOK(res1)) {
37964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
37965 }
37966 arg1 = reinterpret_cast< wxWindow * >(argp1);
37967 ecode2 = SWIG_AsVal_int(obj1, &val2);
37968 if (!SWIG_IsOK(ecode2)) {
37969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
37970 }
37971 arg2 = static_cast< int >(val2);
37972 ecode3 = SWIG_AsVal_int(obj2, &val3);
37973 if (!SWIG_IsOK(ecode3)) {
37974 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
37975 }
37976 arg3 = static_cast< int >(val3);
37977 if (obj3) {
37978 ecode4 = SWIG_AsVal_int(obj3, &val4);
37979 if (!SWIG_IsOK(ecode4)) {
37980 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
37981 }
37982 arg4 = static_cast< int >(val4);
37983 }
37984 if (obj4) {
37985 ecode5 = SWIG_AsVal_int(obj4, &val5);
37986 if (!SWIG_IsOK(ecode5)) {
37987 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
37988 }
37989 arg5 = static_cast< int >(val5);
37990 }
37991 {
37992 PyThreadState* __tstate = wxPyBeginAllowThreads();
37993 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
37994 wxPyEndAllowThreads(__tstate);
37995 if (PyErr_Occurred()) SWIG_fail;
37996 }
37997 {
37998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37999 }
38000 return resultobj;
38001 fail:
38002 return NULL;
38003 }
38004
38005
38006 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38007 PyObject *resultobj = 0;
38008 wxWindow *arg1 = (wxWindow *) 0 ;
38009 wxPoint *arg2 = 0 ;
38010 bool result;
38011 void *argp1 = 0 ;
38012 int res1 = 0 ;
38013 wxPoint temp2 ;
38014 PyObject * obj0 = 0 ;
38015 PyObject * obj1 = 0 ;
38016 char * kwnames[] = {
38017 (char *) "self",(char *) "pt", NULL
38018 };
38019
38020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38022 if (!SWIG_IsOK(res1)) {
38023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38024 }
38025 arg1 = reinterpret_cast< wxWindow * >(argp1);
38026 {
38027 arg2 = &temp2;
38028 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38029 }
38030 {
38031 PyThreadState* __tstate = wxPyBeginAllowThreads();
38032 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38033 wxPyEndAllowThreads(__tstate);
38034 if (PyErr_Occurred()) SWIG_fail;
38035 }
38036 {
38037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38038 }
38039 return resultobj;
38040 fail:
38041 return NULL;
38042 }
38043
38044
38045 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38046 PyObject *resultobj = 0;
38047 wxWindow *arg1 = (wxWindow *) 0 ;
38048 wxRect *arg2 = 0 ;
38049 bool result;
38050 void *argp1 = 0 ;
38051 int res1 = 0 ;
38052 wxRect temp2 ;
38053 PyObject * obj0 = 0 ;
38054 PyObject * obj1 = 0 ;
38055 char * kwnames[] = {
38056 (char *) "self",(char *) "rect", NULL
38057 };
38058
38059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38061 if (!SWIG_IsOK(res1)) {
38062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38063 }
38064 arg1 = reinterpret_cast< wxWindow * >(argp1);
38065 {
38066 arg2 = &temp2;
38067 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38068 }
38069 {
38070 PyThreadState* __tstate = wxPyBeginAllowThreads();
38071 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38072 wxPyEndAllowThreads(__tstate);
38073 if (PyErr_Occurred()) SWIG_fail;
38074 }
38075 {
38076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38077 }
38078 return resultobj;
38079 fail:
38080 return NULL;
38081 }
38082
38083
38084 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38085 PyObject *resultobj = 0;
38086 wxWindow *arg1 = (wxWindow *) 0 ;
38087 SwigValueWrapper<wxVisualAttributes > result;
38088 void *argp1 = 0 ;
38089 int res1 = 0 ;
38090 PyObject *swig_obj[1] ;
38091
38092 if (!args) SWIG_fail;
38093 swig_obj[0] = args;
38094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38095 if (!SWIG_IsOK(res1)) {
38096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38097 }
38098 arg1 = reinterpret_cast< wxWindow * >(argp1);
38099 {
38100 PyThreadState* __tstate = wxPyBeginAllowThreads();
38101 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38102 wxPyEndAllowThreads(__tstate);
38103 if (PyErr_Occurred()) SWIG_fail;
38104 }
38105 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38106 return resultobj;
38107 fail:
38108 return NULL;
38109 }
38110
38111
38112 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38113 PyObject *resultobj = 0;
38114 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38115 SwigValueWrapper<wxVisualAttributes > result;
38116 int val1 ;
38117 int ecode1 = 0 ;
38118 PyObject * obj0 = 0 ;
38119 char * kwnames[] = {
38120 (char *) "variant", NULL
38121 };
38122
38123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38124 if (obj0) {
38125 ecode1 = SWIG_AsVal_int(obj0, &val1);
38126 if (!SWIG_IsOK(ecode1)) {
38127 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38128 }
38129 arg1 = static_cast< wxWindowVariant >(val1);
38130 }
38131 {
38132 if (!wxPyCheckForApp()) SWIG_fail;
38133 PyThreadState* __tstate = wxPyBeginAllowThreads();
38134 result = wxWindow::GetClassDefaultAttributes(arg1);
38135 wxPyEndAllowThreads(__tstate);
38136 if (PyErr_Occurred()) SWIG_fail;
38137 }
38138 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38139 return resultobj;
38140 fail:
38141 return NULL;
38142 }
38143
38144
38145 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38146 PyObject *resultobj = 0;
38147 wxWindow *arg1 = (wxWindow *) 0 ;
38148 wxColour *arg2 = 0 ;
38149 bool result;
38150 void *argp1 = 0 ;
38151 int res1 = 0 ;
38152 wxColour temp2 ;
38153 PyObject * obj0 = 0 ;
38154 PyObject * obj1 = 0 ;
38155 char * kwnames[] = {
38156 (char *) "self",(char *) "colour", NULL
38157 };
38158
38159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38161 if (!SWIG_IsOK(res1)) {
38162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38163 }
38164 arg1 = reinterpret_cast< wxWindow * >(argp1);
38165 {
38166 arg2 = &temp2;
38167 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38168 }
38169 {
38170 PyThreadState* __tstate = wxPyBeginAllowThreads();
38171 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38172 wxPyEndAllowThreads(__tstate);
38173 if (PyErr_Occurred()) SWIG_fail;
38174 }
38175 {
38176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38177 }
38178 return resultobj;
38179 fail:
38180 return NULL;
38181 }
38182
38183
38184 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38185 PyObject *resultobj = 0;
38186 wxWindow *arg1 = (wxWindow *) 0 ;
38187 wxColour *arg2 = 0 ;
38188 void *argp1 = 0 ;
38189 int res1 = 0 ;
38190 wxColour temp2 ;
38191 PyObject * obj0 = 0 ;
38192 PyObject * obj1 = 0 ;
38193 char * kwnames[] = {
38194 (char *) "self",(char *) "colour", NULL
38195 };
38196
38197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38199 if (!SWIG_IsOK(res1)) {
38200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38201 }
38202 arg1 = reinterpret_cast< wxWindow * >(argp1);
38203 {
38204 arg2 = &temp2;
38205 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38206 }
38207 {
38208 PyThreadState* __tstate = wxPyBeginAllowThreads();
38209 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38210 wxPyEndAllowThreads(__tstate);
38211 if (PyErr_Occurred()) SWIG_fail;
38212 }
38213 resultobj = SWIG_Py_Void();
38214 return resultobj;
38215 fail:
38216 return NULL;
38217 }
38218
38219
38220 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38221 PyObject *resultobj = 0;
38222 wxWindow *arg1 = (wxWindow *) 0 ;
38223 wxColour *arg2 = 0 ;
38224 bool result;
38225 void *argp1 = 0 ;
38226 int res1 = 0 ;
38227 wxColour temp2 ;
38228 PyObject * obj0 = 0 ;
38229 PyObject * obj1 = 0 ;
38230 char * kwnames[] = {
38231 (char *) "self",(char *) "colour", NULL
38232 };
38233
38234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38236 if (!SWIG_IsOK(res1)) {
38237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38238 }
38239 arg1 = reinterpret_cast< wxWindow * >(argp1);
38240 {
38241 arg2 = &temp2;
38242 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38243 }
38244 {
38245 PyThreadState* __tstate = wxPyBeginAllowThreads();
38246 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38247 wxPyEndAllowThreads(__tstate);
38248 if (PyErr_Occurred()) SWIG_fail;
38249 }
38250 {
38251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38252 }
38253 return resultobj;
38254 fail:
38255 return NULL;
38256 }
38257
38258
38259 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38260 PyObject *resultobj = 0;
38261 wxWindow *arg1 = (wxWindow *) 0 ;
38262 wxColour *arg2 = 0 ;
38263 void *argp1 = 0 ;
38264 int res1 = 0 ;
38265 wxColour temp2 ;
38266 PyObject * obj0 = 0 ;
38267 PyObject * obj1 = 0 ;
38268 char * kwnames[] = {
38269 (char *) "self",(char *) "colour", NULL
38270 };
38271
38272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38274 if (!SWIG_IsOK(res1)) {
38275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38276 }
38277 arg1 = reinterpret_cast< wxWindow * >(argp1);
38278 {
38279 arg2 = &temp2;
38280 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38281 }
38282 {
38283 PyThreadState* __tstate = wxPyBeginAllowThreads();
38284 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38285 wxPyEndAllowThreads(__tstate);
38286 if (PyErr_Occurred()) SWIG_fail;
38287 }
38288 resultobj = SWIG_Py_Void();
38289 return resultobj;
38290 fail:
38291 return NULL;
38292 }
38293
38294
38295 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38296 PyObject *resultobj = 0;
38297 wxWindow *arg1 = (wxWindow *) 0 ;
38298 wxColour result;
38299 void *argp1 = 0 ;
38300 int res1 = 0 ;
38301 PyObject *swig_obj[1] ;
38302
38303 if (!args) SWIG_fail;
38304 swig_obj[0] = args;
38305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38306 if (!SWIG_IsOK(res1)) {
38307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38308 }
38309 arg1 = reinterpret_cast< wxWindow * >(argp1);
38310 {
38311 PyThreadState* __tstate = wxPyBeginAllowThreads();
38312 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38313 wxPyEndAllowThreads(__tstate);
38314 if (PyErr_Occurred()) SWIG_fail;
38315 }
38316 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38317 return resultobj;
38318 fail:
38319 return NULL;
38320 }
38321
38322
38323 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38324 PyObject *resultobj = 0;
38325 wxWindow *arg1 = (wxWindow *) 0 ;
38326 wxColour result;
38327 void *argp1 = 0 ;
38328 int res1 = 0 ;
38329 PyObject *swig_obj[1] ;
38330
38331 if (!args) SWIG_fail;
38332 swig_obj[0] = args;
38333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38334 if (!SWIG_IsOK(res1)) {
38335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38336 }
38337 arg1 = reinterpret_cast< wxWindow * >(argp1);
38338 {
38339 PyThreadState* __tstate = wxPyBeginAllowThreads();
38340 result = ((wxWindow const *)arg1)->GetForegroundColour();
38341 wxPyEndAllowThreads(__tstate);
38342 if (PyErr_Occurred()) SWIG_fail;
38343 }
38344 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38345 return resultobj;
38346 fail:
38347 return NULL;
38348 }
38349
38350
38351 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38352 PyObject *resultobj = 0;
38353 wxWindow *arg1 = (wxWindow *) 0 ;
38354 bool result;
38355 void *argp1 = 0 ;
38356 int res1 = 0 ;
38357 PyObject *swig_obj[1] ;
38358
38359 if (!args) SWIG_fail;
38360 swig_obj[0] = args;
38361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38362 if (!SWIG_IsOK(res1)) {
38363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38364 }
38365 arg1 = reinterpret_cast< wxWindow * >(argp1);
38366 {
38367 PyThreadState* __tstate = wxPyBeginAllowThreads();
38368 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38369 wxPyEndAllowThreads(__tstate);
38370 if (PyErr_Occurred()) SWIG_fail;
38371 }
38372 {
38373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38374 }
38375 return resultobj;
38376 fail:
38377 return NULL;
38378 }
38379
38380
38381 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38382 PyObject *resultobj = 0;
38383 wxWindow *arg1 = (wxWindow *) 0 ;
38384 bool result;
38385 void *argp1 = 0 ;
38386 int res1 = 0 ;
38387 PyObject *swig_obj[1] ;
38388
38389 if (!args) SWIG_fail;
38390 swig_obj[0] = args;
38391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38392 if (!SWIG_IsOK(res1)) {
38393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38394 }
38395 arg1 = reinterpret_cast< wxWindow * >(argp1);
38396 {
38397 PyThreadState* __tstate = wxPyBeginAllowThreads();
38398 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38399 wxPyEndAllowThreads(__tstate);
38400 if (PyErr_Occurred()) SWIG_fail;
38401 }
38402 {
38403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38404 }
38405 return resultobj;
38406 fail:
38407 return NULL;
38408 }
38409
38410
38411 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38412 PyObject *resultobj = 0;
38413 wxWindow *arg1 = (wxWindow *) 0 ;
38414 wxBackgroundStyle arg2 ;
38415 bool result;
38416 void *argp1 = 0 ;
38417 int res1 = 0 ;
38418 int val2 ;
38419 int ecode2 = 0 ;
38420 PyObject * obj0 = 0 ;
38421 PyObject * obj1 = 0 ;
38422 char * kwnames[] = {
38423 (char *) "self",(char *) "style", NULL
38424 };
38425
38426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38428 if (!SWIG_IsOK(res1)) {
38429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38430 }
38431 arg1 = reinterpret_cast< wxWindow * >(argp1);
38432 ecode2 = SWIG_AsVal_int(obj1, &val2);
38433 if (!SWIG_IsOK(ecode2)) {
38434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38435 }
38436 arg2 = static_cast< wxBackgroundStyle >(val2);
38437 {
38438 PyThreadState* __tstate = wxPyBeginAllowThreads();
38439 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38440 wxPyEndAllowThreads(__tstate);
38441 if (PyErr_Occurred()) SWIG_fail;
38442 }
38443 {
38444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38445 }
38446 return resultobj;
38447 fail:
38448 return NULL;
38449 }
38450
38451
38452 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38453 PyObject *resultobj = 0;
38454 wxWindow *arg1 = (wxWindow *) 0 ;
38455 wxBackgroundStyle result;
38456 void *argp1 = 0 ;
38457 int res1 = 0 ;
38458 PyObject *swig_obj[1] ;
38459
38460 if (!args) SWIG_fail;
38461 swig_obj[0] = args;
38462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38463 if (!SWIG_IsOK(res1)) {
38464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38465 }
38466 arg1 = reinterpret_cast< wxWindow * >(argp1);
38467 {
38468 PyThreadState* __tstate = wxPyBeginAllowThreads();
38469 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38470 wxPyEndAllowThreads(__tstate);
38471 if (PyErr_Occurred()) SWIG_fail;
38472 }
38473 resultobj = SWIG_From_int(static_cast< int >(result));
38474 return resultobj;
38475 fail:
38476 return NULL;
38477 }
38478
38479
38480 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38481 PyObject *resultobj = 0;
38482 wxWindow *arg1 = (wxWindow *) 0 ;
38483 bool result;
38484 void *argp1 = 0 ;
38485 int res1 = 0 ;
38486 PyObject *swig_obj[1] ;
38487
38488 if (!args) SWIG_fail;
38489 swig_obj[0] = args;
38490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38491 if (!SWIG_IsOK(res1)) {
38492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38493 }
38494 arg1 = reinterpret_cast< wxWindow * >(argp1);
38495 {
38496 PyThreadState* __tstate = wxPyBeginAllowThreads();
38497 result = (bool)(arg1)->HasTransparentBackground();
38498 wxPyEndAllowThreads(__tstate);
38499 if (PyErr_Occurred()) SWIG_fail;
38500 }
38501 {
38502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38503 }
38504 return resultobj;
38505 fail:
38506 return NULL;
38507 }
38508
38509
38510 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38511 PyObject *resultobj = 0;
38512 wxWindow *arg1 = (wxWindow *) 0 ;
38513 wxCursor *arg2 = 0 ;
38514 bool result;
38515 void *argp1 = 0 ;
38516 int res1 = 0 ;
38517 void *argp2 = 0 ;
38518 int res2 = 0 ;
38519 PyObject * obj0 = 0 ;
38520 PyObject * obj1 = 0 ;
38521 char * kwnames[] = {
38522 (char *) "self",(char *) "cursor", NULL
38523 };
38524
38525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38527 if (!SWIG_IsOK(res1)) {
38528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38529 }
38530 arg1 = reinterpret_cast< wxWindow * >(argp1);
38531 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38532 if (!SWIG_IsOK(res2)) {
38533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38534 }
38535 if (!argp2) {
38536 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38537 }
38538 arg2 = reinterpret_cast< wxCursor * >(argp2);
38539 {
38540 PyThreadState* __tstate = wxPyBeginAllowThreads();
38541 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38542 wxPyEndAllowThreads(__tstate);
38543 if (PyErr_Occurred()) SWIG_fail;
38544 }
38545 {
38546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38547 }
38548 return resultobj;
38549 fail:
38550 return NULL;
38551 }
38552
38553
38554 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38555 PyObject *resultobj = 0;
38556 wxWindow *arg1 = (wxWindow *) 0 ;
38557 wxCursor result;
38558 void *argp1 = 0 ;
38559 int res1 = 0 ;
38560 PyObject *swig_obj[1] ;
38561
38562 if (!args) SWIG_fail;
38563 swig_obj[0] = args;
38564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38565 if (!SWIG_IsOK(res1)) {
38566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38567 }
38568 arg1 = reinterpret_cast< wxWindow * >(argp1);
38569 {
38570 PyThreadState* __tstate = wxPyBeginAllowThreads();
38571 result = (arg1)->GetCursor();
38572 wxPyEndAllowThreads(__tstate);
38573 if (PyErr_Occurred()) SWIG_fail;
38574 }
38575 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38576 return resultobj;
38577 fail:
38578 return NULL;
38579 }
38580
38581
38582 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38583 PyObject *resultobj = 0;
38584 wxWindow *arg1 = (wxWindow *) 0 ;
38585 wxFont *arg2 = 0 ;
38586 bool result;
38587 void *argp1 = 0 ;
38588 int res1 = 0 ;
38589 void *argp2 = 0 ;
38590 int res2 = 0 ;
38591 PyObject * obj0 = 0 ;
38592 PyObject * obj1 = 0 ;
38593 char * kwnames[] = {
38594 (char *) "self",(char *) "font", NULL
38595 };
38596
38597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38599 if (!SWIG_IsOK(res1)) {
38600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38601 }
38602 arg1 = reinterpret_cast< wxWindow * >(argp1);
38603 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38604 if (!SWIG_IsOK(res2)) {
38605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38606 }
38607 if (!argp2) {
38608 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38609 }
38610 arg2 = reinterpret_cast< wxFont * >(argp2);
38611 {
38612 PyThreadState* __tstate = wxPyBeginAllowThreads();
38613 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38614 wxPyEndAllowThreads(__tstate);
38615 if (PyErr_Occurred()) SWIG_fail;
38616 }
38617 {
38618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38619 }
38620 return resultobj;
38621 fail:
38622 return NULL;
38623 }
38624
38625
38626 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38627 PyObject *resultobj = 0;
38628 wxWindow *arg1 = (wxWindow *) 0 ;
38629 wxFont *arg2 = 0 ;
38630 void *argp1 = 0 ;
38631 int res1 = 0 ;
38632 void *argp2 = 0 ;
38633 int res2 = 0 ;
38634 PyObject * obj0 = 0 ;
38635 PyObject * obj1 = 0 ;
38636 char * kwnames[] = {
38637 (char *) "self",(char *) "font", NULL
38638 };
38639
38640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38642 if (!SWIG_IsOK(res1)) {
38643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38644 }
38645 arg1 = reinterpret_cast< wxWindow * >(argp1);
38646 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38647 if (!SWIG_IsOK(res2)) {
38648 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38649 }
38650 if (!argp2) {
38651 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38652 }
38653 arg2 = reinterpret_cast< wxFont * >(argp2);
38654 {
38655 PyThreadState* __tstate = wxPyBeginAllowThreads();
38656 (arg1)->SetOwnFont((wxFont const &)*arg2);
38657 wxPyEndAllowThreads(__tstate);
38658 if (PyErr_Occurred()) SWIG_fail;
38659 }
38660 resultobj = SWIG_Py_Void();
38661 return resultobj;
38662 fail:
38663 return NULL;
38664 }
38665
38666
38667 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38668 PyObject *resultobj = 0;
38669 wxWindow *arg1 = (wxWindow *) 0 ;
38670 wxFont result;
38671 void *argp1 = 0 ;
38672 int res1 = 0 ;
38673 PyObject *swig_obj[1] ;
38674
38675 if (!args) SWIG_fail;
38676 swig_obj[0] = args;
38677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38678 if (!SWIG_IsOK(res1)) {
38679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38680 }
38681 arg1 = reinterpret_cast< wxWindow * >(argp1);
38682 {
38683 PyThreadState* __tstate = wxPyBeginAllowThreads();
38684 result = (arg1)->GetFont();
38685 wxPyEndAllowThreads(__tstate);
38686 if (PyErr_Occurred()) SWIG_fail;
38687 }
38688 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
38689 return resultobj;
38690 fail:
38691 return NULL;
38692 }
38693
38694
38695 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38696 PyObject *resultobj = 0;
38697 wxWindow *arg1 = (wxWindow *) 0 ;
38698 wxCaret *arg2 = (wxCaret *) 0 ;
38699 void *argp1 = 0 ;
38700 int res1 = 0 ;
38701 int res2 = 0 ;
38702 PyObject * obj0 = 0 ;
38703 PyObject * obj1 = 0 ;
38704 char * kwnames[] = {
38705 (char *) "self",(char *) "caret", NULL
38706 };
38707
38708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
38709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38710 if (!SWIG_IsOK(res1)) {
38711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
38712 }
38713 arg1 = reinterpret_cast< wxWindow * >(argp1);
38714 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
38715 if (!SWIG_IsOK(res2)) {
38716 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
38717 }
38718 {
38719 PyThreadState* __tstate = wxPyBeginAllowThreads();
38720 (arg1)->SetCaret(arg2);
38721 wxPyEndAllowThreads(__tstate);
38722 if (PyErr_Occurred()) SWIG_fail;
38723 }
38724 resultobj = SWIG_Py_Void();
38725 return resultobj;
38726 fail:
38727 return NULL;
38728 }
38729
38730
38731 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38732 PyObject *resultobj = 0;
38733 wxWindow *arg1 = (wxWindow *) 0 ;
38734 wxCaret *result = 0 ;
38735 void *argp1 = 0 ;
38736 int res1 = 0 ;
38737 PyObject *swig_obj[1] ;
38738
38739 if (!args) SWIG_fail;
38740 swig_obj[0] = args;
38741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38742 if (!SWIG_IsOK(res1)) {
38743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
38744 }
38745 arg1 = reinterpret_cast< wxWindow * >(argp1);
38746 {
38747 PyThreadState* __tstate = wxPyBeginAllowThreads();
38748 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
38749 wxPyEndAllowThreads(__tstate);
38750 if (PyErr_Occurred()) SWIG_fail;
38751 }
38752 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
38753 return resultobj;
38754 fail:
38755 return NULL;
38756 }
38757
38758
38759 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38760 PyObject *resultobj = 0;
38761 wxWindow *arg1 = (wxWindow *) 0 ;
38762 int result;
38763 void *argp1 = 0 ;
38764 int res1 = 0 ;
38765 PyObject *swig_obj[1] ;
38766
38767 if (!args) SWIG_fail;
38768 swig_obj[0] = args;
38769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38770 if (!SWIG_IsOK(res1)) {
38771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
38772 }
38773 arg1 = reinterpret_cast< wxWindow * >(argp1);
38774 {
38775 PyThreadState* __tstate = wxPyBeginAllowThreads();
38776 result = (int)((wxWindow const *)arg1)->GetCharHeight();
38777 wxPyEndAllowThreads(__tstate);
38778 if (PyErr_Occurred()) SWIG_fail;
38779 }
38780 resultobj = SWIG_From_int(static_cast< int >(result));
38781 return resultobj;
38782 fail:
38783 return NULL;
38784 }
38785
38786
38787 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38788 PyObject *resultobj = 0;
38789 wxWindow *arg1 = (wxWindow *) 0 ;
38790 int result;
38791 void *argp1 = 0 ;
38792 int res1 = 0 ;
38793 PyObject *swig_obj[1] ;
38794
38795 if (!args) SWIG_fail;
38796 swig_obj[0] = args;
38797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38798 if (!SWIG_IsOK(res1)) {
38799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
38800 }
38801 arg1 = reinterpret_cast< wxWindow * >(argp1);
38802 {
38803 PyThreadState* __tstate = wxPyBeginAllowThreads();
38804 result = (int)((wxWindow const *)arg1)->GetCharWidth();
38805 wxPyEndAllowThreads(__tstate);
38806 if (PyErr_Occurred()) SWIG_fail;
38807 }
38808 resultobj = SWIG_From_int(static_cast< int >(result));
38809 return resultobj;
38810 fail:
38811 return NULL;
38812 }
38813
38814
38815 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38816 PyObject *resultobj = 0;
38817 wxWindow *arg1 = (wxWindow *) 0 ;
38818 wxString *arg2 = 0 ;
38819 int *arg3 = (int *) 0 ;
38820 int *arg4 = (int *) 0 ;
38821 void *argp1 = 0 ;
38822 int res1 = 0 ;
38823 bool temp2 = false ;
38824 int temp3 ;
38825 int res3 = SWIG_TMPOBJ ;
38826 int temp4 ;
38827 int res4 = SWIG_TMPOBJ ;
38828 PyObject * obj0 = 0 ;
38829 PyObject * obj1 = 0 ;
38830 char * kwnames[] = {
38831 (char *) "self",(char *) "string", NULL
38832 };
38833
38834 arg3 = &temp3;
38835 arg4 = &temp4;
38836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
38837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38838 if (!SWIG_IsOK(res1)) {
38839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38840 }
38841 arg1 = reinterpret_cast< wxWindow * >(argp1);
38842 {
38843 arg2 = wxString_in_helper(obj1);
38844 if (arg2 == NULL) SWIG_fail;
38845 temp2 = true;
38846 }
38847 {
38848 PyThreadState* __tstate = wxPyBeginAllowThreads();
38849 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
38850 wxPyEndAllowThreads(__tstate);
38851 if (PyErr_Occurred()) SWIG_fail;
38852 }
38853 resultobj = SWIG_Py_Void();
38854 if (SWIG_IsTmpObj(res3)) {
38855 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38856 } else {
38857 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38858 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38859 }
38860 if (SWIG_IsTmpObj(res4)) {
38861 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38862 } else {
38863 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38864 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38865 }
38866 {
38867 if (temp2)
38868 delete arg2;
38869 }
38870 return resultobj;
38871 fail:
38872 {
38873 if (temp2)
38874 delete arg2;
38875 }
38876 return NULL;
38877 }
38878
38879
38880 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38881 PyObject *resultobj = 0;
38882 wxWindow *arg1 = (wxWindow *) 0 ;
38883 wxString *arg2 = 0 ;
38884 int *arg3 = (int *) 0 ;
38885 int *arg4 = (int *) 0 ;
38886 int *arg5 = (int *) 0 ;
38887 int *arg6 = (int *) 0 ;
38888 wxFont *arg7 = (wxFont *) NULL ;
38889 void *argp1 = 0 ;
38890 int res1 = 0 ;
38891 bool temp2 = false ;
38892 int temp3 ;
38893 int res3 = SWIG_TMPOBJ ;
38894 int temp4 ;
38895 int res4 = SWIG_TMPOBJ ;
38896 int temp5 ;
38897 int res5 = SWIG_TMPOBJ ;
38898 int temp6 ;
38899 int res6 = SWIG_TMPOBJ ;
38900 void *argp7 = 0 ;
38901 int res7 = 0 ;
38902 PyObject * obj0 = 0 ;
38903 PyObject * obj1 = 0 ;
38904 PyObject * obj2 = 0 ;
38905 char * kwnames[] = {
38906 (char *) "self",(char *) "string",(char *) "font", NULL
38907 };
38908
38909 arg3 = &temp3;
38910 arg4 = &temp4;
38911 arg5 = &temp5;
38912 arg6 = &temp6;
38913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38915 if (!SWIG_IsOK(res1)) {
38916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38917 }
38918 arg1 = reinterpret_cast< wxWindow * >(argp1);
38919 {
38920 arg2 = wxString_in_helper(obj1);
38921 if (arg2 == NULL) SWIG_fail;
38922 temp2 = true;
38923 }
38924 if (obj2) {
38925 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
38926 if (!SWIG_IsOK(res7)) {
38927 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
38928 }
38929 arg7 = reinterpret_cast< wxFont * >(argp7);
38930 }
38931 {
38932 PyThreadState* __tstate = wxPyBeginAllowThreads();
38933 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
38934 wxPyEndAllowThreads(__tstate);
38935 if (PyErr_Occurred()) SWIG_fail;
38936 }
38937 resultobj = SWIG_Py_Void();
38938 if (SWIG_IsTmpObj(res3)) {
38939 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38940 } else {
38941 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38942 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38943 }
38944 if (SWIG_IsTmpObj(res4)) {
38945 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38946 } else {
38947 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38948 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38949 }
38950 if (SWIG_IsTmpObj(res5)) {
38951 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
38952 } else {
38953 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38954 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
38955 }
38956 if (SWIG_IsTmpObj(res6)) {
38957 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
38958 } else {
38959 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38960 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
38961 }
38962 {
38963 if (temp2)
38964 delete arg2;
38965 }
38966 return resultobj;
38967 fail:
38968 {
38969 if (temp2)
38970 delete arg2;
38971 }
38972 return NULL;
38973 }
38974
38975
38976 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38977 PyObject *resultobj = 0;
38978 wxWindow *arg1 = (wxWindow *) 0 ;
38979 int *arg2 = (int *) 0 ;
38980 int *arg3 = (int *) 0 ;
38981 void *argp1 = 0 ;
38982 int res1 = 0 ;
38983 int temp2 ;
38984 int res2 = 0 ;
38985 int temp3 ;
38986 int res3 = 0 ;
38987 PyObject * obj0 = 0 ;
38988 PyObject * obj1 = 0 ;
38989 PyObject * obj2 = 0 ;
38990 char * kwnames[] = {
38991 (char *) "self",(char *) "x",(char *) "y", NULL
38992 };
38993
38994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38996 if (!SWIG_IsOK(res1)) {
38997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
38998 }
38999 arg1 = reinterpret_cast< wxWindow * >(argp1);
39000 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39001 int val;
39002 int ecode = SWIG_AsVal_int(obj1, &val);
39003 if (!SWIG_IsOK(ecode)) {
39004 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39005 }
39006 temp2 = static_cast< int >(val);
39007 arg2 = &temp2;
39008 res2 = SWIG_AddTmpMask(ecode);
39009 }
39010 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39011 int val;
39012 int ecode = SWIG_AsVal_int(obj2, &val);
39013 if (!SWIG_IsOK(ecode)) {
39014 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39015 }
39016 temp3 = static_cast< int >(val);
39017 arg3 = &temp3;
39018 res3 = SWIG_AddTmpMask(ecode);
39019 }
39020 {
39021 PyThreadState* __tstate = wxPyBeginAllowThreads();
39022 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39023 wxPyEndAllowThreads(__tstate);
39024 if (PyErr_Occurred()) SWIG_fail;
39025 }
39026 resultobj = SWIG_Py_Void();
39027 if (SWIG_IsTmpObj(res2)) {
39028 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39029 } else {
39030 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39031 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39032 }
39033 if (SWIG_IsTmpObj(res3)) {
39034 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39035 } else {
39036 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39037 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39038 }
39039 return resultobj;
39040 fail:
39041 return NULL;
39042 }
39043
39044
39045 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39046 PyObject *resultobj = 0;
39047 wxWindow *arg1 = (wxWindow *) 0 ;
39048 int *arg2 = (int *) 0 ;
39049 int *arg3 = (int *) 0 ;
39050 void *argp1 = 0 ;
39051 int res1 = 0 ;
39052 int temp2 ;
39053 int res2 = 0 ;
39054 int temp3 ;
39055 int res3 = 0 ;
39056 PyObject * obj0 = 0 ;
39057 PyObject * obj1 = 0 ;
39058 PyObject * obj2 = 0 ;
39059 char * kwnames[] = {
39060 (char *) "self",(char *) "x",(char *) "y", NULL
39061 };
39062
39063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39065 if (!SWIG_IsOK(res1)) {
39066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39067 }
39068 arg1 = reinterpret_cast< wxWindow * >(argp1);
39069 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39070 int val;
39071 int ecode = SWIG_AsVal_int(obj1, &val);
39072 if (!SWIG_IsOK(ecode)) {
39073 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39074 }
39075 temp2 = static_cast< int >(val);
39076 arg2 = &temp2;
39077 res2 = SWIG_AddTmpMask(ecode);
39078 }
39079 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39080 int val;
39081 int ecode = SWIG_AsVal_int(obj2, &val);
39082 if (!SWIG_IsOK(ecode)) {
39083 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39084 }
39085 temp3 = static_cast< int >(val);
39086 arg3 = &temp3;
39087 res3 = SWIG_AddTmpMask(ecode);
39088 }
39089 {
39090 PyThreadState* __tstate = wxPyBeginAllowThreads();
39091 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39092 wxPyEndAllowThreads(__tstate);
39093 if (PyErr_Occurred()) SWIG_fail;
39094 }
39095 resultobj = SWIG_Py_Void();
39096 if (SWIG_IsTmpObj(res2)) {
39097 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39098 } else {
39099 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39100 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39101 }
39102 if (SWIG_IsTmpObj(res3)) {
39103 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39104 } else {
39105 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39106 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39107 }
39108 return resultobj;
39109 fail:
39110 return NULL;
39111 }
39112
39113
39114 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39115 PyObject *resultobj = 0;
39116 wxWindow *arg1 = (wxWindow *) 0 ;
39117 wxPoint *arg2 = 0 ;
39118 wxPoint result;
39119 void *argp1 = 0 ;
39120 int res1 = 0 ;
39121 wxPoint temp2 ;
39122 PyObject * obj0 = 0 ;
39123 PyObject * obj1 = 0 ;
39124 char * kwnames[] = {
39125 (char *) "self",(char *) "pt", NULL
39126 };
39127
39128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39130 if (!SWIG_IsOK(res1)) {
39131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39132 }
39133 arg1 = reinterpret_cast< wxWindow * >(argp1);
39134 {
39135 arg2 = &temp2;
39136 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39137 }
39138 {
39139 PyThreadState* __tstate = wxPyBeginAllowThreads();
39140 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39141 wxPyEndAllowThreads(__tstate);
39142 if (PyErr_Occurred()) SWIG_fail;
39143 }
39144 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39145 return resultobj;
39146 fail:
39147 return NULL;
39148 }
39149
39150
39151 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39152 PyObject *resultobj = 0;
39153 wxWindow *arg1 = (wxWindow *) 0 ;
39154 wxPoint *arg2 = 0 ;
39155 wxPoint result;
39156 void *argp1 = 0 ;
39157 int res1 = 0 ;
39158 wxPoint temp2 ;
39159 PyObject * obj0 = 0 ;
39160 PyObject * obj1 = 0 ;
39161 char * kwnames[] = {
39162 (char *) "self",(char *) "pt", NULL
39163 };
39164
39165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39167 if (!SWIG_IsOK(res1)) {
39168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39169 }
39170 arg1 = reinterpret_cast< wxWindow * >(argp1);
39171 {
39172 arg2 = &temp2;
39173 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39174 }
39175 {
39176 PyThreadState* __tstate = wxPyBeginAllowThreads();
39177 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39178 wxPyEndAllowThreads(__tstate);
39179 if (PyErr_Occurred()) SWIG_fail;
39180 }
39181 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39182 return resultobj;
39183 fail:
39184 return NULL;
39185 }
39186
39187
39188 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39189 PyObject *resultobj = 0;
39190 wxWindow *arg1 = (wxWindow *) 0 ;
39191 int arg2 ;
39192 int arg3 ;
39193 wxHitTest result;
39194 void *argp1 = 0 ;
39195 int res1 = 0 ;
39196 int val2 ;
39197 int ecode2 = 0 ;
39198 int val3 ;
39199 int ecode3 = 0 ;
39200 PyObject * obj0 = 0 ;
39201 PyObject * obj1 = 0 ;
39202 PyObject * obj2 = 0 ;
39203 char * kwnames[] = {
39204 (char *) "self",(char *) "x",(char *) "y", NULL
39205 };
39206
39207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39209 if (!SWIG_IsOK(res1)) {
39210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39211 }
39212 arg1 = reinterpret_cast< wxWindow * >(argp1);
39213 ecode2 = SWIG_AsVal_int(obj1, &val2);
39214 if (!SWIG_IsOK(ecode2)) {
39215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39216 }
39217 arg2 = static_cast< int >(val2);
39218 ecode3 = SWIG_AsVal_int(obj2, &val3);
39219 if (!SWIG_IsOK(ecode3)) {
39220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39221 }
39222 arg3 = static_cast< int >(val3);
39223 {
39224 PyThreadState* __tstate = wxPyBeginAllowThreads();
39225 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39226 wxPyEndAllowThreads(__tstate);
39227 if (PyErr_Occurred()) SWIG_fail;
39228 }
39229 resultobj = SWIG_From_int(static_cast< int >(result));
39230 return resultobj;
39231 fail:
39232 return NULL;
39233 }
39234
39235
39236 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39237 PyObject *resultobj = 0;
39238 wxWindow *arg1 = (wxWindow *) 0 ;
39239 wxPoint *arg2 = 0 ;
39240 wxHitTest result;
39241 void *argp1 = 0 ;
39242 int res1 = 0 ;
39243 wxPoint temp2 ;
39244 PyObject * obj0 = 0 ;
39245 PyObject * obj1 = 0 ;
39246 char * kwnames[] = {
39247 (char *) "self",(char *) "pt", NULL
39248 };
39249
39250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39252 if (!SWIG_IsOK(res1)) {
39253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39254 }
39255 arg1 = reinterpret_cast< wxWindow * >(argp1);
39256 {
39257 arg2 = &temp2;
39258 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39259 }
39260 {
39261 PyThreadState* __tstate = wxPyBeginAllowThreads();
39262 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39263 wxPyEndAllowThreads(__tstate);
39264 if (PyErr_Occurred()) SWIG_fail;
39265 }
39266 resultobj = SWIG_From_int(static_cast< int >(result));
39267 return resultobj;
39268 fail:
39269 return NULL;
39270 }
39271
39272
39273 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39274 PyObject *resultobj = 0;
39275 wxWindow *arg1 = (wxWindow *) 0 ;
39276 long arg2 ;
39277 wxBorder result;
39278 void *argp1 = 0 ;
39279 int res1 = 0 ;
39280 long val2 ;
39281 int ecode2 = 0 ;
39282
39283 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39285 if (!SWIG_IsOK(res1)) {
39286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39287 }
39288 arg1 = reinterpret_cast< wxWindow * >(argp1);
39289 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39290 if (!SWIG_IsOK(ecode2)) {
39291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39292 }
39293 arg2 = static_cast< long >(val2);
39294 {
39295 PyThreadState* __tstate = wxPyBeginAllowThreads();
39296 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39297 wxPyEndAllowThreads(__tstate);
39298 if (PyErr_Occurred()) SWIG_fail;
39299 }
39300 resultobj = SWIG_From_int(static_cast< int >(result));
39301 return resultobj;
39302 fail:
39303 return NULL;
39304 }
39305
39306
39307 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39308 PyObject *resultobj = 0;
39309 wxWindow *arg1 = (wxWindow *) 0 ;
39310 wxBorder result;
39311 void *argp1 = 0 ;
39312 int res1 = 0 ;
39313
39314 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39316 if (!SWIG_IsOK(res1)) {
39317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39318 }
39319 arg1 = reinterpret_cast< wxWindow * >(argp1);
39320 {
39321 PyThreadState* __tstate = wxPyBeginAllowThreads();
39322 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39323 wxPyEndAllowThreads(__tstate);
39324 if (PyErr_Occurred()) SWIG_fail;
39325 }
39326 resultobj = SWIG_From_int(static_cast< int >(result));
39327 return resultobj;
39328 fail:
39329 return NULL;
39330 }
39331
39332
39333 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39334 int argc;
39335 PyObject *argv[3];
39336
39337 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39338 --argc;
39339 if (argc == 1) {
39340 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39341 }
39342 if (argc == 2) {
39343 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39344 }
39345
39346 fail:
39347 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39348 return NULL;
39349 }
39350
39351
39352 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39353 PyObject *resultobj = 0;
39354 wxWindow *arg1 = (wxWindow *) 0 ;
39355 long arg2 = (long) wxUPDATE_UI_NONE ;
39356 void *argp1 = 0 ;
39357 int res1 = 0 ;
39358 long val2 ;
39359 int ecode2 = 0 ;
39360 PyObject * obj0 = 0 ;
39361 PyObject * obj1 = 0 ;
39362 char * kwnames[] = {
39363 (char *) "self",(char *) "flags", NULL
39364 };
39365
39366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39368 if (!SWIG_IsOK(res1)) {
39369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39370 }
39371 arg1 = reinterpret_cast< wxWindow * >(argp1);
39372 if (obj1) {
39373 ecode2 = SWIG_AsVal_long(obj1, &val2);
39374 if (!SWIG_IsOK(ecode2)) {
39375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39376 }
39377 arg2 = static_cast< long >(val2);
39378 }
39379 {
39380 PyThreadState* __tstate = wxPyBeginAllowThreads();
39381 (arg1)->UpdateWindowUI(arg2);
39382 wxPyEndAllowThreads(__tstate);
39383 if (PyErr_Occurred()) SWIG_fail;
39384 }
39385 resultobj = SWIG_Py_Void();
39386 return resultobj;
39387 fail:
39388 return NULL;
39389 }
39390
39391
39392 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39393 PyObject *resultobj = 0;
39394 wxWindow *arg1 = (wxWindow *) 0 ;
39395 wxMenu *arg2 = (wxMenu *) 0 ;
39396 int arg3 = (int) -1 ;
39397 int arg4 = (int) -1 ;
39398 bool result;
39399 void *argp1 = 0 ;
39400 int res1 = 0 ;
39401 void *argp2 = 0 ;
39402 int res2 = 0 ;
39403 int val3 ;
39404 int ecode3 = 0 ;
39405 int val4 ;
39406 int ecode4 = 0 ;
39407 PyObject * obj0 = 0 ;
39408 PyObject * obj1 = 0 ;
39409 PyObject * obj2 = 0 ;
39410 PyObject * obj3 = 0 ;
39411 char * kwnames[] = {
39412 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39413 };
39414
39415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39417 if (!SWIG_IsOK(res1)) {
39418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39419 }
39420 arg1 = reinterpret_cast< wxWindow * >(argp1);
39421 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39422 if (!SWIG_IsOK(res2)) {
39423 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39424 }
39425 arg2 = reinterpret_cast< wxMenu * >(argp2);
39426 if (obj2) {
39427 ecode3 = SWIG_AsVal_int(obj2, &val3);
39428 if (!SWIG_IsOK(ecode3)) {
39429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39430 }
39431 arg3 = static_cast< int >(val3);
39432 }
39433 if (obj3) {
39434 ecode4 = SWIG_AsVal_int(obj3, &val4);
39435 if (!SWIG_IsOK(ecode4)) {
39436 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39437 }
39438 arg4 = static_cast< int >(val4);
39439 }
39440 {
39441 PyThreadState* __tstate = wxPyBeginAllowThreads();
39442 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39443 wxPyEndAllowThreads(__tstate);
39444 if (PyErr_Occurred()) SWIG_fail;
39445 }
39446 {
39447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39448 }
39449 return resultobj;
39450 fail:
39451 return NULL;
39452 }
39453
39454
39455 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39456 PyObject *resultobj = 0;
39457 wxWindow *arg1 = (wxWindow *) 0 ;
39458 wxMenu *arg2 = (wxMenu *) 0 ;
39459 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39460 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39461 bool result;
39462 void *argp1 = 0 ;
39463 int res1 = 0 ;
39464 void *argp2 = 0 ;
39465 int res2 = 0 ;
39466 wxPoint temp3 ;
39467 PyObject * obj0 = 0 ;
39468 PyObject * obj1 = 0 ;
39469 PyObject * obj2 = 0 ;
39470 char * kwnames[] = {
39471 (char *) "self",(char *) "menu",(char *) "pos", NULL
39472 };
39473
39474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39476 if (!SWIG_IsOK(res1)) {
39477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39478 }
39479 arg1 = reinterpret_cast< wxWindow * >(argp1);
39480 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39481 if (!SWIG_IsOK(res2)) {
39482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39483 }
39484 arg2 = reinterpret_cast< wxMenu * >(argp2);
39485 if (obj2) {
39486 {
39487 arg3 = &temp3;
39488 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39489 }
39490 }
39491 {
39492 PyThreadState* __tstate = wxPyBeginAllowThreads();
39493 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39494 wxPyEndAllowThreads(__tstate);
39495 if (PyErr_Occurred()) SWIG_fail;
39496 }
39497 {
39498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39499 }
39500 return resultobj;
39501 fail:
39502 return NULL;
39503 }
39504
39505
39506 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39507 PyObject *resultobj = 0;
39508 wxWindow *arg1 = (wxWindow *) 0 ;
39509 bool result;
39510 void *argp1 = 0 ;
39511 int res1 = 0 ;
39512 PyObject *swig_obj[1] ;
39513
39514 if (!args) SWIG_fail;
39515 swig_obj[0] = args;
39516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39517 if (!SWIG_IsOK(res1)) {
39518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39519 }
39520 arg1 = reinterpret_cast< wxWindow * >(argp1);
39521 {
39522 PyThreadState* __tstate = wxPyBeginAllowThreads();
39523 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39524 wxPyEndAllowThreads(__tstate);
39525 if (PyErr_Occurred()) SWIG_fail;
39526 }
39527 {
39528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39529 }
39530 return resultobj;
39531 fail:
39532 return NULL;
39533 }
39534
39535
39536 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39537 PyObject *resultobj = 0;
39538 wxWindow *arg1 = (wxWindow *) 0 ;
39539 long result;
39540 void *argp1 = 0 ;
39541 int res1 = 0 ;
39542 PyObject *swig_obj[1] ;
39543
39544 if (!args) SWIG_fail;
39545 swig_obj[0] = args;
39546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39547 if (!SWIG_IsOK(res1)) {
39548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39549 }
39550 arg1 = reinterpret_cast< wxWindow * >(argp1);
39551 {
39552 PyThreadState* __tstate = wxPyBeginAllowThreads();
39553 result = (long)wxWindow_GetHandle(arg1);
39554 wxPyEndAllowThreads(__tstate);
39555 if (PyErr_Occurred()) SWIG_fail;
39556 }
39557 resultobj = SWIG_From_long(static_cast< long >(result));
39558 return resultobj;
39559 fail:
39560 return NULL;
39561 }
39562
39563
39564 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39565 PyObject *resultobj = 0;
39566 wxWindow *arg1 = (wxWindow *) 0 ;
39567 long arg2 ;
39568 void *argp1 = 0 ;
39569 int res1 = 0 ;
39570 long val2 ;
39571 int ecode2 = 0 ;
39572 PyObject * obj0 = 0 ;
39573 PyObject * obj1 = 0 ;
39574 char * kwnames[] = {
39575 (char *) "self",(char *) "handle", NULL
39576 };
39577
39578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39580 if (!SWIG_IsOK(res1)) {
39581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39582 }
39583 arg1 = reinterpret_cast< wxWindow * >(argp1);
39584 ecode2 = SWIG_AsVal_long(obj1, &val2);
39585 if (!SWIG_IsOK(ecode2)) {
39586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39587 }
39588 arg2 = static_cast< long >(val2);
39589 {
39590 PyThreadState* __tstate = wxPyBeginAllowThreads();
39591 wxWindow_AssociateHandle(arg1,arg2);
39592 wxPyEndAllowThreads(__tstate);
39593 if (PyErr_Occurred()) SWIG_fail;
39594 }
39595 resultobj = SWIG_Py_Void();
39596 return resultobj;
39597 fail:
39598 return NULL;
39599 }
39600
39601
39602 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39603 PyObject *resultobj = 0;
39604 wxWindow *arg1 = (wxWindow *) 0 ;
39605 void *argp1 = 0 ;
39606 int res1 = 0 ;
39607 PyObject *swig_obj[1] ;
39608
39609 if (!args) SWIG_fail;
39610 swig_obj[0] = args;
39611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39612 if (!SWIG_IsOK(res1)) {
39613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39614 }
39615 arg1 = reinterpret_cast< wxWindow * >(argp1);
39616 {
39617 PyThreadState* __tstate = wxPyBeginAllowThreads();
39618 (arg1)->DissociateHandle();
39619 wxPyEndAllowThreads(__tstate);
39620 if (PyErr_Occurred()) SWIG_fail;
39621 }
39622 resultobj = SWIG_Py_Void();
39623 return resultobj;
39624 fail:
39625 return NULL;
39626 }
39627
39628
39629 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39630 PyObject *resultobj = 0;
39631 wxWindow *arg1 = (wxWindow *) 0 ;
39632 int arg2 ;
39633 bool result;
39634 void *argp1 = 0 ;
39635 int res1 = 0 ;
39636 int val2 ;
39637 int ecode2 = 0 ;
39638 PyObject * obj0 = 0 ;
39639 PyObject * obj1 = 0 ;
39640 char * kwnames[] = {
39641 (char *) "self",(char *) "orient", NULL
39642 };
39643
39644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
39645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39646 if (!SWIG_IsOK(res1)) {
39647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
39648 }
39649 arg1 = reinterpret_cast< wxWindow * >(argp1);
39650 ecode2 = SWIG_AsVal_int(obj1, &val2);
39651 if (!SWIG_IsOK(ecode2)) {
39652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39653 }
39654 arg2 = static_cast< int >(val2);
39655 {
39656 PyThreadState* __tstate = wxPyBeginAllowThreads();
39657 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39658 wxPyEndAllowThreads(__tstate);
39659 if (PyErr_Occurred()) SWIG_fail;
39660 }
39661 {
39662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39663 }
39664 return resultobj;
39665 fail:
39666 return NULL;
39667 }
39668
39669
39670 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39671 PyObject *resultobj = 0;
39672 wxWindow *arg1 = (wxWindow *) 0 ;
39673 int arg2 ;
39674 int arg3 ;
39675 int arg4 ;
39676 int arg5 ;
39677 bool arg6 = (bool) true ;
39678 void *argp1 = 0 ;
39679 int res1 = 0 ;
39680 int val2 ;
39681 int ecode2 = 0 ;
39682 int val3 ;
39683 int ecode3 = 0 ;
39684 int val4 ;
39685 int ecode4 = 0 ;
39686 int val5 ;
39687 int ecode5 = 0 ;
39688 bool val6 ;
39689 int ecode6 = 0 ;
39690 PyObject * obj0 = 0 ;
39691 PyObject * obj1 = 0 ;
39692 PyObject * obj2 = 0 ;
39693 PyObject * obj3 = 0 ;
39694 PyObject * obj4 = 0 ;
39695 PyObject * obj5 = 0 ;
39696 char * kwnames[] = {
39697 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
39698 };
39699
39700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39702 if (!SWIG_IsOK(res1)) {
39703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
39704 }
39705 arg1 = reinterpret_cast< wxWindow * >(argp1);
39706 ecode2 = SWIG_AsVal_int(obj1, &val2);
39707 if (!SWIG_IsOK(ecode2)) {
39708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
39709 }
39710 arg2 = static_cast< int >(val2);
39711 ecode3 = SWIG_AsVal_int(obj2, &val3);
39712 if (!SWIG_IsOK(ecode3)) {
39713 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
39714 }
39715 arg3 = static_cast< int >(val3);
39716 ecode4 = SWIG_AsVal_int(obj3, &val4);
39717 if (!SWIG_IsOK(ecode4)) {
39718 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
39719 }
39720 arg4 = static_cast< int >(val4);
39721 ecode5 = SWIG_AsVal_int(obj4, &val5);
39722 if (!SWIG_IsOK(ecode5)) {
39723 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
39724 }
39725 arg5 = static_cast< int >(val5);
39726 if (obj5) {
39727 ecode6 = SWIG_AsVal_bool(obj5, &val6);
39728 if (!SWIG_IsOK(ecode6)) {
39729 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
39730 }
39731 arg6 = static_cast< bool >(val6);
39732 }
39733 {
39734 PyThreadState* __tstate = wxPyBeginAllowThreads();
39735 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
39736 wxPyEndAllowThreads(__tstate);
39737 if (PyErr_Occurred()) SWIG_fail;
39738 }
39739 resultobj = SWIG_Py_Void();
39740 return resultobj;
39741 fail:
39742 return NULL;
39743 }
39744
39745
39746 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39747 PyObject *resultobj = 0;
39748 wxWindow *arg1 = (wxWindow *) 0 ;
39749 int arg2 ;
39750 int arg3 ;
39751 bool arg4 = (bool) true ;
39752 void *argp1 = 0 ;
39753 int res1 = 0 ;
39754 int val2 ;
39755 int ecode2 = 0 ;
39756 int val3 ;
39757 int ecode3 = 0 ;
39758 bool val4 ;
39759 int ecode4 = 0 ;
39760 PyObject * obj0 = 0 ;
39761 PyObject * obj1 = 0 ;
39762 PyObject * obj2 = 0 ;
39763 PyObject * obj3 = 0 ;
39764 char * kwnames[] = {
39765 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
39766 };
39767
39768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39770 if (!SWIG_IsOK(res1)) {
39771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
39772 }
39773 arg1 = reinterpret_cast< wxWindow * >(argp1);
39774 ecode2 = SWIG_AsVal_int(obj1, &val2);
39775 if (!SWIG_IsOK(ecode2)) {
39776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
39777 }
39778 arg2 = static_cast< int >(val2);
39779 ecode3 = SWIG_AsVal_int(obj2, &val3);
39780 if (!SWIG_IsOK(ecode3)) {
39781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
39782 }
39783 arg3 = static_cast< int >(val3);
39784 if (obj3) {
39785 ecode4 = SWIG_AsVal_bool(obj3, &val4);
39786 if (!SWIG_IsOK(ecode4)) {
39787 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
39788 }
39789 arg4 = static_cast< bool >(val4);
39790 }
39791 {
39792 PyThreadState* __tstate = wxPyBeginAllowThreads();
39793 (arg1)->SetScrollPos(arg2,arg3,arg4);
39794 wxPyEndAllowThreads(__tstate);
39795 if (PyErr_Occurred()) SWIG_fail;
39796 }
39797 resultobj = SWIG_Py_Void();
39798 return resultobj;
39799 fail:
39800 return NULL;
39801 }
39802
39803
39804 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39805 PyObject *resultobj = 0;
39806 wxWindow *arg1 = (wxWindow *) 0 ;
39807 int arg2 ;
39808 int result;
39809 void *argp1 = 0 ;
39810 int res1 = 0 ;
39811 int val2 ;
39812 int ecode2 = 0 ;
39813 PyObject * obj0 = 0 ;
39814 PyObject * obj1 = 0 ;
39815 char * kwnames[] = {
39816 (char *) "self",(char *) "orientation", NULL
39817 };
39818
39819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
39820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39821 if (!SWIG_IsOK(res1)) {
39822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
39823 }
39824 arg1 = reinterpret_cast< wxWindow * >(argp1);
39825 ecode2 = SWIG_AsVal_int(obj1, &val2);
39826 if (!SWIG_IsOK(ecode2)) {
39827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
39828 }
39829 arg2 = static_cast< int >(val2);
39830 {
39831 PyThreadState* __tstate = wxPyBeginAllowThreads();
39832 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
39833 wxPyEndAllowThreads(__tstate);
39834 if (PyErr_Occurred()) SWIG_fail;
39835 }
39836 resultobj = SWIG_From_int(static_cast< int >(result));
39837 return resultobj;
39838 fail:
39839 return NULL;
39840 }
39841
39842
39843 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39844 PyObject *resultobj = 0;
39845 wxWindow *arg1 = (wxWindow *) 0 ;
39846 int arg2 ;
39847 int result;
39848 void *argp1 = 0 ;
39849 int res1 = 0 ;
39850 int val2 ;
39851 int ecode2 = 0 ;
39852 PyObject * obj0 = 0 ;
39853 PyObject * obj1 = 0 ;
39854 char * kwnames[] = {
39855 (char *) "self",(char *) "orientation", NULL
39856 };
39857
39858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
39859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39860 if (!SWIG_IsOK(res1)) {
39861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
39862 }
39863 arg1 = reinterpret_cast< wxWindow * >(argp1);
39864 ecode2 = SWIG_AsVal_int(obj1, &val2);
39865 if (!SWIG_IsOK(ecode2)) {
39866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
39867 }
39868 arg2 = static_cast< int >(val2);
39869 {
39870 PyThreadState* __tstate = wxPyBeginAllowThreads();
39871 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
39872 wxPyEndAllowThreads(__tstate);
39873 if (PyErr_Occurred()) SWIG_fail;
39874 }
39875 resultobj = SWIG_From_int(static_cast< int >(result));
39876 return resultobj;
39877 fail:
39878 return NULL;
39879 }
39880
39881
39882 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39883 PyObject *resultobj = 0;
39884 wxWindow *arg1 = (wxWindow *) 0 ;
39885 int arg2 ;
39886 int result;
39887 void *argp1 = 0 ;
39888 int res1 = 0 ;
39889 int val2 ;
39890 int ecode2 = 0 ;
39891 PyObject * obj0 = 0 ;
39892 PyObject * obj1 = 0 ;
39893 char * kwnames[] = {
39894 (char *) "self",(char *) "orientation", NULL
39895 };
39896
39897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
39898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39899 if (!SWIG_IsOK(res1)) {
39900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
39901 }
39902 arg1 = reinterpret_cast< wxWindow * >(argp1);
39903 ecode2 = SWIG_AsVal_int(obj1, &val2);
39904 if (!SWIG_IsOK(ecode2)) {
39905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
39906 }
39907 arg2 = static_cast< int >(val2);
39908 {
39909 PyThreadState* __tstate = wxPyBeginAllowThreads();
39910 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
39911 wxPyEndAllowThreads(__tstate);
39912 if (PyErr_Occurred()) SWIG_fail;
39913 }
39914 resultobj = SWIG_From_int(static_cast< int >(result));
39915 return resultobj;
39916 fail:
39917 return NULL;
39918 }
39919
39920
39921 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39922 PyObject *resultobj = 0;
39923 wxWindow *arg1 = (wxWindow *) 0 ;
39924 int arg2 ;
39925 int arg3 ;
39926 wxRect *arg4 = (wxRect *) NULL ;
39927 void *argp1 = 0 ;
39928 int res1 = 0 ;
39929 int val2 ;
39930 int ecode2 = 0 ;
39931 int val3 ;
39932 int ecode3 = 0 ;
39933 void *argp4 = 0 ;
39934 int res4 = 0 ;
39935 PyObject * obj0 = 0 ;
39936 PyObject * obj1 = 0 ;
39937 PyObject * obj2 = 0 ;
39938 PyObject * obj3 = 0 ;
39939 char * kwnames[] = {
39940 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
39941 };
39942
39943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39945 if (!SWIG_IsOK(res1)) {
39946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
39947 }
39948 arg1 = reinterpret_cast< wxWindow * >(argp1);
39949 ecode2 = SWIG_AsVal_int(obj1, &val2);
39950 if (!SWIG_IsOK(ecode2)) {
39951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
39952 }
39953 arg2 = static_cast< int >(val2);
39954 ecode3 = SWIG_AsVal_int(obj2, &val3);
39955 if (!SWIG_IsOK(ecode3)) {
39956 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
39957 }
39958 arg3 = static_cast< int >(val3);
39959 if (obj3) {
39960 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
39961 if (!SWIG_IsOK(res4)) {
39962 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
39963 }
39964 arg4 = reinterpret_cast< wxRect * >(argp4);
39965 }
39966 {
39967 PyThreadState* __tstate = wxPyBeginAllowThreads();
39968 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
39969 wxPyEndAllowThreads(__tstate);
39970 if (PyErr_Occurred()) SWIG_fail;
39971 }
39972 resultobj = SWIG_Py_Void();
39973 return resultobj;
39974 fail:
39975 return NULL;
39976 }
39977
39978
39979 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39980 PyObject *resultobj = 0;
39981 wxWindow *arg1 = (wxWindow *) 0 ;
39982 int arg2 ;
39983 bool result;
39984 void *argp1 = 0 ;
39985 int res1 = 0 ;
39986 int val2 ;
39987 int ecode2 = 0 ;
39988 PyObject * obj0 = 0 ;
39989 PyObject * obj1 = 0 ;
39990 char * kwnames[] = {
39991 (char *) "self",(char *) "lines", NULL
39992 };
39993
39994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
39995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39996 if (!SWIG_IsOK(res1)) {
39997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
39998 }
39999 arg1 = reinterpret_cast< wxWindow * >(argp1);
40000 ecode2 = SWIG_AsVal_int(obj1, &val2);
40001 if (!SWIG_IsOK(ecode2)) {
40002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40003 }
40004 arg2 = static_cast< int >(val2);
40005 {
40006 PyThreadState* __tstate = wxPyBeginAllowThreads();
40007 result = (bool)(arg1)->ScrollLines(arg2);
40008 wxPyEndAllowThreads(__tstate);
40009 if (PyErr_Occurred()) SWIG_fail;
40010 }
40011 {
40012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40013 }
40014 return resultobj;
40015 fail:
40016 return NULL;
40017 }
40018
40019
40020 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40021 PyObject *resultobj = 0;
40022 wxWindow *arg1 = (wxWindow *) 0 ;
40023 int arg2 ;
40024 bool result;
40025 void *argp1 = 0 ;
40026 int res1 = 0 ;
40027 int val2 ;
40028 int ecode2 = 0 ;
40029 PyObject * obj0 = 0 ;
40030 PyObject * obj1 = 0 ;
40031 char * kwnames[] = {
40032 (char *) "self",(char *) "pages", NULL
40033 };
40034
40035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40037 if (!SWIG_IsOK(res1)) {
40038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40039 }
40040 arg1 = reinterpret_cast< wxWindow * >(argp1);
40041 ecode2 = SWIG_AsVal_int(obj1, &val2);
40042 if (!SWIG_IsOK(ecode2)) {
40043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40044 }
40045 arg2 = static_cast< int >(val2);
40046 {
40047 PyThreadState* __tstate = wxPyBeginAllowThreads();
40048 result = (bool)(arg1)->ScrollPages(arg2);
40049 wxPyEndAllowThreads(__tstate);
40050 if (PyErr_Occurred()) SWIG_fail;
40051 }
40052 {
40053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40054 }
40055 return resultobj;
40056 fail:
40057 return NULL;
40058 }
40059
40060
40061 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40062 PyObject *resultobj = 0;
40063 wxWindow *arg1 = (wxWindow *) 0 ;
40064 bool result;
40065 void *argp1 = 0 ;
40066 int res1 = 0 ;
40067 PyObject *swig_obj[1] ;
40068
40069 if (!args) SWIG_fail;
40070 swig_obj[0] = args;
40071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40072 if (!SWIG_IsOK(res1)) {
40073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40074 }
40075 arg1 = reinterpret_cast< wxWindow * >(argp1);
40076 {
40077 PyThreadState* __tstate = wxPyBeginAllowThreads();
40078 result = (bool)(arg1)->LineUp();
40079 wxPyEndAllowThreads(__tstate);
40080 if (PyErr_Occurred()) SWIG_fail;
40081 }
40082 {
40083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40084 }
40085 return resultobj;
40086 fail:
40087 return NULL;
40088 }
40089
40090
40091 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40092 PyObject *resultobj = 0;
40093 wxWindow *arg1 = (wxWindow *) 0 ;
40094 bool result;
40095 void *argp1 = 0 ;
40096 int res1 = 0 ;
40097 PyObject *swig_obj[1] ;
40098
40099 if (!args) SWIG_fail;
40100 swig_obj[0] = args;
40101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40102 if (!SWIG_IsOK(res1)) {
40103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40104 }
40105 arg1 = reinterpret_cast< wxWindow * >(argp1);
40106 {
40107 PyThreadState* __tstate = wxPyBeginAllowThreads();
40108 result = (bool)(arg1)->LineDown();
40109 wxPyEndAllowThreads(__tstate);
40110 if (PyErr_Occurred()) SWIG_fail;
40111 }
40112 {
40113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40114 }
40115 return resultobj;
40116 fail:
40117 return NULL;
40118 }
40119
40120
40121 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40122 PyObject *resultobj = 0;
40123 wxWindow *arg1 = (wxWindow *) 0 ;
40124 bool result;
40125 void *argp1 = 0 ;
40126 int res1 = 0 ;
40127 PyObject *swig_obj[1] ;
40128
40129 if (!args) SWIG_fail;
40130 swig_obj[0] = args;
40131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40132 if (!SWIG_IsOK(res1)) {
40133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40134 }
40135 arg1 = reinterpret_cast< wxWindow * >(argp1);
40136 {
40137 PyThreadState* __tstate = wxPyBeginAllowThreads();
40138 result = (bool)(arg1)->PageUp();
40139 wxPyEndAllowThreads(__tstate);
40140 if (PyErr_Occurred()) SWIG_fail;
40141 }
40142 {
40143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40144 }
40145 return resultobj;
40146 fail:
40147 return NULL;
40148 }
40149
40150
40151 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40152 PyObject *resultobj = 0;
40153 wxWindow *arg1 = (wxWindow *) 0 ;
40154 bool result;
40155 void *argp1 = 0 ;
40156 int res1 = 0 ;
40157 PyObject *swig_obj[1] ;
40158
40159 if (!args) SWIG_fail;
40160 swig_obj[0] = args;
40161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40162 if (!SWIG_IsOK(res1)) {
40163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40164 }
40165 arg1 = reinterpret_cast< wxWindow * >(argp1);
40166 {
40167 PyThreadState* __tstate = wxPyBeginAllowThreads();
40168 result = (bool)(arg1)->PageDown();
40169 wxPyEndAllowThreads(__tstate);
40170 if (PyErr_Occurred()) SWIG_fail;
40171 }
40172 {
40173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40174 }
40175 return resultobj;
40176 fail:
40177 return NULL;
40178 }
40179
40180
40181 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40182 PyObject *resultobj = 0;
40183 wxWindow *arg1 = (wxWindow *) 0 ;
40184 wxString *arg2 = 0 ;
40185 void *argp1 = 0 ;
40186 int res1 = 0 ;
40187 bool temp2 = false ;
40188 PyObject * obj0 = 0 ;
40189 PyObject * obj1 = 0 ;
40190 char * kwnames[] = {
40191 (char *) "self",(char *) "text", NULL
40192 };
40193
40194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40196 if (!SWIG_IsOK(res1)) {
40197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40198 }
40199 arg1 = reinterpret_cast< wxWindow * >(argp1);
40200 {
40201 arg2 = wxString_in_helper(obj1);
40202 if (arg2 == NULL) SWIG_fail;
40203 temp2 = true;
40204 }
40205 {
40206 PyThreadState* __tstate = wxPyBeginAllowThreads();
40207 (arg1)->SetHelpText((wxString const &)*arg2);
40208 wxPyEndAllowThreads(__tstate);
40209 if (PyErr_Occurred()) SWIG_fail;
40210 }
40211 resultobj = SWIG_Py_Void();
40212 {
40213 if (temp2)
40214 delete arg2;
40215 }
40216 return resultobj;
40217 fail:
40218 {
40219 if (temp2)
40220 delete arg2;
40221 }
40222 return NULL;
40223 }
40224
40225
40226 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40227 PyObject *resultobj = 0;
40228 wxWindow *arg1 = (wxWindow *) 0 ;
40229 wxString *arg2 = 0 ;
40230 void *argp1 = 0 ;
40231 int res1 = 0 ;
40232 bool temp2 = false ;
40233 PyObject * obj0 = 0 ;
40234 PyObject * obj1 = 0 ;
40235 char * kwnames[] = {
40236 (char *) "self",(char *) "text", NULL
40237 };
40238
40239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40241 if (!SWIG_IsOK(res1)) {
40242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40243 }
40244 arg1 = reinterpret_cast< wxWindow * >(argp1);
40245 {
40246 arg2 = wxString_in_helper(obj1);
40247 if (arg2 == NULL) SWIG_fail;
40248 temp2 = true;
40249 }
40250 {
40251 PyThreadState* __tstate = wxPyBeginAllowThreads();
40252 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40253 wxPyEndAllowThreads(__tstate);
40254 if (PyErr_Occurred()) SWIG_fail;
40255 }
40256 resultobj = SWIG_Py_Void();
40257 {
40258 if (temp2)
40259 delete arg2;
40260 }
40261 return resultobj;
40262 fail:
40263 {
40264 if (temp2)
40265 delete arg2;
40266 }
40267 return NULL;
40268 }
40269
40270
40271 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40272 PyObject *resultobj = 0;
40273 wxWindow *arg1 = (wxWindow *) 0 ;
40274 wxPoint *arg2 = 0 ;
40275 wxHelpEvent::Origin arg3 ;
40276 wxString result;
40277 void *argp1 = 0 ;
40278 int res1 = 0 ;
40279 wxPoint temp2 ;
40280 void *argp3 ;
40281 int res3 = 0 ;
40282 PyObject * obj0 = 0 ;
40283 PyObject * obj1 = 0 ;
40284 PyObject * obj2 = 0 ;
40285 char * kwnames[] = {
40286 (char *) "self",(char *) "pt",(char *) "origin", NULL
40287 };
40288
40289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40291 if (!SWIG_IsOK(res1)) {
40292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40293 }
40294 arg1 = reinterpret_cast< wxWindow * >(argp1);
40295 {
40296 arg2 = &temp2;
40297 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40298 }
40299 {
40300 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40301 if (!SWIG_IsOK(res3)) {
40302 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40303 }
40304 if (!argp3) {
40305 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40306 } else {
40307 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40308 arg3 = *temp;
40309 if (SWIG_IsNewObj(res3)) delete temp;
40310 }
40311 }
40312 {
40313 PyThreadState* __tstate = wxPyBeginAllowThreads();
40314 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40315 wxPyEndAllowThreads(__tstate);
40316 if (PyErr_Occurred()) SWIG_fail;
40317 }
40318 {
40319 #if wxUSE_UNICODE
40320 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40321 #else
40322 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40323 #endif
40324 }
40325 return resultobj;
40326 fail:
40327 return NULL;
40328 }
40329
40330
40331 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40332 PyObject *resultobj = 0;
40333 wxWindow *arg1 = (wxWindow *) 0 ;
40334 wxString result;
40335 void *argp1 = 0 ;
40336 int res1 = 0 ;
40337 PyObject *swig_obj[1] ;
40338
40339 if (!args) SWIG_fail;
40340 swig_obj[0] = args;
40341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40342 if (!SWIG_IsOK(res1)) {
40343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40344 }
40345 arg1 = reinterpret_cast< wxWindow * >(argp1);
40346 {
40347 PyThreadState* __tstate = wxPyBeginAllowThreads();
40348 result = ((wxWindow const *)arg1)->GetHelpText();
40349 wxPyEndAllowThreads(__tstate);
40350 if (PyErr_Occurred()) SWIG_fail;
40351 }
40352 {
40353 #if wxUSE_UNICODE
40354 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40355 #else
40356 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40357 #endif
40358 }
40359 return resultobj;
40360 fail:
40361 return NULL;
40362 }
40363
40364
40365 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40366 PyObject *resultobj = 0;
40367 wxWindow *arg1 = (wxWindow *) 0 ;
40368 wxString *arg2 = 0 ;
40369 void *argp1 = 0 ;
40370 int res1 = 0 ;
40371 bool temp2 = false ;
40372 PyObject * obj0 = 0 ;
40373 PyObject * obj1 = 0 ;
40374 char * kwnames[] = {
40375 (char *) "self",(char *) "tip", NULL
40376 };
40377
40378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40380 if (!SWIG_IsOK(res1)) {
40381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40382 }
40383 arg1 = reinterpret_cast< wxWindow * >(argp1);
40384 {
40385 arg2 = wxString_in_helper(obj1);
40386 if (arg2 == NULL) SWIG_fail;
40387 temp2 = true;
40388 }
40389 {
40390 PyThreadState* __tstate = wxPyBeginAllowThreads();
40391 (arg1)->SetToolTip((wxString const &)*arg2);
40392 wxPyEndAllowThreads(__tstate);
40393 if (PyErr_Occurred()) SWIG_fail;
40394 }
40395 resultobj = SWIG_Py_Void();
40396 {
40397 if (temp2)
40398 delete arg2;
40399 }
40400 return resultobj;
40401 fail:
40402 {
40403 if (temp2)
40404 delete arg2;
40405 }
40406 return NULL;
40407 }
40408
40409
40410 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40411 PyObject *resultobj = 0;
40412 wxWindow *arg1 = (wxWindow *) 0 ;
40413 wxToolTip *arg2 = (wxToolTip *) 0 ;
40414 void *argp1 = 0 ;
40415 int res1 = 0 ;
40416 int res2 = 0 ;
40417 PyObject * obj0 = 0 ;
40418 PyObject * obj1 = 0 ;
40419 char * kwnames[] = {
40420 (char *) "self",(char *) "tip", NULL
40421 };
40422
40423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40425 if (!SWIG_IsOK(res1)) {
40426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40427 }
40428 arg1 = reinterpret_cast< wxWindow * >(argp1);
40429 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40430 if (!SWIG_IsOK(res2)) {
40431 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40432 }
40433 {
40434 PyThreadState* __tstate = wxPyBeginAllowThreads();
40435 (arg1)->SetToolTip(arg2);
40436 wxPyEndAllowThreads(__tstate);
40437 if (PyErr_Occurred()) SWIG_fail;
40438 }
40439 resultobj = SWIG_Py_Void();
40440 return resultobj;
40441 fail:
40442 return NULL;
40443 }
40444
40445
40446 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40447 PyObject *resultobj = 0;
40448 wxWindow *arg1 = (wxWindow *) 0 ;
40449 wxToolTip *result = 0 ;
40450 void *argp1 = 0 ;
40451 int res1 = 0 ;
40452 PyObject *swig_obj[1] ;
40453
40454 if (!args) SWIG_fail;
40455 swig_obj[0] = args;
40456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40457 if (!SWIG_IsOK(res1)) {
40458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40459 }
40460 arg1 = reinterpret_cast< wxWindow * >(argp1);
40461 {
40462 PyThreadState* __tstate = wxPyBeginAllowThreads();
40463 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40464 wxPyEndAllowThreads(__tstate);
40465 if (PyErr_Occurred()) SWIG_fail;
40466 }
40467 {
40468 resultobj = wxPyMake_wxObject(result, (bool)0);
40469 }
40470 return resultobj;
40471 fail:
40472 return NULL;
40473 }
40474
40475
40476 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40477 PyObject *resultobj = 0;
40478 wxWindow *arg1 = (wxWindow *) 0 ;
40479 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40480 void *argp1 = 0 ;
40481 int res1 = 0 ;
40482 int res2 = 0 ;
40483 PyObject * obj0 = 0 ;
40484 PyObject * obj1 = 0 ;
40485 char * kwnames[] = {
40486 (char *) "self",(char *) "dropTarget", NULL
40487 };
40488
40489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40491 if (!SWIG_IsOK(res1)) {
40492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40493 }
40494 arg1 = reinterpret_cast< wxWindow * >(argp1);
40495 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40496 if (!SWIG_IsOK(res2)) {
40497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40498 }
40499 {
40500 PyThreadState* __tstate = wxPyBeginAllowThreads();
40501 (arg1)->SetDropTarget(arg2);
40502 wxPyEndAllowThreads(__tstate);
40503 if (PyErr_Occurred()) SWIG_fail;
40504 }
40505 resultobj = SWIG_Py_Void();
40506 return resultobj;
40507 fail:
40508 return NULL;
40509 }
40510
40511
40512 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40513 PyObject *resultobj = 0;
40514 wxWindow *arg1 = (wxWindow *) 0 ;
40515 wxPyDropTarget *result = 0 ;
40516 void *argp1 = 0 ;
40517 int res1 = 0 ;
40518 PyObject *swig_obj[1] ;
40519
40520 if (!args) SWIG_fail;
40521 swig_obj[0] = args;
40522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40523 if (!SWIG_IsOK(res1)) {
40524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40525 }
40526 arg1 = reinterpret_cast< wxWindow * >(argp1);
40527 {
40528 PyThreadState* __tstate = wxPyBeginAllowThreads();
40529 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40530 wxPyEndAllowThreads(__tstate);
40531 if (PyErr_Occurred()) SWIG_fail;
40532 }
40533 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40534 return resultobj;
40535 fail:
40536 return NULL;
40537 }
40538
40539
40540 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40541 PyObject *resultobj = 0;
40542 wxWindow *arg1 = (wxWindow *) 0 ;
40543 bool arg2 ;
40544 void *argp1 = 0 ;
40545 int res1 = 0 ;
40546 bool val2 ;
40547 int ecode2 = 0 ;
40548 PyObject * obj0 = 0 ;
40549 PyObject * obj1 = 0 ;
40550 char * kwnames[] = {
40551 (char *) "self",(char *) "accept", NULL
40552 };
40553
40554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40556 if (!SWIG_IsOK(res1)) {
40557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40558 }
40559 arg1 = reinterpret_cast< wxWindow * >(argp1);
40560 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40561 if (!SWIG_IsOK(ecode2)) {
40562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40563 }
40564 arg2 = static_cast< bool >(val2);
40565 {
40566 PyThreadState* __tstate = wxPyBeginAllowThreads();
40567 wxWindow_DragAcceptFiles(arg1,arg2);
40568 wxPyEndAllowThreads(__tstate);
40569 if (PyErr_Occurred()) SWIG_fail;
40570 }
40571 resultobj = SWIG_Py_Void();
40572 return resultobj;
40573 fail:
40574 return NULL;
40575 }
40576
40577
40578 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40579 PyObject *resultobj = 0;
40580 wxWindow *arg1 = (wxWindow *) 0 ;
40581 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40582 void *argp1 = 0 ;
40583 int res1 = 0 ;
40584 int res2 = 0 ;
40585 PyObject * obj0 = 0 ;
40586 PyObject * obj1 = 0 ;
40587 char * kwnames[] = {
40588 (char *) "self",(char *) "constraints", NULL
40589 };
40590
40591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40593 if (!SWIG_IsOK(res1)) {
40594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40595 }
40596 arg1 = reinterpret_cast< wxWindow * >(argp1);
40597 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40598 if (!SWIG_IsOK(res2)) {
40599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40600 }
40601 {
40602 PyThreadState* __tstate = wxPyBeginAllowThreads();
40603 (arg1)->SetConstraints(arg2);
40604 wxPyEndAllowThreads(__tstate);
40605 if (PyErr_Occurred()) SWIG_fail;
40606 }
40607 resultobj = SWIG_Py_Void();
40608 return resultobj;
40609 fail:
40610 return NULL;
40611 }
40612
40613
40614 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40615 PyObject *resultobj = 0;
40616 wxWindow *arg1 = (wxWindow *) 0 ;
40617 wxLayoutConstraints *result = 0 ;
40618 void *argp1 = 0 ;
40619 int res1 = 0 ;
40620 PyObject *swig_obj[1] ;
40621
40622 if (!args) SWIG_fail;
40623 swig_obj[0] = args;
40624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40625 if (!SWIG_IsOK(res1)) {
40626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40627 }
40628 arg1 = reinterpret_cast< wxWindow * >(argp1);
40629 {
40630 PyThreadState* __tstate = wxPyBeginAllowThreads();
40631 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40632 wxPyEndAllowThreads(__tstate);
40633 if (PyErr_Occurred()) SWIG_fail;
40634 }
40635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40636 return resultobj;
40637 fail:
40638 return NULL;
40639 }
40640
40641
40642 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40643 PyObject *resultobj = 0;
40644 wxWindow *arg1 = (wxWindow *) 0 ;
40645 bool arg2 ;
40646 void *argp1 = 0 ;
40647 int res1 = 0 ;
40648 bool val2 ;
40649 int ecode2 = 0 ;
40650 PyObject * obj0 = 0 ;
40651 PyObject * obj1 = 0 ;
40652 char * kwnames[] = {
40653 (char *) "self",(char *) "autoLayout", NULL
40654 };
40655
40656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40658 if (!SWIG_IsOK(res1)) {
40659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40660 }
40661 arg1 = reinterpret_cast< wxWindow * >(argp1);
40662 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40663 if (!SWIG_IsOK(ecode2)) {
40664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40665 }
40666 arg2 = static_cast< bool >(val2);
40667 {
40668 PyThreadState* __tstate = wxPyBeginAllowThreads();
40669 (arg1)->SetAutoLayout(arg2);
40670 wxPyEndAllowThreads(__tstate);
40671 if (PyErr_Occurred()) SWIG_fail;
40672 }
40673 resultobj = SWIG_Py_Void();
40674 return resultobj;
40675 fail:
40676 return NULL;
40677 }
40678
40679
40680 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40681 PyObject *resultobj = 0;
40682 wxWindow *arg1 = (wxWindow *) 0 ;
40683 bool result;
40684 void *argp1 = 0 ;
40685 int res1 = 0 ;
40686 PyObject *swig_obj[1] ;
40687
40688 if (!args) SWIG_fail;
40689 swig_obj[0] = args;
40690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40691 if (!SWIG_IsOK(res1)) {
40692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
40693 }
40694 arg1 = reinterpret_cast< wxWindow * >(argp1);
40695 {
40696 PyThreadState* __tstate = wxPyBeginAllowThreads();
40697 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
40698 wxPyEndAllowThreads(__tstate);
40699 if (PyErr_Occurred()) SWIG_fail;
40700 }
40701 {
40702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40703 }
40704 return resultobj;
40705 fail:
40706 return NULL;
40707 }
40708
40709
40710 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40711 PyObject *resultobj = 0;
40712 wxWindow *arg1 = (wxWindow *) 0 ;
40713 bool result;
40714 void *argp1 = 0 ;
40715 int res1 = 0 ;
40716 PyObject *swig_obj[1] ;
40717
40718 if (!args) SWIG_fail;
40719 swig_obj[0] = args;
40720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40721 if (!SWIG_IsOK(res1)) {
40722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
40723 }
40724 arg1 = reinterpret_cast< wxWindow * >(argp1);
40725 {
40726 PyThreadState* __tstate = wxPyBeginAllowThreads();
40727 result = (bool)(arg1)->Layout();
40728 wxPyEndAllowThreads(__tstate);
40729 if (PyErr_Occurred()) SWIG_fail;
40730 }
40731 {
40732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40733 }
40734 return resultobj;
40735 fail:
40736 return NULL;
40737 }
40738
40739
40740 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40741 PyObject *resultobj = 0;
40742 wxWindow *arg1 = (wxWindow *) 0 ;
40743 wxSizer *arg2 = (wxSizer *) 0 ;
40744 bool arg3 = (bool) true ;
40745 void *argp1 = 0 ;
40746 int res1 = 0 ;
40747 int res2 = 0 ;
40748 bool val3 ;
40749 int ecode3 = 0 ;
40750 PyObject * obj0 = 0 ;
40751 PyObject * obj1 = 0 ;
40752 PyObject * obj2 = 0 ;
40753 char * kwnames[] = {
40754 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40755 };
40756
40757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40759 if (!SWIG_IsOK(res1)) {
40760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40761 }
40762 arg1 = reinterpret_cast< wxWindow * >(argp1);
40763 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40764 if (!SWIG_IsOK(res2)) {
40765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40766 }
40767 if (obj2) {
40768 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40769 if (!SWIG_IsOK(ecode3)) {
40770 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
40771 }
40772 arg3 = static_cast< bool >(val3);
40773 }
40774 {
40775 PyThreadState* __tstate = wxPyBeginAllowThreads();
40776 (arg1)->SetSizer(arg2,arg3);
40777 wxPyEndAllowThreads(__tstate);
40778 if (PyErr_Occurred()) SWIG_fail;
40779 }
40780 resultobj = SWIG_Py_Void();
40781 return resultobj;
40782 fail:
40783 return NULL;
40784 }
40785
40786
40787 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40788 PyObject *resultobj = 0;
40789 wxWindow *arg1 = (wxWindow *) 0 ;
40790 wxSizer *arg2 = (wxSizer *) 0 ;
40791 bool arg3 = (bool) true ;
40792 void *argp1 = 0 ;
40793 int res1 = 0 ;
40794 int res2 = 0 ;
40795 bool val3 ;
40796 int ecode3 = 0 ;
40797 PyObject * obj0 = 0 ;
40798 PyObject * obj1 = 0 ;
40799 PyObject * obj2 = 0 ;
40800 char * kwnames[] = {
40801 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40802 };
40803
40804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40806 if (!SWIG_IsOK(res1)) {
40807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
40808 }
40809 arg1 = reinterpret_cast< wxWindow * >(argp1);
40810 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40811 if (!SWIG_IsOK(res2)) {
40812 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
40813 }
40814 if (obj2) {
40815 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40816 if (!SWIG_IsOK(ecode3)) {
40817 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
40818 }
40819 arg3 = static_cast< bool >(val3);
40820 }
40821 {
40822 PyThreadState* __tstate = wxPyBeginAllowThreads();
40823 (arg1)->SetSizerAndFit(arg2,arg3);
40824 wxPyEndAllowThreads(__tstate);
40825 if (PyErr_Occurred()) SWIG_fail;
40826 }
40827 resultobj = SWIG_Py_Void();
40828 return resultobj;
40829 fail:
40830 return NULL;
40831 }
40832
40833
40834 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40835 PyObject *resultobj = 0;
40836 wxWindow *arg1 = (wxWindow *) 0 ;
40837 wxSizer *result = 0 ;
40838 void *argp1 = 0 ;
40839 int res1 = 0 ;
40840 PyObject *swig_obj[1] ;
40841
40842 if (!args) SWIG_fail;
40843 swig_obj[0] = args;
40844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40845 if (!SWIG_IsOK(res1)) {
40846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40847 }
40848 arg1 = reinterpret_cast< wxWindow * >(argp1);
40849 {
40850 PyThreadState* __tstate = wxPyBeginAllowThreads();
40851 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
40852 wxPyEndAllowThreads(__tstate);
40853 if (PyErr_Occurred()) SWIG_fail;
40854 }
40855 {
40856 resultobj = wxPyMake_wxObject(result, (bool)0);
40857 }
40858 return resultobj;
40859 fail:
40860 return NULL;
40861 }
40862
40863
40864 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40865 PyObject *resultobj = 0;
40866 wxWindow *arg1 = (wxWindow *) 0 ;
40867 wxSizer *arg2 = (wxSizer *) 0 ;
40868 void *argp1 = 0 ;
40869 int res1 = 0 ;
40870 void *argp2 = 0 ;
40871 int res2 = 0 ;
40872 PyObject * obj0 = 0 ;
40873 PyObject * obj1 = 0 ;
40874 char * kwnames[] = {
40875 (char *) "self",(char *) "sizer", NULL
40876 };
40877
40878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
40879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40880 if (!SWIG_IsOK(res1)) {
40881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40882 }
40883 arg1 = reinterpret_cast< wxWindow * >(argp1);
40884 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
40885 if (!SWIG_IsOK(res2)) {
40886 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40887 }
40888 arg2 = reinterpret_cast< wxSizer * >(argp2);
40889 {
40890 PyThreadState* __tstate = wxPyBeginAllowThreads();
40891 (arg1)->SetContainingSizer(arg2);
40892 wxPyEndAllowThreads(__tstate);
40893 if (PyErr_Occurred()) SWIG_fail;
40894 }
40895 resultobj = SWIG_Py_Void();
40896 return resultobj;
40897 fail:
40898 return NULL;
40899 }
40900
40901
40902 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40903 PyObject *resultobj = 0;
40904 wxWindow *arg1 = (wxWindow *) 0 ;
40905 wxSizer *result = 0 ;
40906 void *argp1 = 0 ;
40907 int res1 = 0 ;
40908 PyObject *swig_obj[1] ;
40909
40910 if (!args) SWIG_fail;
40911 swig_obj[0] = args;
40912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40913 if (!SWIG_IsOK(res1)) {
40914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40915 }
40916 arg1 = reinterpret_cast< wxWindow * >(argp1);
40917 {
40918 PyThreadState* __tstate = wxPyBeginAllowThreads();
40919 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
40920 wxPyEndAllowThreads(__tstate);
40921 if (PyErr_Occurred()) SWIG_fail;
40922 }
40923 {
40924 resultobj = wxPyMake_wxObject(result, (bool)0);
40925 }
40926 return resultobj;
40927 fail:
40928 return NULL;
40929 }
40930
40931
40932 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40933 PyObject *resultobj = 0;
40934 wxWindow *arg1 = (wxWindow *) 0 ;
40935 void *argp1 = 0 ;
40936 int res1 = 0 ;
40937 PyObject *swig_obj[1] ;
40938
40939 if (!args) SWIG_fail;
40940 swig_obj[0] = args;
40941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40942 if (!SWIG_IsOK(res1)) {
40943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
40944 }
40945 arg1 = reinterpret_cast< wxWindow * >(argp1);
40946 {
40947 PyThreadState* __tstate = wxPyBeginAllowThreads();
40948 (arg1)->InheritAttributes();
40949 wxPyEndAllowThreads(__tstate);
40950 if (PyErr_Occurred()) SWIG_fail;
40951 }
40952 resultobj = SWIG_Py_Void();
40953 return resultobj;
40954 fail:
40955 return NULL;
40956 }
40957
40958
40959 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40960 PyObject *resultobj = 0;
40961 wxWindow *arg1 = (wxWindow *) 0 ;
40962 bool result;
40963 void *argp1 = 0 ;
40964 int res1 = 0 ;
40965 PyObject *swig_obj[1] ;
40966
40967 if (!args) SWIG_fail;
40968 swig_obj[0] = args;
40969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40970 if (!SWIG_IsOK(res1)) {
40971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
40972 }
40973 arg1 = reinterpret_cast< wxWindow * >(argp1);
40974 {
40975 PyThreadState* __tstate = wxPyBeginAllowThreads();
40976 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
40977 wxPyEndAllowThreads(__tstate);
40978 if (PyErr_Occurred()) SWIG_fail;
40979 }
40980 {
40981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40982 }
40983 return resultobj;
40984 fail:
40985 return NULL;
40986 }
40987
40988
40989 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40990 PyObject *resultobj = 0;
40991 wxWindow *arg1 = (wxWindow *) 0 ;
40992 bool result;
40993 void *argp1 = 0 ;
40994 int res1 = 0 ;
40995 PyObject *swig_obj[1] ;
40996
40997 if (!args) SWIG_fail;
40998 swig_obj[0] = args;
40999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41000 if (!SWIG_IsOK(res1)) {
41001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41002 }
41003 arg1 = reinterpret_cast< wxWindow * >(argp1);
41004 {
41005 PyThreadState* __tstate = wxPyBeginAllowThreads();
41006 result = (bool)(arg1)->CanSetTransparent();
41007 wxPyEndAllowThreads(__tstate);
41008 if (PyErr_Occurred()) SWIG_fail;
41009 }
41010 {
41011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41012 }
41013 return resultobj;
41014 fail:
41015 return NULL;
41016 }
41017
41018
41019 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41020 PyObject *resultobj = 0;
41021 wxWindow *arg1 = (wxWindow *) 0 ;
41022 byte arg2 ;
41023 bool result;
41024 void *argp1 = 0 ;
41025 int res1 = 0 ;
41026 unsigned char val2 ;
41027 int ecode2 = 0 ;
41028 PyObject * obj0 = 0 ;
41029 PyObject * obj1 = 0 ;
41030 char * kwnames[] = {
41031 (char *) "self",(char *) "alpha", NULL
41032 };
41033
41034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41036 if (!SWIG_IsOK(res1)) {
41037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41038 }
41039 arg1 = reinterpret_cast< wxWindow * >(argp1);
41040 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41041 if (!SWIG_IsOK(ecode2)) {
41042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41043 }
41044 arg2 = static_cast< byte >(val2);
41045 {
41046 PyThreadState* __tstate = wxPyBeginAllowThreads();
41047 result = (bool)(arg1)->SetTransparent(arg2);
41048 wxPyEndAllowThreads(__tstate);
41049 if (PyErr_Occurred()) SWIG_fail;
41050 }
41051 {
41052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41053 }
41054 return resultobj;
41055 fail:
41056 return NULL;
41057 }
41058
41059
41060 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41061 PyObject *obj;
41062 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41063 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41064 return SWIG_Py_Void();
41065 }
41066
41067 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41068 return SWIG_Python_InitShadowInstance(args);
41069 }
41070
41071 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41072 PyObject *resultobj = 0;
41073 long arg1 ;
41074 wxWindow *arg2 = (wxWindow *) NULL ;
41075 wxWindow *result = 0 ;
41076 long val1 ;
41077 int ecode1 = 0 ;
41078 void *argp2 = 0 ;
41079 int res2 = 0 ;
41080 PyObject * obj0 = 0 ;
41081 PyObject * obj1 = 0 ;
41082 char * kwnames[] = {
41083 (char *) "id",(char *) "parent", NULL
41084 };
41085
41086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41087 ecode1 = SWIG_AsVal_long(obj0, &val1);
41088 if (!SWIG_IsOK(ecode1)) {
41089 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41090 }
41091 arg1 = static_cast< long >(val1);
41092 if (obj1) {
41093 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41094 if (!SWIG_IsOK(res2)) {
41095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41096 }
41097 arg2 = reinterpret_cast< wxWindow * >(argp2);
41098 }
41099 {
41100 if (!wxPyCheckForApp()) SWIG_fail;
41101 PyThreadState* __tstate = wxPyBeginAllowThreads();
41102 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41103 wxPyEndAllowThreads(__tstate);
41104 if (PyErr_Occurred()) SWIG_fail;
41105 }
41106 {
41107 resultobj = wxPyMake_wxObject(result, 0);
41108 }
41109 return resultobj;
41110 fail:
41111 return NULL;
41112 }
41113
41114
41115 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41116 PyObject *resultobj = 0;
41117 wxString *arg1 = 0 ;
41118 wxWindow *arg2 = (wxWindow *) NULL ;
41119 wxWindow *result = 0 ;
41120 bool temp1 = false ;
41121 void *argp2 = 0 ;
41122 int res2 = 0 ;
41123 PyObject * obj0 = 0 ;
41124 PyObject * obj1 = 0 ;
41125 char * kwnames[] = {
41126 (char *) "name",(char *) "parent", NULL
41127 };
41128
41129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41130 {
41131 arg1 = wxString_in_helper(obj0);
41132 if (arg1 == NULL) SWIG_fail;
41133 temp1 = true;
41134 }
41135 if (obj1) {
41136 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41137 if (!SWIG_IsOK(res2)) {
41138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41139 }
41140 arg2 = reinterpret_cast< wxWindow * >(argp2);
41141 }
41142 {
41143 if (!wxPyCheckForApp()) SWIG_fail;
41144 PyThreadState* __tstate = wxPyBeginAllowThreads();
41145 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41146 wxPyEndAllowThreads(__tstate);
41147 if (PyErr_Occurred()) SWIG_fail;
41148 }
41149 {
41150 resultobj = wxPyMake_wxObject(result, 0);
41151 }
41152 {
41153 if (temp1)
41154 delete arg1;
41155 }
41156 return resultobj;
41157 fail:
41158 {
41159 if (temp1)
41160 delete arg1;
41161 }
41162 return NULL;
41163 }
41164
41165
41166 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41167 PyObject *resultobj = 0;
41168 wxString *arg1 = 0 ;
41169 wxWindow *arg2 = (wxWindow *) NULL ;
41170 wxWindow *result = 0 ;
41171 bool temp1 = false ;
41172 void *argp2 = 0 ;
41173 int res2 = 0 ;
41174 PyObject * obj0 = 0 ;
41175 PyObject * obj1 = 0 ;
41176 char * kwnames[] = {
41177 (char *) "label",(char *) "parent", NULL
41178 };
41179
41180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41181 {
41182 arg1 = wxString_in_helper(obj0);
41183 if (arg1 == NULL) SWIG_fail;
41184 temp1 = true;
41185 }
41186 if (obj1) {
41187 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41188 if (!SWIG_IsOK(res2)) {
41189 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41190 }
41191 arg2 = reinterpret_cast< wxWindow * >(argp2);
41192 }
41193 {
41194 if (!wxPyCheckForApp()) SWIG_fail;
41195 PyThreadState* __tstate = wxPyBeginAllowThreads();
41196 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41197 wxPyEndAllowThreads(__tstate);
41198 if (PyErr_Occurred()) SWIG_fail;
41199 }
41200 {
41201 resultobj = wxPyMake_wxObject(result, 0);
41202 }
41203 {
41204 if (temp1)
41205 delete arg1;
41206 }
41207 return resultobj;
41208 fail:
41209 {
41210 if (temp1)
41211 delete arg1;
41212 }
41213 return NULL;
41214 }
41215
41216
41217 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41218 PyObject *resultobj = 0;
41219 wxWindow *arg1 = (wxWindow *) 0 ;
41220 unsigned long arg2 ;
41221 wxWindow *result = 0 ;
41222 void *argp1 = 0 ;
41223 int res1 = 0 ;
41224 unsigned long val2 ;
41225 int ecode2 = 0 ;
41226 PyObject * obj0 = 0 ;
41227 PyObject * obj1 = 0 ;
41228 char * kwnames[] = {
41229 (char *) "parent",(char *) "_hWnd", NULL
41230 };
41231
41232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41234 if (!SWIG_IsOK(res1)) {
41235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41236 }
41237 arg1 = reinterpret_cast< wxWindow * >(argp1);
41238 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41239 if (!SWIG_IsOK(ecode2)) {
41240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41241 }
41242 arg2 = static_cast< unsigned long >(val2);
41243 {
41244 PyThreadState* __tstate = wxPyBeginAllowThreads();
41245 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41246 wxPyEndAllowThreads(__tstate);
41247 if (PyErr_Occurred()) SWIG_fail;
41248 }
41249 {
41250 resultobj = wxPyMake_wxObject(result, 0);
41251 }
41252 return resultobj;
41253 fail:
41254 return NULL;
41255 }
41256
41257
41258 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41259 PyObject *resultobj = 0;
41260 PyObject *result = 0 ;
41261
41262 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41263 {
41264 PyThreadState* __tstate = wxPyBeginAllowThreads();
41265 result = (PyObject *)GetTopLevelWindows();
41266 wxPyEndAllowThreads(__tstate);
41267 if (PyErr_Occurred()) SWIG_fail;
41268 }
41269 resultobj = result;
41270 return resultobj;
41271 fail:
41272 return NULL;
41273 }
41274
41275
41276 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41277 PyObject *resultobj = 0;
41278 wxValidator *result = 0 ;
41279
41280 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41281 {
41282 PyThreadState* __tstate = wxPyBeginAllowThreads();
41283 result = (wxValidator *)new wxValidator();
41284 wxPyEndAllowThreads(__tstate);
41285 if (PyErr_Occurred()) SWIG_fail;
41286 }
41287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41288 return resultobj;
41289 fail:
41290 return NULL;
41291 }
41292
41293
41294 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41295 PyObject *resultobj = 0;
41296 wxValidator *arg1 = (wxValidator *) 0 ;
41297 wxValidator *result = 0 ;
41298 void *argp1 = 0 ;
41299 int res1 = 0 ;
41300 PyObject *swig_obj[1] ;
41301
41302 if (!args) SWIG_fail;
41303 swig_obj[0] = args;
41304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41305 if (!SWIG_IsOK(res1)) {
41306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41307 }
41308 arg1 = reinterpret_cast< wxValidator * >(argp1);
41309 {
41310 PyThreadState* __tstate = wxPyBeginAllowThreads();
41311 result = (wxValidator *)(arg1)->Clone();
41312 wxPyEndAllowThreads(__tstate);
41313 if (PyErr_Occurred()) SWIG_fail;
41314 }
41315 {
41316 resultobj = wxPyMake_wxObject(result, 0);
41317 }
41318 return resultobj;
41319 fail:
41320 return NULL;
41321 }
41322
41323
41324 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41325 PyObject *resultobj = 0;
41326 wxValidator *arg1 = (wxValidator *) 0 ;
41327 wxWindow *arg2 = (wxWindow *) 0 ;
41328 bool result;
41329 void *argp1 = 0 ;
41330 int res1 = 0 ;
41331 void *argp2 = 0 ;
41332 int res2 = 0 ;
41333 PyObject * obj0 = 0 ;
41334 PyObject * obj1 = 0 ;
41335 char * kwnames[] = {
41336 (char *) "self",(char *) "parent", NULL
41337 };
41338
41339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41341 if (!SWIG_IsOK(res1)) {
41342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41343 }
41344 arg1 = reinterpret_cast< wxValidator * >(argp1);
41345 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41346 if (!SWIG_IsOK(res2)) {
41347 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41348 }
41349 arg2 = reinterpret_cast< wxWindow * >(argp2);
41350 {
41351 PyThreadState* __tstate = wxPyBeginAllowThreads();
41352 result = (bool)(arg1)->Validate(arg2);
41353 wxPyEndAllowThreads(__tstate);
41354 if (PyErr_Occurred()) SWIG_fail;
41355 }
41356 {
41357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41358 }
41359 return resultobj;
41360 fail:
41361 return NULL;
41362 }
41363
41364
41365 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41366 PyObject *resultobj = 0;
41367 wxValidator *arg1 = (wxValidator *) 0 ;
41368 bool result;
41369 void *argp1 = 0 ;
41370 int res1 = 0 ;
41371 PyObject *swig_obj[1] ;
41372
41373 if (!args) SWIG_fail;
41374 swig_obj[0] = args;
41375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41376 if (!SWIG_IsOK(res1)) {
41377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41378 }
41379 arg1 = reinterpret_cast< wxValidator * >(argp1);
41380 {
41381 PyThreadState* __tstate = wxPyBeginAllowThreads();
41382 result = (bool)(arg1)->TransferToWindow();
41383 wxPyEndAllowThreads(__tstate);
41384 if (PyErr_Occurred()) SWIG_fail;
41385 }
41386 {
41387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41388 }
41389 return resultobj;
41390 fail:
41391 return NULL;
41392 }
41393
41394
41395 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41396 PyObject *resultobj = 0;
41397 wxValidator *arg1 = (wxValidator *) 0 ;
41398 bool result;
41399 void *argp1 = 0 ;
41400 int res1 = 0 ;
41401 PyObject *swig_obj[1] ;
41402
41403 if (!args) SWIG_fail;
41404 swig_obj[0] = args;
41405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41406 if (!SWIG_IsOK(res1)) {
41407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41408 }
41409 arg1 = reinterpret_cast< wxValidator * >(argp1);
41410 {
41411 PyThreadState* __tstate = wxPyBeginAllowThreads();
41412 result = (bool)(arg1)->TransferFromWindow();
41413 wxPyEndAllowThreads(__tstate);
41414 if (PyErr_Occurred()) SWIG_fail;
41415 }
41416 {
41417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41418 }
41419 return resultobj;
41420 fail:
41421 return NULL;
41422 }
41423
41424
41425 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41426 PyObject *resultobj = 0;
41427 wxValidator *arg1 = (wxValidator *) 0 ;
41428 wxWindow *result = 0 ;
41429 void *argp1 = 0 ;
41430 int res1 = 0 ;
41431 PyObject *swig_obj[1] ;
41432
41433 if (!args) SWIG_fail;
41434 swig_obj[0] = args;
41435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41436 if (!SWIG_IsOK(res1)) {
41437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41438 }
41439 arg1 = reinterpret_cast< wxValidator * >(argp1);
41440 {
41441 PyThreadState* __tstate = wxPyBeginAllowThreads();
41442 result = (wxWindow *)(arg1)->GetWindow();
41443 wxPyEndAllowThreads(__tstate);
41444 if (PyErr_Occurred()) SWIG_fail;
41445 }
41446 {
41447 resultobj = wxPyMake_wxObject(result, 0);
41448 }
41449 return resultobj;
41450 fail:
41451 return NULL;
41452 }
41453
41454
41455 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41456 PyObject *resultobj = 0;
41457 wxValidator *arg1 = (wxValidator *) 0 ;
41458 wxWindow *arg2 = (wxWindow *) 0 ;
41459 void *argp1 = 0 ;
41460 int res1 = 0 ;
41461 void *argp2 = 0 ;
41462 int res2 = 0 ;
41463 PyObject * obj0 = 0 ;
41464 PyObject * obj1 = 0 ;
41465 char * kwnames[] = {
41466 (char *) "self",(char *) "window", NULL
41467 };
41468
41469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41471 if (!SWIG_IsOK(res1)) {
41472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41473 }
41474 arg1 = reinterpret_cast< wxValidator * >(argp1);
41475 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41476 if (!SWIG_IsOK(res2)) {
41477 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41478 }
41479 arg2 = reinterpret_cast< wxWindow * >(argp2);
41480 {
41481 PyThreadState* __tstate = wxPyBeginAllowThreads();
41482 (arg1)->SetWindow(arg2);
41483 wxPyEndAllowThreads(__tstate);
41484 if (PyErr_Occurred()) SWIG_fail;
41485 }
41486 resultobj = SWIG_Py_Void();
41487 return resultobj;
41488 fail:
41489 return NULL;
41490 }
41491
41492
41493 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41494 PyObject *resultobj = 0;
41495 bool result;
41496
41497 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41498 {
41499 PyThreadState* __tstate = wxPyBeginAllowThreads();
41500 result = (bool)wxValidator::IsSilent();
41501 wxPyEndAllowThreads(__tstate);
41502 if (PyErr_Occurred()) SWIG_fail;
41503 }
41504 {
41505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41506 }
41507 return resultobj;
41508 fail:
41509 return NULL;
41510 }
41511
41512
41513 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41514 PyObject *resultobj = 0;
41515 int arg1 = (int) true ;
41516 int val1 ;
41517 int ecode1 = 0 ;
41518 PyObject * obj0 = 0 ;
41519 char * kwnames[] = {
41520 (char *) "doIt", NULL
41521 };
41522
41523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41524 if (obj0) {
41525 ecode1 = SWIG_AsVal_int(obj0, &val1);
41526 if (!SWIG_IsOK(ecode1)) {
41527 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41528 }
41529 arg1 = static_cast< int >(val1);
41530 }
41531 {
41532 PyThreadState* __tstate = wxPyBeginAllowThreads();
41533 wxValidator::SetBellOnError(arg1);
41534 wxPyEndAllowThreads(__tstate);
41535 if (PyErr_Occurred()) SWIG_fail;
41536 }
41537 resultobj = SWIG_Py_Void();
41538 return resultobj;
41539 fail:
41540 return NULL;
41541 }
41542
41543
41544 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41545 PyObject *obj;
41546 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41547 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41548 return SWIG_Py_Void();
41549 }
41550
41551 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41552 return SWIG_Python_InitShadowInstance(args);
41553 }
41554
41555 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41556 PyObject *resultobj = 0;
41557 wxPyValidator *result = 0 ;
41558
41559 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41560 {
41561 PyThreadState* __tstate = wxPyBeginAllowThreads();
41562 result = (wxPyValidator *)new wxPyValidator();
41563 wxPyEndAllowThreads(__tstate);
41564 if (PyErr_Occurred()) SWIG_fail;
41565 }
41566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41567 return resultobj;
41568 fail:
41569 return NULL;
41570 }
41571
41572
41573 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41574 PyObject *resultobj = 0;
41575 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41576 PyObject *arg2 = (PyObject *) 0 ;
41577 PyObject *arg3 = (PyObject *) 0 ;
41578 int arg4 = (int) true ;
41579 void *argp1 = 0 ;
41580 int res1 = 0 ;
41581 int val4 ;
41582 int ecode4 = 0 ;
41583 PyObject * obj0 = 0 ;
41584 PyObject * obj1 = 0 ;
41585 PyObject * obj2 = 0 ;
41586 PyObject * obj3 = 0 ;
41587 char * kwnames[] = {
41588 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41589 };
41590
41591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41593 if (!SWIG_IsOK(res1)) {
41594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41595 }
41596 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41597 arg2 = obj1;
41598 arg3 = obj2;
41599 if (obj3) {
41600 ecode4 = SWIG_AsVal_int(obj3, &val4);
41601 if (!SWIG_IsOK(ecode4)) {
41602 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41603 }
41604 arg4 = static_cast< int >(val4);
41605 }
41606 {
41607 PyThreadState* __tstate = wxPyBeginAllowThreads();
41608 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41609 wxPyEndAllowThreads(__tstate);
41610 if (PyErr_Occurred()) SWIG_fail;
41611 }
41612 resultobj = SWIG_Py_Void();
41613 return resultobj;
41614 fail:
41615 return NULL;
41616 }
41617
41618
41619 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41620 PyObject *obj;
41621 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41622 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41623 return SWIG_Py_Void();
41624 }
41625
41626 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41627 return SWIG_Python_InitShadowInstance(args);
41628 }
41629
41630 SWIGINTERN int DefaultValidator_set(PyObject *) {
41631 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41632 return 1;
41633 }
41634
41635
41636 SWIGINTERN PyObject *DefaultValidator_get(void) {
41637 PyObject *pyobj = 0;
41638
41639 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41640 return pyobj;
41641 }
41642
41643
41644 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41645 PyObject *resultobj = 0;
41646 wxString const &arg1_defvalue = wxPyEmptyString ;
41647 wxString *arg1 = (wxString *) &arg1_defvalue ;
41648 long arg2 = (long) 0 ;
41649 wxMenu *result = 0 ;
41650 bool temp1 = false ;
41651 long val2 ;
41652 int ecode2 = 0 ;
41653 PyObject * obj0 = 0 ;
41654 PyObject * obj1 = 0 ;
41655 char * kwnames[] = {
41656 (char *) "title",(char *) "style", NULL
41657 };
41658
41659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41660 if (obj0) {
41661 {
41662 arg1 = wxString_in_helper(obj0);
41663 if (arg1 == NULL) SWIG_fail;
41664 temp1 = true;
41665 }
41666 }
41667 if (obj1) {
41668 ecode2 = SWIG_AsVal_long(obj1, &val2);
41669 if (!SWIG_IsOK(ecode2)) {
41670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
41671 }
41672 arg2 = static_cast< long >(val2);
41673 }
41674 {
41675 if (!wxPyCheckForApp()) SWIG_fail;
41676 PyThreadState* __tstate = wxPyBeginAllowThreads();
41677 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
41678 wxPyEndAllowThreads(__tstate);
41679 if (PyErr_Occurred()) SWIG_fail;
41680 }
41681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
41682 {
41683 if (temp1)
41684 delete arg1;
41685 }
41686 return resultobj;
41687 fail:
41688 {
41689 if (temp1)
41690 delete arg1;
41691 }
41692 return NULL;
41693 }
41694
41695
41696 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41697 PyObject *resultobj = 0;
41698 wxMenu *arg1 = (wxMenu *) 0 ;
41699 int arg2 ;
41700 wxString const &arg3_defvalue = wxPyEmptyString ;
41701 wxString *arg3 = (wxString *) &arg3_defvalue ;
41702 wxString const &arg4_defvalue = wxPyEmptyString ;
41703 wxString *arg4 = (wxString *) &arg4_defvalue ;
41704 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41705 wxMenuItem *result = 0 ;
41706 void *argp1 = 0 ;
41707 int res1 = 0 ;
41708 int val2 ;
41709 int ecode2 = 0 ;
41710 bool temp3 = false ;
41711 bool temp4 = false ;
41712 int val5 ;
41713 int ecode5 = 0 ;
41714 PyObject * obj0 = 0 ;
41715 PyObject * obj1 = 0 ;
41716 PyObject * obj2 = 0 ;
41717 PyObject * obj3 = 0 ;
41718 PyObject * obj4 = 0 ;
41719 char * kwnames[] = {
41720 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
41721 };
41722
41723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41725 if (!SWIG_IsOK(res1)) {
41726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
41727 }
41728 arg1 = reinterpret_cast< wxMenu * >(argp1);
41729 ecode2 = SWIG_AsVal_int(obj1, &val2);
41730 if (!SWIG_IsOK(ecode2)) {
41731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
41732 }
41733 arg2 = static_cast< int >(val2);
41734 if (obj2) {
41735 {
41736 arg3 = wxString_in_helper(obj2);
41737 if (arg3 == NULL) SWIG_fail;
41738 temp3 = true;
41739 }
41740 }
41741 if (obj3) {
41742 {
41743 arg4 = wxString_in_helper(obj3);
41744 if (arg4 == NULL) SWIG_fail;
41745 temp4 = true;
41746 }
41747 }
41748 if (obj4) {
41749 ecode5 = SWIG_AsVal_int(obj4, &val5);
41750 if (!SWIG_IsOK(ecode5)) {
41751 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
41752 }
41753 arg5 = static_cast< wxItemKind >(val5);
41754 }
41755 {
41756 PyThreadState* __tstate = wxPyBeginAllowThreads();
41757 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
41758 wxPyEndAllowThreads(__tstate);
41759 if (PyErr_Occurred()) SWIG_fail;
41760 }
41761 {
41762 resultobj = wxPyMake_wxObject(result, (bool)0);
41763 }
41764 {
41765 if (temp3)
41766 delete arg3;
41767 }
41768 {
41769 if (temp4)
41770 delete arg4;
41771 }
41772 return resultobj;
41773 fail:
41774 {
41775 if (temp3)
41776 delete arg3;
41777 }
41778 {
41779 if (temp4)
41780 delete arg4;
41781 }
41782 return NULL;
41783 }
41784
41785
41786 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41787 PyObject *resultobj = 0;
41788 wxMenu *arg1 = (wxMenu *) 0 ;
41789 wxMenuItem *result = 0 ;
41790 void *argp1 = 0 ;
41791 int res1 = 0 ;
41792 PyObject *swig_obj[1] ;
41793
41794 if (!args) SWIG_fail;
41795 swig_obj[0] = args;
41796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41797 if (!SWIG_IsOK(res1)) {
41798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
41799 }
41800 arg1 = reinterpret_cast< wxMenu * >(argp1);
41801 {
41802 PyThreadState* __tstate = wxPyBeginAllowThreads();
41803 result = (wxMenuItem *)(arg1)->AppendSeparator();
41804 wxPyEndAllowThreads(__tstate);
41805 if (PyErr_Occurred()) SWIG_fail;
41806 }
41807 {
41808 resultobj = wxPyMake_wxObject(result, (bool)0);
41809 }
41810 return resultobj;
41811 fail:
41812 return NULL;
41813 }
41814
41815
41816 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41817 PyObject *resultobj = 0;
41818 wxMenu *arg1 = (wxMenu *) 0 ;
41819 int arg2 ;
41820 wxString *arg3 = 0 ;
41821 wxString const &arg4_defvalue = wxPyEmptyString ;
41822 wxString *arg4 = (wxString *) &arg4_defvalue ;
41823 wxMenuItem *result = 0 ;
41824 void *argp1 = 0 ;
41825 int res1 = 0 ;
41826 int val2 ;
41827 int ecode2 = 0 ;
41828 bool temp3 = false ;
41829 bool temp4 = false ;
41830 PyObject * obj0 = 0 ;
41831 PyObject * obj1 = 0 ;
41832 PyObject * obj2 = 0 ;
41833 PyObject * obj3 = 0 ;
41834 char * kwnames[] = {
41835 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41836 };
41837
41838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41840 if (!SWIG_IsOK(res1)) {
41841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41842 }
41843 arg1 = reinterpret_cast< wxMenu * >(argp1);
41844 ecode2 = SWIG_AsVal_int(obj1, &val2);
41845 if (!SWIG_IsOK(ecode2)) {
41846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
41847 }
41848 arg2 = static_cast< int >(val2);
41849 {
41850 arg3 = wxString_in_helper(obj2);
41851 if (arg3 == NULL) SWIG_fail;
41852 temp3 = true;
41853 }
41854 if (obj3) {
41855 {
41856 arg4 = wxString_in_helper(obj3);
41857 if (arg4 == NULL) SWIG_fail;
41858 temp4 = true;
41859 }
41860 }
41861 {
41862 PyThreadState* __tstate = wxPyBeginAllowThreads();
41863 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41864 wxPyEndAllowThreads(__tstate);
41865 if (PyErr_Occurred()) SWIG_fail;
41866 }
41867 {
41868 resultobj = wxPyMake_wxObject(result, (bool)0);
41869 }
41870 {
41871 if (temp3)
41872 delete arg3;
41873 }
41874 {
41875 if (temp4)
41876 delete arg4;
41877 }
41878 return resultobj;
41879 fail:
41880 {
41881 if (temp3)
41882 delete arg3;
41883 }
41884 {
41885 if (temp4)
41886 delete arg4;
41887 }
41888 return NULL;
41889 }
41890
41891
41892 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41893 PyObject *resultobj = 0;
41894 wxMenu *arg1 = (wxMenu *) 0 ;
41895 int arg2 ;
41896 wxString *arg3 = 0 ;
41897 wxString const &arg4_defvalue = wxPyEmptyString ;
41898 wxString *arg4 = (wxString *) &arg4_defvalue ;
41899 wxMenuItem *result = 0 ;
41900 void *argp1 = 0 ;
41901 int res1 = 0 ;
41902 int val2 ;
41903 int ecode2 = 0 ;
41904 bool temp3 = false ;
41905 bool temp4 = false ;
41906 PyObject * obj0 = 0 ;
41907 PyObject * obj1 = 0 ;
41908 PyObject * obj2 = 0 ;
41909 PyObject * obj3 = 0 ;
41910 char * kwnames[] = {
41911 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41912 };
41913
41914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41916 if (!SWIG_IsOK(res1)) {
41917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41918 }
41919 arg1 = reinterpret_cast< wxMenu * >(argp1);
41920 ecode2 = SWIG_AsVal_int(obj1, &val2);
41921 if (!SWIG_IsOK(ecode2)) {
41922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
41923 }
41924 arg2 = static_cast< int >(val2);
41925 {
41926 arg3 = wxString_in_helper(obj2);
41927 if (arg3 == NULL) SWIG_fail;
41928 temp3 = true;
41929 }
41930 if (obj3) {
41931 {
41932 arg4 = wxString_in_helper(obj3);
41933 if (arg4 == NULL) SWIG_fail;
41934 temp4 = true;
41935 }
41936 }
41937 {
41938 PyThreadState* __tstate = wxPyBeginAllowThreads();
41939 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41940 wxPyEndAllowThreads(__tstate);
41941 if (PyErr_Occurred()) SWIG_fail;
41942 }
41943 {
41944 resultobj = wxPyMake_wxObject(result, (bool)0);
41945 }
41946 {
41947 if (temp3)
41948 delete arg3;
41949 }
41950 {
41951 if (temp4)
41952 delete arg4;
41953 }
41954 return resultobj;
41955 fail:
41956 {
41957 if (temp3)
41958 delete arg3;
41959 }
41960 {
41961 if (temp4)
41962 delete arg4;
41963 }
41964 return NULL;
41965 }
41966
41967
41968 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41969 PyObject *resultobj = 0;
41970 wxMenu *arg1 = (wxMenu *) 0 ;
41971 int arg2 ;
41972 wxString *arg3 = 0 ;
41973 wxMenu *arg4 = (wxMenu *) 0 ;
41974 wxString const &arg5_defvalue = wxPyEmptyString ;
41975 wxString *arg5 = (wxString *) &arg5_defvalue ;
41976 wxMenuItem *result = 0 ;
41977 void *argp1 = 0 ;
41978 int res1 = 0 ;
41979 int val2 ;
41980 int ecode2 = 0 ;
41981 bool temp3 = false ;
41982 void *argp4 = 0 ;
41983 int res4 = 0 ;
41984 bool temp5 = false ;
41985 PyObject * obj0 = 0 ;
41986 PyObject * obj1 = 0 ;
41987 PyObject * obj2 = 0 ;
41988 PyObject * obj3 = 0 ;
41989 PyObject * obj4 = 0 ;
41990 char * kwnames[] = {
41991 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
41992 };
41993
41994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41996 if (!SWIG_IsOK(res1)) {
41997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
41998 }
41999 arg1 = reinterpret_cast< wxMenu * >(argp1);
42000 ecode2 = SWIG_AsVal_int(obj1, &val2);
42001 if (!SWIG_IsOK(ecode2)) {
42002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42003 }
42004 arg2 = static_cast< int >(val2);
42005 {
42006 arg3 = wxString_in_helper(obj2);
42007 if (arg3 == NULL) SWIG_fail;
42008 temp3 = true;
42009 }
42010 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42011 if (!SWIG_IsOK(res4)) {
42012 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42013 }
42014 arg4 = reinterpret_cast< wxMenu * >(argp4);
42015 if (obj4) {
42016 {
42017 arg5 = wxString_in_helper(obj4);
42018 if (arg5 == NULL) SWIG_fail;
42019 temp5 = true;
42020 }
42021 }
42022 {
42023 PyThreadState* __tstate = wxPyBeginAllowThreads();
42024 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42025 wxPyEndAllowThreads(__tstate);
42026 if (PyErr_Occurred()) SWIG_fail;
42027 }
42028 {
42029 resultobj = wxPyMake_wxObject(result, (bool)0);
42030 }
42031 {
42032 if (temp3)
42033 delete arg3;
42034 }
42035 {
42036 if (temp5)
42037 delete arg5;
42038 }
42039 return resultobj;
42040 fail:
42041 {
42042 if (temp3)
42043 delete arg3;
42044 }
42045 {
42046 if (temp5)
42047 delete arg5;
42048 }
42049 return NULL;
42050 }
42051
42052
42053 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42054 PyObject *resultobj = 0;
42055 wxMenu *arg1 = (wxMenu *) 0 ;
42056 wxMenu *arg2 = (wxMenu *) 0 ;
42057 wxString *arg3 = 0 ;
42058 wxString const &arg4_defvalue = wxPyEmptyString ;
42059 wxString *arg4 = (wxString *) &arg4_defvalue ;
42060 wxMenuItem *result = 0 ;
42061 void *argp1 = 0 ;
42062 int res1 = 0 ;
42063 void *argp2 = 0 ;
42064 int res2 = 0 ;
42065 bool temp3 = false ;
42066 bool temp4 = false ;
42067 PyObject * obj0 = 0 ;
42068 PyObject * obj1 = 0 ;
42069 PyObject * obj2 = 0 ;
42070 PyObject * obj3 = 0 ;
42071 char * kwnames[] = {
42072 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42073 };
42074
42075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42077 if (!SWIG_IsOK(res1)) {
42078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42079 }
42080 arg1 = reinterpret_cast< wxMenu * >(argp1);
42081 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42082 if (!SWIG_IsOK(res2)) {
42083 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42084 }
42085 arg2 = reinterpret_cast< wxMenu * >(argp2);
42086 {
42087 arg3 = wxString_in_helper(obj2);
42088 if (arg3 == NULL) SWIG_fail;
42089 temp3 = true;
42090 }
42091 if (obj3) {
42092 {
42093 arg4 = wxString_in_helper(obj3);
42094 if (arg4 == NULL) SWIG_fail;
42095 temp4 = true;
42096 }
42097 }
42098 {
42099 PyThreadState* __tstate = wxPyBeginAllowThreads();
42100 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42101 wxPyEndAllowThreads(__tstate);
42102 if (PyErr_Occurred()) SWIG_fail;
42103 }
42104 {
42105 resultobj = wxPyMake_wxObject(result, (bool)0);
42106 }
42107 {
42108 if (temp3)
42109 delete arg3;
42110 }
42111 {
42112 if (temp4)
42113 delete arg4;
42114 }
42115 return resultobj;
42116 fail:
42117 {
42118 if (temp3)
42119 delete arg3;
42120 }
42121 {
42122 if (temp4)
42123 delete arg4;
42124 }
42125 return NULL;
42126 }
42127
42128
42129 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42130 PyObject *resultobj = 0;
42131 wxMenu *arg1 = (wxMenu *) 0 ;
42132 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42133 wxMenuItem *result = 0 ;
42134 void *argp1 = 0 ;
42135 int res1 = 0 ;
42136 int res2 = 0 ;
42137 PyObject * obj0 = 0 ;
42138 PyObject * obj1 = 0 ;
42139 char * kwnames[] = {
42140 (char *) "self",(char *) "item", NULL
42141 };
42142
42143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42145 if (!SWIG_IsOK(res1)) {
42146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42147 }
42148 arg1 = reinterpret_cast< wxMenu * >(argp1);
42149 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42150 if (!SWIG_IsOK(res2)) {
42151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42152 }
42153 {
42154 PyThreadState* __tstate = wxPyBeginAllowThreads();
42155 result = (wxMenuItem *)(arg1)->Append(arg2);
42156 wxPyEndAllowThreads(__tstate);
42157 if (PyErr_Occurred()) SWIG_fail;
42158 }
42159 {
42160 resultobj = wxPyMake_wxObject(result, (bool)0);
42161 }
42162 return resultobj;
42163 fail:
42164 return NULL;
42165 }
42166
42167
42168 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42169 PyObject *resultobj = 0;
42170 wxMenu *arg1 = (wxMenu *) 0 ;
42171 size_t arg2 ;
42172 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42173 wxMenuItem *result = 0 ;
42174 void *argp1 = 0 ;
42175 int res1 = 0 ;
42176 size_t val2 ;
42177 int ecode2 = 0 ;
42178 int res3 = 0 ;
42179 PyObject * obj0 = 0 ;
42180 PyObject * obj1 = 0 ;
42181 PyObject * obj2 = 0 ;
42182 char * kwnames[] = {
42183 (char *) "self",(char *) "pos",(char *) "item", NULL
42184 };
42185
42186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42188 if (!SWIG_IsOK(res1)) {
42189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42190 }
42191 arg1 = reinterpret_cast< wxMenu * >(argp1);
42192 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42193 if (!SWIG_IsOK(ecode2)) {
42194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42195 }
42196 arg2 = static_cast< size_t >(val2);
42197 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42198 if (!SWIG_IsOK(res3)) {
42199 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42200 }
42201 {
42202 PyThreadState* __tstate = wxPyBeginAllowThreads();
42203 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
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_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42217 PyObject *resultobj = 0;
42218 wxMenu *arg1 = (wxMenu *) 0 ;
42219 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42220 wxMenuItem *result = 0 ;
42221 void *argp1 = 0 ;
42222 int res1 = 0 ;
42223 int res2 = 0 ;
42224 PyObject * obj0 = 0 ;
42225 PyObject * obj1 = 0 ;
42226 char * kwnames[] = {
42227 (char *) "self",(char *) "item", NULL
42228 };
42229
42230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42232 if (!SWIG_IsOK(res1)) {
42233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42234 }
42235 arg1 = reinterpret_cast< wxMenu * >(argp1);
42236 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42237 if (!SWIG_IsOK(res2)) {
42238 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42239 }
42240 {
42241 PyThreadState* __tstate = wxPyBeginAllowThreads();
42242 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42243 wxPyEndAllowThreads(__tstate);
42244 if (PyErr_Occurred()) SWIG_fail;
42245 }
42246 {
42247 resultobj = wxPyMake_wxObject(result, (bool)0);
42248 }
42249 return resultobj;
42250 fail:
42251 return NULL;
42252 }
42253
42254
42255 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42256 PyObject *resultobj = 0;
42257 wxMenu *arg1 = (wxMenu *) 0 ;
42258 void *argp1 = 0 ;
42259 int res1 = 0 ;
42260 PyObject *swig_obj[1] ;
42261
42262 if (!args) SWIG_fail;
42263 swig_obj[0] = args;
42264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42265 if (!SWIG_IsOK(res1)) {
42266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42267 }
42268 arg1 = reinterpret_cast< wxMenu * >(argp1);
42269 {
42270 PyThreadState* __tstate = wxPyBeginAllowThreads();
42271 (arg1)->Break();
42272 wxPyEndAllowThreads(__tstate);
42273 if (PyErr_Occurred()) SWIG_fail;
42274 }
42275 resultobj = SWIG_Py_Void();
42276 return resultobj;
42277 fail:
42278 return NULL;
42279 }
42280
42281
42282 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42283 PyObject *resultobj = 0;
42284 wxMenu *arg1 = (wxMenu *) 0 ;
42285 size_t arg2 ;
42286 int arg3 ;
42287 wxString const &arg4_defvalue = wxPyEmptyString ;
42288 wxString *arg4 = (wxString *) &arg4_defvalue ;
42289 wxString const &arg5_defvalue = wxPyEmptyString ;
42290 wxString *arg5 = (wxString *) &arg5_defvalue ;
42291 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42292 wxMenuItem *result = 0 ;
42293 void *argp1 = 0 ;
42294 int res1 = 0 ;
42295 size_t val2 ;
42296 int ecode2 = 0 ;
42297 int val3 ;
42298 int ecode3 = 0 ;
42299 bool temp4 = false ;
42300 bool temp5 = false ;
42301 int val6 ;
42302 int ecode6 = 0 ;
42303 PyObject * obj0 = 0 ;
42304 PyObject * obj1 = 0 ;
42305 PyObject * obj2 = 0 ;
42306 PyObject * obj3 = 0 ;
42307 PyObject * obj4 = 0 ;
42308 PyObject * obj5 = 0 ;
42309 char * kwnames[] = {
42310 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42311 };
42312
42313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42315 if (!SWIG_IsOK(res1)) {
42316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42317 }
42318 arg1 = reinterpret_cast< wxMenu * >(argp1);
42319 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42320 if (!SWIG_IsOK(ecode2)) {
42321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42322 }
42323 arg2 = static_cast< size_t >(val2);
42324 ecode3 = SWIG_AsVal_int(obj2, &val3);
42325 if (!SWIG_IsOK(ecode3)) {
42326 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42327 }
42328 arg3 = static_cast< int >(val3);
42329 if (obj3) {
42330 {
42331 arg4 = wxString_in_helper(obj3);
42332 if (arg4 == NULL) SWIG_fail;
42333 temp4 = true;
42334 }
42335 }
42336 if (obj4) {
42337 {
42338 arg5 = wxString_in_helper(obj4);
42339 if (arg5 == NULL) SWIG_fail;
42340 temp5 = true;
42341 }
42342 }
42343 if (obj5) {
42344 ecode6 = SWIG_AsVal_int(obj5, &val6);
42345 if (!SWIG_IsOK(ecode6)) {
42346 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42347 }
42348 arg6 = static_cast< wxItemKind >(val6);
42349 }
42350 {
42351 PyThreadState* __tstate = wxPyBeginAllowThreads();
42352 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42353 wxPyEndAllowThreads(__tstate);
42354 if (PyErr_Occurred()) SWIG_fail;
42355 }
42356 {
42357 resultobj = wxPyMake_wxObject(result, (bool)0);
42358 }
42359 {
42360 if (temp4)
42361 delete arg4;
42362 }
42363 {
42364 if (temp5)
42365 delete arg5;
42366 }
42367 return resultobj;
42368 fail:
42369 {
42370 if (temp4)
42371 delete arg4;
42372 }
42373 {
42374 if (temp5)
42375 delete arg5;
42376 }
42377 return NULL;
42378 }
42379
42380
42381 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42382 PyObject *resultobj = 0;
42383 wxMenu *arg1 = (wxMenu *) 0 ;
42384 size_t arg2 ;
42385 wxMenuItem *result = 0 ;
42386 void *argp1 = 0 ;
42387 int res1 = 0 ;
42388 size_t val2 ;
42389 int ecode2 = 0 ;
42390 PyObject * obj0 = 0 ;
42391 PyObject * obj1 = 0 ;
42392 char * kwnames[] = {
42393 (char *) "self",(char *) "pos", NULL
42394 };
42395
42396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42398 if (!SWIG_IsOK(res1)) {
42399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42400 }
42401 arg1 = reinterpret_cast< wxMenu * >(argp1);
42402 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42403 if (!SWIG_IsOK(ecode2)) {
42404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42405 }
42406 arg2 = static_cast< size_t >(val2);
42407 {
42408 PyThreadState* __tstate = wxPyBeginAllowThreads();
42409 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42410 wxPyEndAllowThreads(__tstate);
42411 if (PyErr_Occurred()) SWIG_fail;
42412 }
42413 {
42414 resultobj = wxPyMake_wxObject(result, (bool)0);
42415 }
42416 return resultobj;
42417 fail:
42418 return NULL;
42419 }
42420
42421
42422 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42423 PyObject *resultobj = 0;
42424 wxMenu *arg1 = (wxMenu *) 0 ;
42425 size_t arg2 ;
42426 int arg3 ;
42427 wxString *arg4 = 0 ;
42428 wxString const &arg5_defvalue = wxPyEmptyString ;
42429 wxString *arg5 = (wxString *) &arg5_defvalue ;
42430 wxMenuItem *result = 0 ;
42431 void *argp1 = 0 ;
42432 int res1 = 0 ;
42433 size_t val2 ;
42434 int ecode2 = 0 ;
42435 int val3 ;
42436 int ecode3 = 0 ;
42437 bool temp4 = false ;
42438 bool temp5 = false ;
42439 PyObject * obj0 = 0 ;
42440 PyObject * obj1 = 0 ;
42441 PyObject * obj2 = 0 ;
42442 PyObject * obj3 = 0 ;
42443 PyObject * obj4 = 0 ;
42444 char * kwnames[] = {
42445 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42446 };
42447
42448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42450 if (!SWIG_IsOK(res1)) {
42451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42452 }
42453 arg1 = reinterpret_cast< wxMenu * >(argp1);
42454 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42455 if (!SWIG_IsOK(ecode2)) {
42456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42457 }
42458 arg2 = static_cast< size_t >(val2);
42459 ecode3 = SWIG_AsVal_int(obj2, &val3);
42460 if (!SWIG_IsOK(ecode3)) {
42461 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42462 }
42463 arg3 = static_cast< int >(val3);
42464 {
42465 arg4 = wxString_in_helper(obj3);
42466 if (arg4 == NULL) SWIG_fail;
42467 temp4 = true;
42468 }
42469 if (obj4) {
42470 {
42471 arg5 = wxString_in_helper(obj4);
42472 if (arg5 == NULL) SWIG_fail;
42473 temp5 = true;
42474 }
42475 }
42476 {
42477 PyThreadState* __tstate = wxPyBeginAllowThreads();
42478 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42479 wxPyEndAllowThreads(__tstate);
42480 if (PyErr_Occurred()) SWIG_fail;
42481 }
42482 {
42483 resultobj = wxPyMake_wxObject(result, (bool)0);
42484 }
42485 {
42486 if (temp4)
42487 delete arg4;
42488 }
42489 {
42490 if (temp5)
42491 delete arg5;
42492 }
42493 return resultobj;
42494 fail:
42495 {
42496 if (temp4)
42497 delete arg4;
42498 }
42499 {
42500 if (temp5)
42501 delete arg5;
42502 }
42503 return NULL;
42504 }
42505
42506
42507 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42508 PyObject *resultobj = 0;
42509 wxMenu *arg1 = (wxMenu *) 0 ;
42510 size_t arg2 ;
42511 int arg3 ;
42512 wxString *arg4 = 0 ;
42513 wxString const &arg5_defvalue = wxPyEmptyString ;
42514 wxString *arg5 = (wxString *) &arg5_defvalue ;
42515 wxMenuItem *result = 0 ;
42516 void *argp1 = 0 ;
42517 int res1 = 0 ;
42518 size_t val2 ;
42519 int ecode2 = 0 ;
42520 int val3 ;
42521 int ecode3 = 0 ;
42522 bool temp4 = false ;
42523 bool temp5 = false ;
42524 PyObject * obj0 = 0 ;
42525 PyObject * obj1 = 0 ;
42526 PyObject * obj2 = 0 ;
42527 PyObject * obj3 = 0 ;
42528 PyObject * obj4 = 0 ;
42529 char * kwnames[] = {
42530 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42531 };
42532
42533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42535 if (!SWIG_IsOK(res1)) {
42536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42537 }
42538 arg1 = reinterpret_cast< wxMenu * >(argp1);
42539 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42540 if (!SWIG_IsOK(ecode2)) {
42541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42542 }
42543 arg2 = static_cast< size_t >(val2);
42544 ecode3 = SWIG_AsVal_int(obj2, &val3);
42545 if (!SWIG_IsOK(ecode3)) {
42546 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42547 }
42548 arg3 = static_cast< int >(val3);
42549 {
42550 arg4 = wxString_in_helper(obj3);
42551 if (arg4 == NULL) SWIG_fail;
42552 temp4 = true;
42553 }
42554 if (obj4) {
42555 {
42556 arg5 = wxString_in_helper(obj4);
42557 if (arg5 == NULL) SWIG_fail;
42558 temp5 = true;
42559 }
42560 }
42561 {
42562 PyThreadState* __tstate = wxPyBeginAllowThreads();
42563 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42564 wxPyEndAllowThreads(__tstate);
42565 if (PyErr_Occurred()) SWIG_fail;
42566 }
42567 {
42568 resultobj = wxPyMake_wxObject(result, (bool)0);
42569 }
42570 {
42571 if (temp4)
42572 delete arg4;
42573 }
42574 {
42575 if (temp5)
42576 delete arg5;
42577 }
42578 return resultobj;
42579 fail:
42580 {
42581 if (temp4)
42582 delete arg4;
42583 }
42584 {
42585 if (temp5)
42586 delete arg5;
42587 }
42588 return NULL;
42589 }
42590
42591
42592 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42593 PyObject *resultobj = 0;
42594 wxMenu *arg1 = (wxMenu *) 0 ;
42595 size_t arg2 ;
42596 int arg3 ;
42597 wxString *arg4 = 0 ;
42598 wxMenu *arg5 = (wxMenu *) 0 ;
42599 wxString const &arg6_defvalue = wxPyEmptyString ;
42600 wxString *arg6 = (wxString *) &arg6_defvalue ;
42601 wxMenuItem *result = 0 ;
42602 void *argp1 = 0 ;
42603 int res1 = 0 ;
42604 size_t val2 ;
42605 int ecode2 = 0 ;
42606 int val3 ;
42607 int ecode3 = 0 ;
42608 bool temp4 = false ;
42609 void *argp5 = 0 ;
42610 int res5 = 0 ;
42611 bool temp6 = false ;
42612 PyObject * obj0 = 0 ;
42613 PyObject * obj1 = 0 ;
42614 PyObject * obj2 = 0 ;
42615 PyObject * obj3 = 0 ;
42616 PyObject * obj4 = 0 ;
42617 PyObject * obj5 = 0 ;
42618 char * kwnames[] = {
42619 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42620 };
42621
42622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42624 if (!SWIG_IsOK(res1)) {
42625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42626 }
42627 arg1 = reinterpret_cast< wxMenu * >(argp1);
42628 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42629 if (!SWIG_IsOK(ecode2)) {
42630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42631 }
42632 arg2 = static_cast< size_t >(val2);
42633 ecode3 = SWIG_AsVal_int(obj2, &val3);
42634 if (!SWIG_IsOK(ecode3)) {
42635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42636 }
42637 arg3 = static_cast< int >(val3);
42638 {
42639 arg4 = wxString_in_helper(obj3);
42640 if (arg4 == NULL) SWIG_fail;
42641 temp4 = true;
42642 }
42643 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42644 if (!SWIG_IsOK(res5)) {
42645 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42646 }
42647 arg5 = reinterpret_cast< wxMenu * >(argp5);
42648 if (obj5) {
42649 {
42650 arg6 = wxString_in_helper(obj5);
42651 if (arg6 == NULL) SWIG_fail;
42652 temp6 = true;
42653 }
42654 }
42655 {
42656 PyThreadState* __tstate = wxPyBeginAllowThreads();
42657 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42658 wxPyEndAllowThreads(__tstate);
42659 if (PyErr_Occurred()) SWIG_fail;
42660 }
42661 {
42662 resultobj = wxPyMake_wxObject(result, (bool)0);
42663 }
42664 {
42665 if (temp4)
42666 delete arg4;
42667 }
42668 {
42669 if (temp6)
42670 delete arg6;
42671 }
42672 return resultobj;
42673 fail:
42674 {
42675 if (temp4)
42676 delete arg4;
42677 }
42678 {
42679 if (temp6)
42680 delete arg6;
42681 }
42682 return NULL;
42683 }
42684
42685
42686 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42687 PyObject *resultobj = 0;
42688 wxMenu *arg1 = (wxMenu *) 0 ;
42689 int arg2 ;
42690 wxString const &arg3_defvalue = wxPyEmptyString ;
42691 wxString *arg3 = (wxString *) &arg3_defvalue ;
42692 wxString const &arg4_defvalue = wxPyEmptyString ;
42693 wxString *arg4 = (wxString *) &arg4_defvalue ;
42694 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42695 wxMenuItem *result = 0 ;
42696 void *argp1 = 0 ;
42697 int res1 = 0 ;
42698 int val2 ;
42699 int ecode2 = 0 ;
42700 bool temp3 = false ;
42701 bool temp4 = false ;
42702 int val5 ;
42703 int ecode5 = 0 ;
42704 PyObject * obj0 = 0 ;
42705 PyObject * obj1 = 0 ;
42706 PyObject * obj2 = 0 ;
42707 PyObject * obj3 = 0 ;
42708 PyObject * obj4 = 0 ;
42709 char * kwnames[] = {
42710 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42711 };
42712
42713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42715 if (!SWIG_IsOK(res1)) {
42716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
42717 }
42718 arg1 = reinterpret_cast< wxMenu * >(argp1);
42719 ecode2 = SWIG_AsVal_int(obj1, &val2);
42720 if (!SWIG_IsOK(ecode2)) {
42721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
42722 }
42723 arg2 = static_cast< int >(val2);
42724 if (obj2) {
42725 {
42726 arg3 = wxString_in_helper(obj2);
42727 if (arg3 == NULL) SWIG_fail;
42728 temp3 = true;
42729 }
42730 }
42731 if (obj3) {
42732 {
42733 arg4 = wxString_in_helper(obj3);
42734 if (arg4 == NULL) SWIG_fail;
42735 temp4 = true;
42736 }
42737 }
42738 if (obj4) {
42739 ecode5 = SWIG_AsVal_int(obj4, &val5);
42740 if (!SWIG_IsOK(ecode5)) {
42741 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
42742 }
42743 arg5 = static_cast< wxItemKind >(val5);
42744 }
42745 {
42746 PyThreadState* __tstate = wxPyBeginAllowThreads();
42747 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42748 wxPyEndAllowThreads(__tstate);
42749 if (PyErr_Occurred()) SWIG_fail;
42750 }
42751 {
42752 resultobj = wxPyMake_wxObject(result, (bool)0);
42753 }
42754 {
42755 if (temp3)
42756 delete arg3;
42757 }
42758 {
42759 if (temp4)
42760 delete arg4;
42761 }
42762 return resultobj;
42763 fail:
42764 {
42765 if (temp3)
42766 delete arg3;
42767 }
42768 {
42769 if (temp4)
42770 delete arg4;
42771 }
42772 return NULL;
42773 }
42774
42775
42776 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42777 PyObject *resultobj = 0;
42778 wxMenu *arg1 = (wxMenu *) 0 ;
42779 wxMenuItem *result = 0 ;
42780 void *argp1 = 0 ;
42781 int res1 = 0 ;
42782 PyObject *swig_obj[1] ;
42783
42784 if (!args) SWIG_fail;
42785 swig_obj[0] = args;
42786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42787 if (!SWIG_IsOK(res1)) {
42788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42789 }
42790 arg1 = reinterpret_cast< wxMenu * >(argp1);
42791 {
42792 PyThreadState* __tstate = wxPyBeginAllowThreads();
42793 result = (wxMenuItem *)(arg1)->PrependSeparator();
42794 wxPyEndAllowThreads(__tstate);
42795 if (PyErr_Occurred()) SWIG_fail;
42796 }
42797 {
42798 resultobj = wxPyMake_wxObject(result, (bool)0);
42799 }
42800 return resultobj;
42801 fail:
42802 return NULL;
42803 }
42804
42805
42806 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42807 PyObject *resultobj = 0;
42808 wxMenu *arg1 = (wxMenu *) 0 ;
42809 int arg2 ;
42810 wxString *arg3 = 0 ;
42811 wxString const &arg4_defvalue = wxPyEmptyString ;
42812 wxString *arg4 = (wxString *) &arg4_defvalue ;
42813 wxMenuItem *result = 0 ;
42814 void *argp1 = 0 ;
42815 int res1 = 0 ;
42816 int val2 ;
42817 int ecode2 = 0 ;
42818 bool temp3 = false ;
42819 bool temp4 = false ;
42820 PyObject * obj0 = 0 ;
42821 PyObject * obj1 = 0 ;
42822 PyObject * obj2 = 0 ;
42823 PyObject * obj3 = 0 ;
42824 char * kwnames[] = {
42825 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42826 };
42827
42828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42830 if (!SWIG_IsOK(res1)) {
42831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42832 }
42833 arg1 = reinterpret_cast< wxMenu * >(argp1);
42834 ecode2 = SWIG_AsVal_int(obj1, &val2);
42835 if (!SWIG_IsOK(ecode2)) {
42836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
42837 }
42838 arg2 = static_cast< int >(val2);
42839 {
42840 arg3 = wxString_in_helper(obj2);
42841 if (arg3 == NULL) SWIG_fail;
42842 temp3 = true;
42843 }
42844 if (obj3) {
42845 {
42846 arg4 = wxString_in_helper(obj3);
42847 if (arg4 == NULL) SWIG_fail;
42848 temp4 = true;
42849 }
42850 }
42851 {
42852 PyThreadState* __tstate = wxPyBeginAllowThreads();
42853 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42854 wxPyEndAllowThreads(__tstate);
42855 if (PyErr_Occurred()) SWIG_fail;
42856 }
42857 {
42858 resultobj = wxPyMake_wxObject(result, (bool)0);
42859 }
42860 {
42861 if (temp3)
42862 delete arg3;
42863 }
42864 {
42865 if (temp4)
42866 delete arg4;
42867 }
42868 return resultobj;
42869 fail:
42870 {
42871 if (temp3)
42872 delete arg3;
42873 }
42874 {
42875 if (temp4)
42876 delete arg4;
42877 }
42878 return NULL;
42879 }
42880
42881
42882 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42883 PyObject *resultobj = 0;
42884 wxMenu *arg1 = (wxMenu *) 0 ;
42885 int arg2 ;
42886 wxString *arg3 = 0 ;
42887 wxString const &arg4_defvalue = wxPyEmptyString ;
42888 wxString *arg4 = (wxString *) &arg4_defvalue ;
42889 wxMenuItem *result = 0 ;
42890 void *argp1 = 0 ;
42891 int res1 = 0 ;
42892 int val2 ;
42893 int ecode2 = 0 ;
42894 bool temp3 = false ;
42895 bool temp4 = false ;
42896 PyObject * obj0 = 0 ;
42897 PyObject * obj1 = 0 ;
42898 PyObject * obj2 = 0 ;
42899 PyObject * obj3 = 0 ;
42900 char * kwnames[] = {
42901 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42902 };
42903
42904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42906 if (!SWIG_IsOK(res1)) {
42907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42908 }
42909 arg1 = reinterpret_cast< wxMenu * >(argp1);
42910 ecode2 = SWIG_AsVal_int(obj1, &val2);
42911 if (!SWIG_IsOK(ecode2)) {
42912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
42913 }
42914 arg2 = static_cast< int >(val2);
42915 {
42916 arg3 = wxString_in_helper(obj2);
42917 if (arg3 == NULL) SWIG_fail;
42918 temp3 = true;
42919 }
42920 if (obj3) {
42921 {
42922 arg4 = wxString_in_helper(obj3);
42923 if (arg4 == NULL) SWIG_fail;
42924 temp4 = true;
42925 }
42926 }
42927 {
42928 PyThreadState* __tstate = wxPyBeginAllowThreads();
42929 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42930 wxPyEndAllowThreads(__tstate);
42931 if (PyErr_Occurred()) SWIG_fail;
42932 }
42933 {
42934 resultobj = wxPyMake_wxObject(result, (bool)0);
42935 }
42936 {
42937 if (temp3)
42938 delete arg3;
42939 }
42940 {
42941 if (temp4)
42942 delete arg4;
42943 }
42944 return resultobj;
42945 fail:
42946 {
42947 if (temp3)
42948 delete arg3;
42949 }
42950 {
42951 if (temp4)
42952 delete arg4;
42953 }
42954 return NULL;
42955 }
42956
42957
42958 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42959 PyObject *resultobj = 0;
42960 wxMenu *arg1 = (wxMenu *) 0 ;
42961 int arg2 ;
42962 wxString *arg3 = 0 ;
42963 wxMenu *arg4 = (wxMenu *) 0 ;
42964 wxString const &arg5_defvalue = wxPyEmptyString ;
42965 wxString *arg5 = (wxString *) &arg5_defvalue ;
42966 wxMenuItem *result = 0 ;
42967 void *argp1 = 0 ;
42968 int res1 = 0 ;
42969 int val2 ;
42970 int ecode2 = 0 ;
42971 bool temp3 = false ;
42972 void *argp4 = 0 ;
42973 int res4 = 0 ;
42974 bool temp5 = false ;
42975 PyObject * obj0 = 0 ;
42976 PyObject * obj1 = 0 ;
42977 PyObject * obj2 = 0 ;
42978 PyObject * obj3 = 0 ;
42979 PyObject * obj4 = 0 ;
42980 char * kwnames[] = {
42981 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42982 };
42983
42984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42986 if (!SWIG_IsOK(res1)) {
42987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42988 }
42989 arg1 = reinterpret_cast< wxMenu * >(argp1);
42990 ecode2 = SWIG_AsVal_int(obj1, &val2);
42991 if (!SWIG_IsOK(ecode2)) {
42992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
42993 }
42994 arg2 = static_cast< int >(val2);
42995 {
42996 arg3 = wxString_in_helper(obj2);
42997 if (arg3 == NULL) SWIG_fail;
42998 temp3 = true;
42999 }
43000 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43001 if (!SWIG_IsOK(res4)) {
43002 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43003 }
43004 arg4 = reinterpret_cast< wxMenu * >(argp4);
43005 if (obj4) {
43006 {
43007 arg5 = wxString_in_helper(obj4);
43008 if (arg5 == NULL) SWIG_fail;
43009 temp5 = true;
43010 }
43011 }
43012 {
43013 PyThreadState* __tstate = wxPyBeginAllowThreads();
43014 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43015 wxPyEndAllowThreads(__tstate);
43016 if (PyErr_Occurred()) SWIG_fail;
43017 }
43018 {
43019 resultobj = wxPyMake_wxObject(result, (bool)0);
43020 }
43021 {
43022 if (temp3)
43023 delete arg3;
43024 }
43025 {
43026 if (temp5)
43027 delete arg5;
43028 }
43029 return resultobj;
43030 fail:
43031 {
43032 if (temp3)
43033 delete arg3;
43034 }
43035 {
43036 if (temp5)
43037 delete arg5;
43038 }
43039 return NULL;
43040 }
43041
43042
43043 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43044 PyObject *resultobj = 0;
43045 wxMenu *arg1 = (wxMenu *) 0 ;
43046 int arg2 ;
43047 wxMenuItem *result = 0 ;
43048 void *argp1 = 0 ;
43049 int res1 = 0 ;
43050 int val2 ;
43051 int ecode2 = 0 ;
43052 PyObject * obj0 = 0 ;
43053 PyObject * obj1 = 0 ;
43054 char * kwnames[] = {
43055 (char *) "self",(char *) "id", NULL
43056 };
43057
43058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43060 if (!SWIG_IsOK(res1)) {
43061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43062 }
43063 arg1 = reinterpret_cast< wxMenu * >(argp1);
43064 ecode2 = SWIG_AsVal_int(obj1, &val2);
43065 if (!SWIG_IsOK(ecode2)) {
43066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43067 }
43068 arg2 = static_cast< int >(val2);
43069 {
43070 PyThreadState* __tstate = wxPyBeginAllowThreads();
43071 result = (wxMenuItem *)(arg1)->Remove(arg2);
43072 wxPyEndAllowThreads(__tstate);
43073 if (PyErr_Occurred()) SWIG_fail;
43074 }
43075 {
43076 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43077 }
43078 return resultobj;
43079 fail:
43080 return NULL;
43081 }
43082
43083
43084 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43085 PyObject *resultobj = 0;
43086 wxMenu *arg1 = (wxMenu *) 0 ;
43087 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43088 wxMenuItem *result = 0 ;
43089 void *argp1 = 0 ;
43090 int res1 = 0 ;
43091 void *argp2 = 0 ;
43092 int res2 = 0 ;
43093 PyObject * obj0 = 0 ;
43094 PyObject * obj1 = 0 ;
43095 char * kwnames[] = {
43096 (char *) "self",(char *) "item", NULL
43097 };
43098
43099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43101 if (!SWIG_IsOK(res1)) {
43102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43103 }
43104 arg1 = reinterpret_cast< wxMenu * >(argp1);
43105 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43106 if (!SWIG_IsOK(res2)) {
43107 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43108 }
43109 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43110 {
43111 PyThreadState* __tstate = wxPyBeginAllowThreads();
43112 result = (wxMenuItem *)(arg1)->Remove(arg2);
43113 wxPyEndAllowThreads(__tstate);
43114 if (PyErr_Occurred()) SWIG_fail;
43115 }
43116 {
43117 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43118 }
43119 return resultobj;
43120 fail:
43121 return NULL;
43122 }
43123
43124
43125 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43126 PyObject *resultobj = 0;
43127 wxMenu *arg1 = (wxMenu *) 0 ;
43128 int arg2 ;
43129 bool result;
43130 void *argp1 = 0 ;
43131 int res1 = 0 ;
43132 int val2 ;
43133 int ecode2 = 0 ;
43134 PyObject * obj0 = 0 ;
43135 PyObject * obj1 = 0 ;
43136 char * kwnames[] = {
43137 (char *) "self",(char *) "id", NULL
43138 };
43139
43140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43142 if (!SWIG_IsOK(res1)) {
43143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43144 }
43145 arg1 = reinterpret_cast< wxMenu * >(argp1);
43146 ecode2 = SWIG_AsVal_int(obj1, &val2);
43147 if (!SWIG_IsOK(ecode2)) {
43148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43149 }
43150 arg2 = static_cast< int >(val2);
43151 {
43152 PyThreadState* __tstate = wxPyBeginAllowThreads();
43153 result = (bool)(arg1)->Delete(arg2);
43154 wxPyEndAllowThreads(__tstate);
43155 if (PyErr_Occurred()) SWIG_fail;
43156 }
43157 {
43158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43159 }
43160 return resultobj;
43161 fail:
43162 return NULL;
43163 }
43164
43165
43166 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43167 PyObject *resultobj = 0;
43168 wxMenu *arg1 = (wxMenu *) 0 ;
43169 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43170 bool result;
43171 void *argp1 = 0 ;
43172 int res1 = 0 ;
43173 void *argp2 = 0 ;
43174 int res2 = 0 ;
43175 PyObject * obj0 = 0 ;
43176 PyObject * obj1 = 0 ;
43177 char * kwnames[] = {
43178 (char *) "self",(char *) "item", NULL
43179 };
43180
43181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43183 if (!SWIG_IsOK(res1)) {
43184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43185 }
43186 arg1 = reinterpret_cast< wxMenu * >(argp1);
43187 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43188 if (!SWIG_IsOK(res2)) {
43189 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43190 }
43191 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43192 {
43193 PyThreadState* __tstate = wxPyBeginAllowThreads();
43194 result = (bool)(arg1)->Delete(arg2);
43195 wxPyEndAllowThreads(__tstate);
43196 if (PyErr_Occurred()) SWIG_fail;
43197 }
43198 {
43199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43200 }
43201 return resultobj;
43202 fail:
43203 return NULL;
43204 }
43205
43206
43207 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43208 PyObject *resultobj = 0;
43209 wxMenu *arg1 = (wxMenu *) 0 ;
43210 void *argp1 = 0 ;
43211 int res1 = 0 ;
43212 PyObject *swig_obj[1] ;
43213
43214 if (!args) SWIG_fail;
43215 swig_obj[0] = args;
43216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43217 if (!SWIG_IsOK(res1)) {
43218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43219 }
43220 arg1 = reinterpret_cast< wxMenu * >(argp1);
43221 {
43222 PyThreadState* __tstate = wxPyBeginAllowThreads();
43223 wxMenu_Destroy(arg1);
43224 wxPyEndAllowThreads(__tstate);
43225 if (PyErr_Occurred()) SWIG_fail;
43226 }
43227 resultobj = SWIG_Py_Void();
43228 return resultobj;
43229 fail:
43230 return NULL;
43231 }
43232
43233
43234 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43235 PyObject *resultobj = 0;
43236 wxMenu *arg1 = (wxMenu *) 0 ;
43237 int arg2 ;
43238 bool result;
43239 void *argp1 = 0 ;
43240 int res1 = 0 ;
43241 int val2 ;
43242 int ecode2 = 0 ;
43243 PyObject * obj0 = 0 ;
43244 PyObject * obj1 = 0 ;
43245 char * kwnames[] = {
43246 (char *) "self",(char *) "id", NULL
43247 };
43248
43249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43251 if (!SWIG_IsOK(res1)) {
43252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43253 }
43254 arg1 = reinterpret_cast< wxMenu * >(argp1);
43255 ecode2 = SWIG_AsVal_int(obj1, &val2);
43256 if (!SWIG_IsOK(ecode2)) {
43257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43258 }
43259 arg2 = static_cast< int >(val2);
43260 {
43261 PyThreadState* __tstate = wxPyBeginAllowThreads();
43262 result = (bool)(arg1)->Destroy(arg2);
43263 wxPyEndAllowThreads(__tstate);
43264 if (PyErr_Occurred()) SWIG_fail;
43265 }
43266 {
43267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43268 }
43269 return resultobj;
43270 fail:
43271 return NULL;
43272 }
43273
43274
43275 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43276 PyObject *resultobj = 0;
43277 wxMenu *arg1 = (wxMenu *) 0 ;
43278 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43279 bool result;
43280 void *argp1 = 0 ;
43281 int res1 = 0 ;
43282 void *argp2 = 0 ;
43283 int res2 = 0 ;
43284 PyObject * obj0 = 0 ;
43285 PyObject * obj1 = 0 ;
43286 char * kwnames[] = {
43287 (char *) "self",(char *) "item", NULL
43288 };
43289
43290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43292 if (!SWIG_IsOK(res1)) {
43293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43294 }
43295 arg1 = reinterpret_cast< wxMenu * >(argp1);
43296 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43297 if (!SWIG_IsOK(res2)) {
43298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43299 }
43300 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43301 {
43302 PyThreadState* __tstate = wxPyBeginAllowThreads();
43303 result = (bool)(arg1)->Destroy(arg2);
43304 wxPyEndAllowThreads(__tstate);
43305 if (PyErr_Occurred()) SWIG_fail;
43306 }
43307 {
43308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43309 }
43310 return resultobj;
43311 fail:
43312 return NULL;
43313 }
43314
43315
43316 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43317 PyObject *resultobj = 0;
43318 wxMenu *arg1 = (wxMenu *) 0 ;
43319 size_t result;
43320 void *argp1 = 0 ;
43321 int res1 = 0 ;
43322 PyObject *swig_obj[1] ;
43323
43324 if (!args) SWIG_fail;
43325 swig_obj[0] = args;
43326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43327 if (!SWIG_IsOK(res1)) {
43328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43329 }
43330 arg1 = reinterpret_cast< wxMenu * >(argp1);
43331 {
43332 PyThreadState* __tstate = wxPyBeginAllowThreads();
43333 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43334 wxPyEndAllowThreads(__tstate);
43335 if (PyErr_Occurred()) SWIG_fail;
43336 }
43337 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43338 return resultobj;
43339 fail:
43340 return NULL;
43341 }
43342
43343
43344 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43345 PyObject *resultobj = 0;
43346 wxMenu *arg1 = (wxMenu *) 0 ;
43347 PyObject *result = 0 ;
43348 void *argp1 = 0 ;
43349 int res1 = 0 ;
43350 PyObject *swig_obj[1] ;
43351
43352 if (!args) SWIG_fail;
43353 swig_obj[0] = args;
43354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43355 if (!SWIG_IsOK(res1)) {
43356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43357 }
43358 arg1 = reinterpret_cast< wxMenu * >(argp1);
43359 {
43360 PyThreadState* __tstate = wxPyBeginAllowThreads();
43361 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43362 wxPyEndAllowThreads(__tstate);
43363 if (PyErr_Occurred()) SWIG_fail;
43364 }
43365 resultobj = result;
43366 return resultobj;
43367 fail:
43368 return NULL;
43369 }
43370
43371
43372 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43373 PyObject *resultobj = 0;
43374 wxMenu *arg1 = (wxMenu *) 0 ;
43375 wxString *arg2 = 0 ;
43376 int result;
43377 void *argp1 = 0 ;
43378 int res1 = 0 ;
43379 bool temp2 = false ;
43380 PyObject * obj0 = 0 ;
43381 PyObject * obj1 = 0 ;
43382 char * kwnames[] = {
43383 (char *) "self",(char *) "item", NULL
43384 };
43385
43386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43388 if (!SWIG_IsOK(res1)) {
43389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43390 }
43391 arg1 = reinterpret_cast< wxMenu * >(argp1);
43392 {
43393 arg2 = wxString_in_helper(obj1);
43394 if (arg2 == NULL) SWIG_fail;
43395 temp2 = true;
43396 }
43397 {
43398 PyThreadState* __tstate = wxPyBeginAllowThreads();
43399 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43400 wxPyEndAllowThreads(__tstate);
43401 if (PyErr_Occurred()) SWIG_fail;
43402 }
43403 resultobj = SWIG_From_int(static_cast< int >(result));
43404 {
43405 if (temp2)
43406 delete arg2;
43407 }
43408 return resultobj;
43409 fail:
43410 {
43411 if (temp2)
43412 delete arg2;
43413 }
43414 return NULL;
43415 }
43416
43417
43418 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43419 PyObject *resultobj = 0;
43420 wxMenu *arg1 = (wxMenu *) 0 ;
43421 int arg2 ;
43422 wxMenuItem *result = 0 ;
43423 void *argp1 = 0 ;
43424 int res1 = 0 ;
43425 int val2 ;
43426 int ecode2 = 0 ;
43427 PyObject * obj0 = 0 ;
43428 PyObject * obj1 = 0 ;
43429 char * kwnames[] = {
43430 (char *) "self",(char *) "id", NULL
43431 };
43432
43433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43435 if (!SWIG_IsOK(res1)) {
43436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43437 }
43438 arg1 = reinterpret_cast< wxMenu * >(argp1);
43439 ecode2 = SWIG_AsVal_int(obj1, &val2);
43440 if (!SWIG_IsOK(ecode2)) {
43441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43442 }
43443 arg2 = static_cast< int >(val2);
43444 {
43445 PyThreadState* __tstate = wxPyBeginAllowThreads();
43446 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43447 wxPyEndAllowThreads(__tstate);
43448 if (PyErr_Occurred()) SWIG_fail;
43449 }
43450 {
43451 resultobj = wxPyMake_wxObject(result, (bool)0);
43452 }
43453 return resultobj;
43454 fail:
43455 return NULL;
43456 }
43457
43458
43459 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43460 PyObject *resultobj = 0;
43461 wxMenu *arg1 = (wxMenu *) 0 ;
43462 size_t arg2 ;
43463 wxMenuItem *result = 0 ;
43464 void *argp1 = 0 ;
43465 int res1 = 0 ;
43466 size_t val2 ;
43467 int ecode2 = 0 ;
43468 PyObject * obj0 = 0 ;
43469 PyObject * obj1 = 0 ;
43470 char * kwnames[] = {
43471 (char *) "self",(char *) "position", NULL
43472 };
43473
43474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43476 if (!SWIG_IsOK(res1)) {
43477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43478 }
43479 arg1 = reinterpret_cast< wxMenu * >(argp1);
43480 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43481 if (!SWIG_IsOK(ecode2)) {
43482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43483 }
43484 arg2 = static_cast< size_t >(val2);
43485 {
43486 PyThreadState* __tstate = wxPyBeginAllowThreads();
43487 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43488 wxPyEndAllowThreads(__tstate);
43489 if (PyErr_Occurred()) SWIG_fail;
43490 }
43491 {
43492 resultobj = wxPyMake_wxObject(result, (bool)0);
43493 }
43494 return resultobj;
43495 fail:
43496 return NULL;
43497 }
43498
43499
43500 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43501 PyObject *resultobj = 0;
43502 wxMenu *arg1 = (wxMenu *) 0 ;
43503 int arg2 ;
43504 bool arg3 ;
43505 void *argp1 = 0 ;
43506 int res1 = 0 ;
43507 int val2 ;
43508 int ecode2 = 0 ;
43509 bool val3 ;
43510 int ecode3 = 0 ;
43511 PyObject * obj0 = 0 ;
43512 PyObject * obj1 = 0 ;
43513 PyObject * obj2 = 0 ;
43514 char * kwnames[] = {
43515 (char *) "self",(char *) "id",(char *) "enable", NULL
43516 };
43517
43518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43520 if (!SWIG_IsOK(res1)) {
43521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43522 }
43523 arg1 = reinterpret_cast< wxMenu * >(argp1);
43524 ecode2 = SWIG_AsVal_int(obj1, &val2);
43525 if (!SWIG_IsOK(ecode2)) {
43526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43527 }
43528 arg2 = static_cast< int >(val2);
43529 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43530 if (!SWIG_IsOK(ecode3)) {
43531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43532 }
43533 arg3 = static_cast< bool >(val3);
43534 {
43535 PyThreadState* __tstate = wxPyBeginAllowThreads();
43536 (arg1)->Enable(arg2,arg3);
43537 wxPyEndAllowThreads(__tstate);
43538 if (PyErr_Occurred()) SWIG_fail;
43539 }
43540 resultobj = SWIG_Py_Void();
43541 return resultobj;
43542 fail:
43543 return NULL;
43544 }
43545
43546
43547 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43548 PyObject *resultobj = 0;
43549 wxMenu *arg1 = (wxMenu *) 0 ;
43550 int arg2 ;
43551 bool result;
43552 void *argp1 = 0 ;
43553 int res1 = 0 ;
43554 int val2 ;
43555 int ecode2 = 0 ;
43556 PyObject * obj0 = 0 ;
43557 PyObject * obj1 = 0 ;
43558 char * kwnames[] = {
43559 (char *) "self",(char *) "id", NULL
43560 };
43561
43562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43564 if (!SWIG_IsOK(res1)) {
43565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43566 }
43567 arg1 = reinterpret_cast< wxMenu * >(argp1);
43568 ecode2 = SWIG_AsVal_int(obj1, &val2);
43569 if (!SWIG_IsOK(ecode2)) {
43570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43571 }
43572 arg2 = static_cast< int >(val2);
43573 {
43574 PyThreadState* __tstate = wxPyBeginAllowThreads();
43575 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43576 wxPyEndAllowThreads(__tstate);
43577 if (PyErr_Occurred()) SWIG_fail;
43578 }
43579 {
43580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43581 }
43582 return resultobj;
43583 fail:
43584 return NULL;
43585 }
43586
43587
43588 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43589 PyObject *resultobj = 0;
43590 wxMenu *arg1 = (wxMenu *) 0 ;
43591 int arg2 ;
43592 bool arg3 ;
43593 void *argp1 = 0 ;
43594 int res1 = 0 ;
43595 int val2 ;
43596 int ecode2 = 0 ;
43597 bool val3 ;
43598 int ecode3 = 0 ;
43599 PyObject * obj0 = 0 ;
43600 PyObject * obj1 = 0 ;
43601 PyObject * obj2 = 0 ;
43602 char * kwnames[] = {
43603 (char *) "self",(char *) "id",(char *) "check", NULL
43604 };
43605
43606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43608 if (!SWIG_IsOK(res1)) {
43609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43610 }
43611 arg1 = reinterpret_cast< wxMenu * >(argp1);
43612 ecode2 = SWIG_AsVal_int(obj1, &val2);
43613 if (!SWIG_IsOK(ecode2)) {
43614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43615 }
43616 arg2 = static_cast< int >(val2);
43617 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43618 if (!SWIG_IsOK(ecode3)) {
43619 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43620 }
43621 arg3 = static_cast< bool >(val3);
43622 {
43623 PyThreadState* __tstate = wxPyBeginAllowThreads();
43624 (arg1)->Check(arg2,arg3);
43625 wxPyEndAllowThreads(__tstate);
43626 if (PyErr_Occurred()) SWIG_fail;
43627 }
43628 resultobj = SWIG_Py_Void();
43629 return resultobj;
43630 fail:
43631 return NULL;
43632 }
43633
43634
43635 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43636 PyObject *resultobj = 0;
43637 wxMenu *arg1 = (wxMenu *) 0 ;
43638 int arg2 ;
43639 bool result;
43640 void *argp1 = 0 ;
43641 int res1 = 0 ;
43642 int val2 ;
43643 int ecode2 = 0 ;
43644 PyObject * obj0 = 0 ;
43645 PyObject * obj1 = 0 ;
43646 char * kwnames[] = {
43647 (char *) "self",(char *) "id", NULL
43648 };
43649
43650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43652 if (!SWIG_IsOK(res1)) {
43653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43654 }
43655 arg1 = reinterpret_cast< wxMenu * >(argp1);
43656 ecode2 = SWIG_AsVal_int(obj1, &val2);
43657 if (!SWIG_IsOK(ecode2)) {
43658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43659 }
43660 arg2 = static_cast< int >(val2);
43661 {
43662 PyThreadState* __tstate = wxPyBeginAllowThreads();
43663 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43664 wxPyEndAllowThreads(__tstate);
43665 if (PyErr_Occurred()) SWIG_fail;
43666 }
43667 {
43668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43669 }
43670 return resultobj;
43671 fail:
43672 return NULL;
43673 }
43674
43675
43676 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43677 PyObject *resultobj = 0;
43678 wxMenu *arg1 = (wxMenu *) 0 ;
43679 int arg2 ;
43680 wxString *arg3 = 0 ;
43681 void *argp1 = 0 ;
43682 int res1 = 0 ;
43683 int val2 ;
43684 int ecode2 = 0 ;
43685 bool temp3 = false ;
43686 PyObject * obj0 = 0 ;
43687 PyObject * obj1 = 0 ;
43688 PyObject * obj2 = 0 ;
43689 char * kwnames[] = {
43690 (char *) "self",(char *) "id",(char *) "label", NULL
43691 };
43692
43693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43695 if (!SWIG_IsOK(res1)) {
43696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
43697 }
43698 arg1 = reinterpret_cast< wxMenu * >(argp1);
43699 ecode2 = SWIG_AsVal_int(obj1, &val2);
43700 if (!SWIG_IsOK(ecode2)) {
43701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
43702 }
43703 arg2 = static_cast< int >(val2);
43704 {
43705 arg3 = wxString_in_helper(obj2);
43706 if (arg3 == NULL) SWIG_fail;
43707 temp3 = true;
43708 }
43709 {
43710 PyThreadState* __tstate = wxPyBeginAllowThreads();
43711 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43712 wxPyEndAllowThreads(__tstate);
43713 if (PyErr_Occurred()) SWIG_fail;
43714 }
43715 resultobj = SWIG_Py_Void();
43716 {
43717 if (temp3)
43718 delete arg3;
43719 }
43720 return resultobj;
43721 fail:
43722 {
43723 if (temp3)
43724 delete arg3;
43725 }
43726 return NULL;
43727 }
43728
43729
43730 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43731 PyObject *resultobj = 0;
43732 wxMenu *arg1 = (wxMenu *) 0 ;
43733 int arg2 ;
43734 wxString result;
43735 void *argp1 = 0 ;
43736 int res1 = 0 ;
43737 int val2 ;
43738 int ecode2 = 0 ;
43739 PyObject * obj0 = 0 ;
43740 PyObject * obj1 = 0 ;
43741 char * kwnames[] = {
43742 (char *) "self",(char *) "id", NULL
43743 };
43744
43745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43747 if (!SWIG_IsOK(res1)) {
43748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
43749 }
43750 arg1 = reinterpret_cast< wxMenu * >(argp1);
43751 ecode2 = SWIG_AsVal_int(obj1, &val2);
43752 if (!SWIG_IsOK(ecode2)) {
43753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
43754 }
43755 arg2 = static_cast< int >(val2);
43756 {
43757 PyThreadState* __tstate = wxPyBeginAllowThreads();
43758 result = ((wxMenu const *)arg1)->GetLabel(arg2);
43759 wxPyEndAllowThreads(__tstate);
43760 if (PyErr_Occurred()) SWIG_fail;
43761 }
43762 {
43763 #if wxUSE_UNICODE
43764 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43765 #else
43766 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43767 #endif
43768 }
43769 return resultobj;
43770 fail:
43771 return NULL;
43772 }
43773
43774
43775 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43776 PyObject *resultobj = 0;
43777 wxMenu *arg1 = (wxMenu *) 0 ;
43778 int arg2 ;
43779 wxString *arg3 = 0 ;
43780 void *argp1 = 0 ;
43781 int res1 = 0 ;
43782 int val2 ;
43783 int ecode2 = 0 ;
43784 bool temp3 = false ;
43785 PyObject * obj0 = 0 ;
43786 PyObject * obj1 = 0 ;
43787 PyObject * obj2 = 0 ;
43788 char * kwnames[] = {
43789 (char *) "self",(char *) "id",(char *) "helpString", NULL
43790 };
43791
43792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43794 if (!SWIG_IsOK(res1)) {
43795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
43796 }
43797 arg1 = reinterpret_cast< wxMenu * >(argp1);
43798 ecode2 = SWIG_AsVal_int(obj1, &val2);
43799 if (!SWIG_IsOK(ecode2)) {
43800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43801 }
43802 arg2 = static_cast< int >(val2);
43803 {
43804 arg3 = wxString_in_helper(obj2);
43805 if (arg3 == NULL) SWIG_fail;
43806 temp3 = true;
43807 }
43808 {
43809 PyThreadState* __tstate = wxPyBeginAllowThreads();
43810 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43811 wxPyEndAllowThreads(__tstate);
43812 if (PyErr_Occurred()) SWIG_fail;
43813 }
43814 resultobj = SWIG_Py_Void();
43815 {
43816 if (temp3)
43817 delete arg3;
43818 }
43819 return resultobj;
43820 fail:
43821 {
43822 if (temp3)
43823 delete arg3;
43824 }
43825 return NULL;
43826 }
43827
43828
43829 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43830 PyObject *resultobj = 0;
43831 wxMenu *arg1 = (wxMenu *) 0 ;
43832 int arg2 ;
43833 wxString result;
43834 void *argp1 = 0 ;
43835 int res1 = 0 ;
43836 int val2 ;
43837 int ecode2 = 0 ;
43838 PyObject * obj0 = 0 ;
43839 PyObject * obj1 = 0 ;
43840 char * kwnames[] = {
43841 (char *) "self",(char *) "id", NULL
43842 };
43843
43844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43846 if (!SWIG_IsOK(res1)) {
43847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
43848 }
43849 arg1 = reinterpret_cast< wxMenu * >(argp1);
43850 ecode2 = SWIG_AsVal_int(obj1, &val2);
43851 if (!SWIG_IsOK(ecode2)) {
43852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43853 }
43854 arg2 = static_cast< int >(val2);
43855 {
43856 PyThreadState* __tstate = wxPyBeginAllowThreads();
43857 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
43858 wxPyEndAllowThreads(__tstate);
43859 if (PyErr_Occurred()) SWIG_fail;
43860 }
43861 {
43862 #if wxUSE_UNICODE
43863 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43864 #else
43865 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43866 #endif
43867 }
43868 return resultobj;
43869 fail:
43870 return NULL;
43871 }
43872
43873
43874 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43875 PyObject *resultobj = 0;
43876 wxMenu *arg1 = (wxMenu *) 0 ;
43877 wxString *arg2 = 0 ;
43878 void *argp1 = 0 ;
43879 int res1 = 0 ;
43880 bool temp2 = false ;
43881 PyObject * obj0 = 0 ;
43882 PyObject * obj1 = 0 ;
43883 char * kwnames[] = {
43884 (char *) "self",(char *) "title", NULL
43885 };
43886
43887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
43888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43889 if (!SWIG_IsOK(res1)) {
43890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
43891 }
43892 arg1 = reinterpret_cast< wxMenu * >(argp1);
43893 {
43894 arg2 = wxString_in_helper(obj1);
43895 if (arg2 == NULL) SWIG_fail;
43896 temp2 = true;
43897 }
43898 {
43899 PyThreadState* __tstate = wxPyBeginAllowThreads();
43900 (arg1)->SetTitle((wxString const &)*arg2);
43901 wxPyEndAllowThreads(__tstate);
43902 if (PyErr_Occurred()) SWIG_fail;
43903 }
43904 resultobj = SWIG_Py_Void();
43905 {
43906 if (temp2)
43907 delete arg2;
43908 }
43909 return resultobj;
43910 fail:
43911 {
43912 if (temp2)
43913 delete arg2;
43914 }
43915 return NULL;
43916 }
43917
43918
43919 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43920 PyObject *resultobj = 0;
43921 wxMenu *arg1 = (wxMenu *) 0 ;
43922 wxString result;
43923 void *argp1 = 0 ;
43924 int res1 = 0 ;
43925 PyObject *swig_obj[1] ;
43926
43927 if (!args) SWIG_fail;
43928 swig_obj[0] = args;
43929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43930 if (!SWIG_IsOK(res1)) {
43931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
43932 }
43933 arg1 = reinterpret_cast< wxMenu * >(argp1);
43934 {
43935 PyThreadState* __tstate = wxPyBeginAllowThreads();
43936 result = ((wxMenu const *)arg1)->GetTitle();
43937 wxPyEndAllowThreads(__tstate);
43938 if (PyErr_Occurred()) SWIG_fail;
43939 }
43940 {
43941 #if wxUSE_UNICODE
43942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43943 #else
43944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43945 #endif
43946 }
43947 return resultobj;
43948 fail:
43949 return NULL;
43950 }
43951
43952
43953 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43954 PyObject *resultobj = 0;
43955 wxMenu *arg1 = (wxMenu *) 0 ;
43956 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
43957 void *argp1 = 0 ;
43958 int res1 = 0 ;
43959 void *argp2 = 0 ;
43960 int res2 = 0 ;
43961 PyObject * obj0 = 0 ;
43962 PyObject * obj1 = 0 ;
43963 char * kwnames[] = {
43964 (char *) "self",(char *) "handler", NULL
43965 };
43966
43967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
43968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43969 if (!SWIG_IsOK(res1)) {
43970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
43971 }
43972 arg1 = reinterpret_cast< wxMenu * >(argp1);
43973 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
43974 if (!SWIG_IsOK(res2)) {
43975 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
43976 }
43977 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
43978 {
43979 PyThreadState* __tstate = wxPyBeginAllowThreads();
43980 (arg1)->SetEventHandler(arg2);
43981 wxPyEndAllowThreads(__tstate);
43982 if (PyErr_Occurred()) SWIG_fail;
43983 }
43984 resultobj = SWIG_Py_Void();
43985 return resultobj;
43986 fail:
43987 return NULL;
43988 }
43989
43990
43991 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43992 PyObject *resultobj = 0;
43993 wxMenu *arg1 = (wxMenu *) 0 ;
43994 wxEvtHandler *result = 0 ;
43995 void *argp1 = 0 ;
43996 int res1 = 0 ;
43997 PyObject *swig_obj[1] ;
43998
43999 if (!args) SWIG_fail;
44000 swig_obj[0] = args;
44001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44002 if (!SWIG_IsOK(res1)) {
44003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44004 }
44005 arg1 = reinterpret_cast< wxMenu * >(argp1);
44006 {
44007 PyThreadState* __tstate = wxPyBeginAllowThreads();
44008 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44009 wxPyEndAllowThreads(__tstate);
44010 if (PyErr_Occurred()) SWIG_fail;
44011 }
44012 {
44013 resultobj = wxPyMake_wxObject(result, 0);
44014 }
44015 return resultobj;
44016 fail:
44017 return NULL;
44018 }
44019
44020
44021 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44022 PyObject *resultobj = 0;
44023 wxMenu *arg1 = (wxMenu *) 0 ;
44024 wxWindow *arg2 = (wxWindow *) 0 ;
44025 void *argp1 = 0 ;
44026 int res1 = 0 ;
44027 void *argp2 = 0 ;
44028 int res2 = 0 ;
44029 PyObject * obj0 = 0 ;
44030 PyObject * obj1 = 0 ;
44031 char * kwnames[] = {
44032 (char *) "self",(char *) "win", NULL
44033 };
44034
44035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44037 if (!SWIG_IsOK(res1)) {
44038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44039 }
44040 arg1 = reinterpret_cast< wxMenu * >(argp1);
44041 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44042 if (!SWIG_IsOK(res2)) {
44043 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44044 }
44045 arg2 = reinterpret_cast< wxWindow * >(argp2);
44046 {
44047 PyThreadState* __tstate = wxPyBeginAllowThreads();
44048 (arg1)->SetInvokingWindow(arg2);
44049 wxPyEndAllowThreads(__tstate);
44050 if (PyErr_Occurred()) SWIG_fail;
44051 }
44052 resultobj = SWIG_Py_Void();
44053 return resultobj;
44054 fail:
44055 return NULL;
44056 }
44057
44058
44059 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44060 PyObject *resultobj = 0;
44061 wxMenu *arg1 = (wxMenu *) 0 ;
44062 wxWindow *result = 0 ;
44063 void *argp1 = 0 ;
44064 int res1 = 0 ;
44065 PyObject *swig_obj[1] ;
44066
44067 if (!args) SWIG_fail;
44068 swig_obj[0] = args;
44069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44070 if (!SWIG_IsOK(res1)) {
44071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44072 }
44073 arg1 = reinterpret_cast< wxMenu * >(argp1);
44074 {
44075 PyThreadState* __tstate = wxPyBeginAllowThreads();
44076 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44077 wxPyEndAllowThreads(__tstate);
44078 if (PyErr_Occurred()) SWIG_fail;
44079 }
44080 {
44081 resultobj = wxPyMake_wxObject(result, 0);
44082 }
44083 return resultobj;
44084 fail:
44085 return NULL;
44086 }
44087
44088
44089 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44090 PyObject *resultobj = 0;
44091 wxMenu *arg1 = (wxMenu *) 0 ;
44092 long result;
44093 void *argp1 = 0 ;
44094 int res1 = 0 ;
44095 PyObject *swig_obj[1] ;
44096
44097 if (!args) SWIG_fail;
44098 swig_obj[0] = args;
44099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44100 if (!SWIG_IsOK(res1)) {
44101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44102 }
44103 arg1 = reinterpret_cast< wxMenu * >(argp1);
44104 {
44105 PyThreadState* __tstate = wxPyBeginAllowThreads();
44106 result = (long)((wxMenu const *)arg1)->GetStyle();
44107 wxPyEndAllowThreads(__tstate);
44108 if (PyErr_Occurred()) SWIG_fail;
44109 }
44110 resultobj = SWIG_From_long(static_cast< long >(result));
44111 return resultobj;
44112 fail:
44113 return NULL;
44114 }
44115
44116
44117 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44118 PyObject *resultobj = 0;
44119 wxMenu *arg1 = (wxMenu *) 0 ;
44120 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44121 void *argp1 = 0 ;
44122 int res1 = 0 ;
44123 void *argp2 = 0 ;
44124 int res2 = 0 ;
44125 PyObject * obj0 = 0 ;
44126 PyObject * obj1 = 0 ;
44127 char * kwnames[] = {
44128 (char *) "self",(char *) "source", NULL
44129 };
44130
44131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44133 if (!SWIG_IsOK(res1)) {
44134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44135 }
44136 arg1 = reinterpret_cast< wxMenu * >(argp1);
44137 if (obj1) {
44138 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44139 if (!SWIG_IsOK(res2)) {
44140 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44141 }
44142 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44143 }
44144 {
44145 PyThreadState* __tstate = wxPyBeginAllowThreads();
44146 (arg1)->UpdateUI(arg2);
44147 wxPyEndAllowThreads(__tstate);
44148 if (PyErr_Occurred()) SWIG_fail;
44149 }
44150 resultobj = SWIG_Py_Void();
44151 return resultobj;
44152 fail:
44153 return NULL;
44154 }
44155
44156
44157 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44158 PyObject *resultobj = 0;
44159 wxMenu *arg1 = (wxMenu *) 0 ;
44160 wxMenuBar *result = 0 ;
44161 void *argp1 = 0 ;
44162 int res1 = 0 ;
44163 PyObject *swig_obj[1] ;
44164
44165 if (!args) SWIG_fail;
44166 swig_obj[0] = args;
44167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44168 if (!SWIG_IsOK(res1)) {
44169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44170 }
44171 arg1 = reinterpret_cast< wxMenu * >(argp1);
44172 {
44173 PyThreadState* __tstate = wxPyBeginAllowThreads();
44174 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44175 wxPyEndAllowThreads(__tstate);
44176 if (PyErr_Occurred()) SWIG_fail;
44177 }
44178 {
44179 resultobj = wxPyMake_wxObject(result, (bool)0);
44180 }
44181 return resultobj;
44182 fail:
44183 return NULL;
44184 }
44185
44186
44187 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44188 PyObject *resultobj = 0;
44189 wxMenu *arg1 = (wxMenu *) 0 ;
44190 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44191 void *argp1 = 0 ;
44192 int res1 = 0 ;
44193 void *argp2 = 0 ;
44194 int res2 = 0 ;
44195 PyObject * obj0 = 0 ;
44196 PyObject * obj1 = 0 ;
44197 char * kwnames[] = {
44198 (char *) "self",(char *) "menubar", NULL
44199 };
44200
44201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44203 if (!SWIG_IsOK(res1)) {
44204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44205 }
44206 arg1 = reinterpret_cast< wxMenu * >(argp1);
44207 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44208 if (!SWIG_IsOK(res2)) {
44209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44210 }
44211 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44212 {
44213 PyThreadState* __tstate = wxPyBeginAllowThreads();
44214 (arg1)->Attach(arg2);
44215 wxPyEndAllowThreads(__tstate);
44216 if (PyErr_Occurred()) SWIG_fail;
44217 }
44218 resultobj = SWIG_Py_Void();
44219 return resultobj;
44220 fail:
44221 return NULL;
44222 }
44223
44224
44225 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44226 PyObject *resultobj = 0;
44227 wxMenu *arg1 = (wxMenu *) 0 ;
44228 void *argp1 = 0 ;
44229 int res1 = 0 ;
44230 PyObject *swig_obj[1] ;
44231
44232 if (!args) SWIG_fail;
44233 swig_obj[0] = args;
44234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44235 if (!SWIG_IsOK(res1)) {
44236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44237 }
44238 arg1 = reinterpret_cast< wxMenu * >(argp1);
44239 {
44240 PyThreadState* __tstate = wxPyBeginAllowThreads();
44241 (arg1)->Detach();
44242 wxPyEndAllowThreads(__tstate);
44243 if (PyErr_Occurred()) SWIG_fail;
44244 }
44245 resultobj = SWIG_Py_Void();
44246 return resultobj;
44247 fail:
44248 return NULL;
44249 }
44250
44251
44252 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44253 PyObject *resultobj = 0;
44254 wxMenu *arg1 = (wxMenu *) 0 ;
44255 bool result;
44256 void *argp1 = 0 ;
44257 int res1 = 0 ;
44258 PyObject *swig_obj[1] ;
44259
44260 if (!args) SWIG_fail;
44261 swig_obj[0] = args;
44262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44263 if (!SWIG_IsOK(res1)) {
44264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44265 }
44266 arg1 = reinterpret_cast< wxMenu * >(argp1);
44267 {
44268 PyThreadState* __tstate = wxPyBeginAllowThreads();
44269 result = (bool)((wxMenu const *)arg1)->IsAttached();
44270 wxPyEndAllowThreads(__tstate);
44271 if (PyErr_Occurred()) SWIG_fail;
44272 }
44273 {
44274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44275 }
44276 return resultobj;
44277 fail:
44278 return NULL;
44279 }
44280
44281
44282 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44283 PyObject *resultobj = 0;
44284 wxMenu *arg1 = (wxMenu *) 0 ;
44285 wxMenu *arg2 = (wxMenu *) 0 ;
44286 void *argp1 = 0 ;
44287 int res1 = 0 ;
44288 void *argp2 = 0 ;
44289 int res2 = 0 ;
44290 PyObject * obj0 = 0 ;
44291 PyObject * obj1 = 0 ;
44292 char * kwnames[] = {
44293 (char *) "self",(char *) "parent", NULL
44294 };
44295
44296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44298 if (!SWIG_IsOK(res1)) {
44299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44300 }
44301 arg1 = reinterpret_cast< wxMenu * >(argp1);
44302 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44303 if (!SWIG_IsOK(res2)) {
44304 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44305 }
44306 arg2 = reinterpret_cast< wxMenu * >(argp2);
44307 {
44308 PyThreadState* __tstate = wxPyBeginAllowThreads();
44309 (arg1)->SetParent(arg2);
44310 wxPyEndAllowThreads(__tstate);
44311 if (PyErr_Occurred()) SWIG_fail;
44312 }
44313 resultobj = SWIG_Py_Void();
44314 return resultobj;
44315 fail:
44316 return NULL;
44317 }
44318
44319
44320 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44321 PyObject *resultobj = 0;
44322 wxMenu *arg1 = (wxMenu *) 0 ;
44323 wxMenu *result = 0 ;
44324 void *argp1 = 0 ;
44325 int res1 = 0 ;
44326 PyObject *swig_obj[1] ;
44327
44328 if (!args) SWIG_fail;
44329 swig_obj[0] = args;
44330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44331 if (!SWIG_IsOK(res1)) {
44332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44333 }
44334 arg1 = reinterpret_cast< wxMenu * >(argp1);
44335 {
44336 PyThreadState* __tstate = wxPyBeginAllowThreads();
44337 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44338 wxPyEndAllowThreads(__tstate);
44339 if (PyErr_Occurred()) SWIG_fail;
44340 }
44341 {
44342 resultobj = wxPyMake_wxObject(result, 0);
44343 }
44344 return resultobj;
44345 fail:
44346 return NULL;
44347 }
44348
44349
44350 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44351 PyObject *obj;
44352 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44353 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44354 return SWIG_Py_Void();
44355 }
44356
44357 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44358 return SWIG_Python_InitShadowInstance(args);
44359 }
44360
44361 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44362 PyObject *resultobj = 0;
44363 long arg1 = (long) 0 ;
44364 wxMenuBar *result = 0 ;
44365 long val1 ;
44366 int ecode1 = 0 ;
44367 PyObject * obj0 = 0 ;
44368 char * kwnames[] = {
44369 (char *) "style", NULL
44370 };
44371
44372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44373 if (obj0) {
44374 ecode1 = SWIG_AsVal_long(obj0, &val1);
44375 if (!SWIG_IsOK(ecode1)) {
44376 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44377 }
44378 arg1 = static_cast< long >(val1);
44379 }
44380 {
44381 if (!wxPyCheckForApp()) SWIG_fail;
44382 PyThreadState* __tstate = wxPyBeginAllowThreads();
44383 result = (wxMenuBar *)new wxMenuBar(arg1);
44384 wxPyEndAllowThreads(__tstate);
44385 if (PyErr_Occurred()) SWIG_fail;
44386 }
44387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44388 return resultobj;
44389 fail:
44390 return NULL;
44391 }
44392
44393
44394 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44395 PyObject *resultobj = 0;
44396 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44397 wxMenu *arg2 = (wxMenu *) 0 ;
44398 wxString *arg3 = 0 ;
44399 bool result;
44400 void *argp1 = 0 ;
44401 int res1 = 0 ;
44402 void *argp2 = 0 ;
44403 int res2 = 0 ;
44404 bool temp3 = false ;
44405 PyObject * obj0 = 0 ;
44406 PyObject * obj1 = 0 ;
44407 PyObject * obj2 = 0 ;
44408 char * kwnames[] = {
44409 (char *) "self",(char *) "menu",(char *) "title", NULL
44410 };
44411
44412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44414 if (!SWIG_IsOK(res1)) {
44415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44416 }
44417 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44418 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44419 if (!SWIG_IsOK(res2)) {
44420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44421 }
44422 arg2 = reinterpret_cast< wxMenu * >(argp2);
44423 {
44424 arg3 = wxString_in_helper(obj2);
44425 if (arg3 == NULL) SWIG_fail;
44426 temp3 = true;
44427 }
44428 {
44429 PyThreadState* __tstate = wxPyBeginAllowThreads();
44430 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44431 wxPyEndAllowThreads(__tstate);
44432 if (PyErr_Occurred()) SWIG_fail;
44433 }
44434 {
44435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44436 }
44437 {
44438 if (temp3)
44439 delete arg3;
44440 }
44441 return resultobj;
44442 fail:
44443 {
44444 if (temp3)
44445 delete arg3;
44446 }
44447 return NULL;
44448 }
44449
44450
44451 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44452 PyObject *resultobj = 0;
44453 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44454 size_t arg2 ;
44455 wxMenu *arg3 = (wxMenu *) 0 ;
44456 wxString *arg4 = 0 ;
44457 bool result;
44458 void *argp1 = 0 ;
44459 int res1 = 0 ;
44460 size_t val2 ;
44461 int ecode2 = 0 ;
44462 void *argp3 = 0 ;
44463 int res3 = 0 ;
44464 bool temp4 = false ;
44465 PyObject * obj0 = 0 ;
44466 PyObject * obj1 = 0 ;
44467 PyObject * obj2 = 0 ;
44468 PyObject * obj3 = 0 ;
44469 char * kwnames[] = {
44470 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44471 };
44472
44473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44475 if (!SWIG_IsOK(res1)) {
44476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44477 }
44478 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44479 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44480 if (!SWIG_IsOK(ecode2)) {
44481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44482 }
44483 arg2 = static_cast< size_t >(val2);
44484 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44485 if (!SWIG_IsOK(res3)) {
44486 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44487 }
44488 arg3 = reinterpret_cast< wxMenu * >(argp3);
44489 {
44490 arg4 = wxString_in_helper(obj3);
44491 if (arg4 == NULL) SWIG_fail;
44492 temp4 = true;
44493 }
44494 {
44495 PyThreadState* __tstate = wxPyBeginAllowThreads();
44496 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44497 wxPyEndAllowThreads(__tstate);
44498 if (PyErr_Occurred()) SWIG_fail;
44499 }
44500 {
44501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44502 }
44503 {
44504 if (temp4)
44505 delete arg4;
44506 }
44507 return resultobj;
44508 fail:
44509 {
44510 if (temp4)
44511 delete arg4;
44512 }
44513 return NULL;
44514 }
44515
44516
44517 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44518 PyObject *resultobj = 0;
44519 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44520 size_t result;
44521 void *argp1 = 0 ;
44522 int res1 = 0 ;
44523 PyObject *swig_obj[1] ;
44524
44525 if (!args) SWIG_fail;
44526 swig_obj[0] = args;
44527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44528 if (!SWIG_IsOK(res1)) {
44529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44530 }
44531 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44532 {
44533 PyThreadState* __tstate = wxPyBeginAllowThreads();
44534 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44535 wxPyEndAllowThreads(__tstate);
44536 if (PyErr_Occurred()) SWIG_fail;
44537 }
44538 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44539 return resultobj;
44540 fail:
44541 return NULL;
44542 }
44543
44544
44545 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44546 PyObject *resultobj = 0;
44547 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44548 size_t arg2 ;
44549 wxMenu *result = 0 ;
44550 void *argp1 = 0 ;
44551 int res1 = 0 ;
44552 size_t val2 ;
44553 int ecode2 = 0 ;
44554 PyObject * obj0 = 0 ;
44555 PyObject * obj1 = 0 ;
44556 char * kwnames[] = {
44557 (char *) "self",(char *) "pos", NULL
44558 };
44559
44560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44562 if (!SWIG_IsOK(res1)) {
44563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44564 }
44565 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44566 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44567 if (!SWIG_IsOK(ecode2)) {
44568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44569 }
44570 arg2 = static_cast< size_t >(val2);
44571 {
44572 PyThreadState* __tstate = wxPyBeginAllowThreads();
44573 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44574 wxPyEndAllowThreads(__tstate);
44575 if (PyErr_Occurred()) SWIG_fail;
44576 }
44577 {
44578 resultobj = wxPyMake_wxObject(result, 0);
44579 }
44580 return resultobj;
44581 fail:
44582 return NULL;
44583 }
44584
44585
44586 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44587 PyObject *resultobj = 0;
44588 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44589 size_t arg2 ;
44590 wxMenu *arg3 = (wxMenu *) 0 ;
44591 wxString *arg4 = 0 ;
44592 wxMenu *result = 0 ;
44593 void *argp1 = 0 ;
44594 int res1 = 0 ;
44595 size_t val2 ;
44596 int ecode2 = 0 ;
44597 void *argp3 = 0 ;
44598 int res3 = 0 ;
44599 bool temp4 = false ;
44600 PyObject * obj0 = 0 ;
44601 PyObject * obj1 = 0 ;
44602 PyObject * obj2 = 0 ;
44603 PyObject * obj3 = 0 ;
44604 char * kwnames[] = {
44605 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44606 };
44607
44608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
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_Replace" "', expected argument " "2"" of type '" "size_t""'");
44617 }
44618 arg2 = static_cast< size_t >(val2);
44619 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44620 if (!SWIG_IsOK(res3)) {
44621 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44622 }
44623 arg3 = reinterpret_cast< wxMenu * >(argp3);
44624 {
44625 arg4 = wxString_in_helper(obj3);
44626 if (arg4 == NULL) SWIG_fail;
44627 temp4 = true;
44628 }
44629 {
44630 PyThreadState* __tstate = wxPyBeginAllowThreads();
44631 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44632 wxPyEndAllowThreads(__tstate);
44633 if (PyErr_Occurred()) SWIG_fail;
44634 }
44635 {
44636 resultobj = wxPyMake_wxObject(result, 0);
44637 }
44638 {
44639 if (temp4)
44640 delete arg4;
44641 }
44642 return resultobj;
44643 fail:
44644 {
44645 if (temp4)
44646 delete arg4;
44647 }
44648 return NULL;
44649 }
44650
44651
44652 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44653 PyObject *resultobj = 0;
44654 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44655 size_t arg2 ;
44656 wxMenu *result = 0 ;
44657 void *argp1 = 0 ;
44658 int res1 = 0 ;
44659 size_t val2 ;
44660 int ecode2 = 0 ;
44661 PyObject * obj0 = 0 ;
44662 PyObject * obj1 = 0 ;
44663 char * kwnames[] = {
44664 (char *) "self",(char *) "pos", NULL
44665 };
44666
44667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44669 if (!SWIG_IsOK(res1)) {
44670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44671 }
44672 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44673 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44674 if (!SWIG_IsOK(ecode2)) {
44675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
44676 }
44677 arg2 = static_cast< size_t >(val2);
44678 {
44679 PyThreadState* __tstate = wxPyBeginAllowThreads();
44680 result = (wxMenu *)(arg1)->Remove(arg2);
44681 wxPyEndAllowThreads(__tstate);
44682 if (PyErr_Occurred()) SWIG_fail;
44683 }
44684 {
44685 resultobj = wxPyMake_wxObject(result, 0);
44686 }
44687 return resultobj;
44688 fail:
44689 return NULL;
44690 }
44691
44692
44693 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44694 PyObject *resultobj = 0;
44695 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44696 size_t arg2 ;
44697 bool arg3 ;
44698 void *argp1 = 0 ;
44699 int res1 = 0 ;
44700 size_t val2 ;
44701 int ecode2 = 0 ;
44702 bool val3 ;
44703 int ecode3 = 0 ;
44704 PyObject * obj0 = 0 ;
44705 PyObject * obj1 = 0 ;
44706 PyObject * obj2 = 0 ;
44707 char * kwnames[] = {
44708 (char *) "self",(char *) "pos",(char *) "enable", NULL
44709 };
44710
44711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44713 if (!SWIG_IsOK(res1)) {
44714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44715 }
44716 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44717 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44718 if (!SWIG_IsOK(ecode2)) {
44719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
44720 }
44721 arg2 = static_cast< size_t >(val2);
44722 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44723 if (!SWIG_IsOK(ecode3)) {
44724 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
44725 }
44726 arg3 = static_cast< bool >(val3);
44727 {
44728 PyThreadState* __tstate = wxPyBeginAllowThreads();
44729 (arg1)->EnableTop(arg2,arg3);
44730 wxPyEndAllowThreads(__tstate);
44731 if (PyErr_Occurred()) SWIG_fail;
44732 }
44733 resultobj = SWIG_Py_Void();
44734 return resultobj;
44735 fail:
44736 return NULL;
44737 }
44738
44739
44740 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44741 PyObject *resultobj = 0;
44742 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44743 size_t arg2 ;
44744 bool result;
44745 void *argp1 = 0 ;
44746 int res1 = 0 ;
44747 size_t val2 ;
44748 int ecode2 = 0 ;
44749 PyObject * obj0 = 0 ;
44750 PyObject * obj1 = 0 ;
44751 char * kwnames[] = {
44752 (char *) "self",(char *) "pos", NULL
44753 };
44754
44755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
44756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44757 if (!SWIG_IsOK(res1)) {
44758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44759 }
44760 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44761 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44762 if (!SWIG_IsOK(ecode2)) {
44763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
44764 }
44765 arg2 = static_cast< size_t >(val2);
44766 {
44767 PyThreadState* __tstate = wxPyBeginAllowThreads();
44768 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
44769 wxPyEndAllowThreads(__tstate);
44770 if (PyErr_Occurred()) SWIG_fail;
44771 }
44772 {
44773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44774 }
44775 return resultobj;
44776 fail:
44777 return NULL;
44778 }
44779
44780
44781 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44782 PyObject *resultobj = 0;
44783 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44784 size_t arg2 ;
44785 wxString *arg3 = 0 ;
44786 void *argp1 = 0 ;
44787 int res1 = 0 ;
44788 size_t val2 ;
44789 int ecode2 = 0 ;
44790 bool temp3 = false ;
44791 PyObject * obj0 = 0 ;
44792 PyObject * obj1 = 0 ;
44793 PyObject * obj2 = 0 ;
44794 char * kwnames[] = {
44795 (char *) "self",(char *) "pos",(char *) "label", NULL
44796 };
44797
44798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44800 if (!SWIG_IsOK(res1)) {
44801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44802 }
44803 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44804 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44805 if (!SWIG_IsOK(ecode2)) {
44806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44807 }
44808 arg2 = static_cast< size_t >(val2);
44809 {
44810 arg3 = wxString_in_helper(obj2);
44811 if (arg3 == NULL) SWIG_fail;
44812 temp3 = true;
44813 }
44814 {
44815 PyThreadState* __tstate = wxPyBeginAllowThreads();
44816 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
44817 wxPyEndAllowThreads(__tstate);
44818 if (PyErr_Occurred()) SWIG_fail;
44819 }
44820 resultobj = SWIG_Py_Void();
44821 {
44822 if (temp3)
44823 delete arg3;
44824 }
44825 return resultobj;
44826 fail:
44827 {
44828 if (temp3)
44829 delete arg3;
44830 }
44831 return NULL;
44832 }
44833
44834
44835 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44836 PyObject *resultobj = 0;
44837 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44838 size_t arg2 ;
44839 wxString result;
44840 void *argp1 = 0 ;
44841 int res1 = 0 ;
44842 size_t val2 ;
44843 int ecode2 = 0 ;
44844 PyObject * obj0 = 0 ;
44845 PyObject * obj1 = 0 ;
44846 char * kwnames[] = {
44847 (char *) "self",(char *) "pos", NULL
44848 };
44849
44850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
44851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44852 if (!SWIG_IsOK(res1)) {
44853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44854 }
44855 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44856 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44857 if (!SWIG_IsOK(ecode2)) {
44858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44859 }
44860 arg2 = static_cast< size_t >(val2);
44861 {
44862 PyThreadState* __tstate = wxPyBeginAllowThreads();
44863 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
44864 wxPyEndAllowThreads(__tstate);
44865 if (PyErr_Occurred()) SWIG_fail;
44866 }
44867 {
44868 #if wxUSE_UNICODE
44869 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44870 #else
44871 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44872 #endif
44873 }
44874 return resultobj;
44875 fail:
44876 return NULL;
44877 }
44878
44879
44880 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44881 PyObject *resultobj = 0;
44882 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44883 wxString *arg2 = 0 ;
44884 wxString *arg3 = 0 ;
44885 int result;
44886 void *argp1 = 0 ;
44887 int res1 = 0 ;
44888 bool temp2 = false ;
44889 bool temp3 = false ;
44890 PyObject * obj0 = 0 ;
44891 PyObject * obj1 = 0 ;
44892 PyObject * obj2 = 0 ;
44893 char * kwnames[] = {
44894 (char *) "self",(char *) "menu",(char *) "item", NULL
44895 };
44896
44897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44899 if (!SWIG_IsOK(res1)) {
44900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44901 }
44902 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44903 {
44904 arg2 = wxString_in_helper(obj1);
44905 if (arg2 == NULL) SWIG_fail;
44906 temp2 = true;
44907 }
44908 {
44909 arg3 = wxString_in_helper(obj2);
44910 if (arg3 == NULL) SWIG_fail;
44911 temp3 = true;
44912 }
44913 {
44914 PyThreadState* __tstate = wxPyBeginAllowThreads();
44915 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
44916 wxPyEndAllowThreads(__tstate);
44917 if (PyErr_Occurred()) SWIG_fail;
44918 }
44919 resultobj = SWIG_From_int(static_cast< int >(result));
44920 {
44921 if (temp2)
44922 delete arg2;
44923 }
44924 {
44925 if (temp3)
44926 delete arg3;
44927 }
44928 return resultobj;
44929 fail:
44930 {
44931 if (temp2)
44932 delete arg2;
44933 }
44934 {
44935 if (temp3)
44936 delete arg3;
44937 }
44938 return NULL;
44939 }
44940
44941
44942 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44943 PyObject *resultobj = 0;
44944 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44945 int arg2 ;
44946 wxMenuItem *result = 0 ;
44947 void *argp1 = 0 ;
44948 int res1 = 0 ;
44949 int val2 ;
44950 int ecode2 = 0 ;
44951 PyObject * obj0 = 0 ;
44952 PyObject * obj1 = 0 ;
44953 char * kwnames[] = {
44954 (char *) "self",(char *) "id", NULL
44955 };
44956
44957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
44958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44959 if (!SWIG_IsOK(res1)) {
44960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44961 }
44962 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44963 ecode2 = SWIG_AsVal_int(obj1, &val2);
44964 if (!SWIG_IsOK(ecode2)) {
44965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
44966 }
44967 arg2 = static_cast< int >(val2);
44968 {
44969 PyThreadState* __tstate = wxPyBeginAllowThreads();
44970 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
44971 wxPyEndAllowThreads(__tstate);
44972 if (PyErr_Occurred()) SWIG_fail;
44973 }
44974 {
44975 resultobj = wxPyMake_wxObject(result, (bool)0);
44976 }
44977 return resultobj;
44978 fail:
44979 return NULL;
44980 }
44981
44982
44983 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44984 PyObject *resultobj = 0;
44985 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44986 wxString *arg2 = 0 ;
44987 int result;
44988 void *argp1 = 0 ;
44989 int res1 = 0 ;
44990 bool temp2 = false ;
44991 PyObject * obj0 = 0 ;
44992 PyObject * obj1 = 0 ;
44993 char * kwnames[] = {
44994 (char *) "self",(char *) "title", NULL
44995 };
44996
44997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44999 if (!SWIG_IsOK(res1)) {
45000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45001 }
45002 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45003 {
45004 arg2 = wxString_in_helper(obj1);
45005 if (arg2 == NULL) SWIG_fail;
45006 temp2 = true;
45007 }
45008 {
45009 PyThreadState* __tstate = wxPyBeginAllowThreads();
45010 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45011 wxPyEndAllowThreads(__tstate);
45012 if (PyErr_Occurred()) SWIG_fail;
45013 }
45014 resultobj = SWIG_From_int(static_cast< int >(result));
45015 {
45016 if (temp2)
45017 delete arg2;
45018 }
45019 return resultobj;
45020 fail:
45021 {
45022 if (temp2)
45023 delete arg2;
45024 }
45025 return NULL;
45026 }
45027
45028
45029 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45030 PyObject *resultobj = 0;
45031 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45032 int arg2 ;
45033 bool arg3 ;
45034 void *argp1 = 0 ;
45035 int res1 = 0 ;
45036 int val2 ;
45037 int ecode2 = 0 ;
45038 bool val3 ;
45039 int ecode3 = 0 ;
45040 PyObject * obj0 = 0 ;
45041 PyObject * obj1 = 0 ;
45042 PyObject * obj2 = 0 ;
45043 char * kwnames[] = {
45044 (char *) "self",(char *) "id",(char *) "enable", NULL
45045 };
45046
45047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45049 if (!SWIG_IsOK(res1)) {
45050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45051 }
45052 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45053 ecode2 = SWIG_AsVal_int(obj1, &val2);
45054 if (!SWIG_IsOK(ecode2)) {
45055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45056 }
45057 arg2 = static_cast< int >(val2);
45058 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45059 if (!SWIG_IsOK(ecode3)) {
45060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45061 }
45062 arg3 = static_cast< bool >(val3);
45063 {
45064 PyThreadState* __tstate = wxPyBeginAllowThreads();
45065 (arg1)->Enable(arg2,arg3);
45066 wxPyEndAllowThreads(__tstate);
45067 if (PyErr_Occurred()) SWIG_fail;
45068 }
45069 resultobj = SWIG_Py_Void();
45070 return resultobj;
45071 fail:
45072 return NULL;
45073 }
45074
45075
45076 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45077 PyObject *resultobj = 0;
45078 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45079 int arg2 ;
45080 bool arg3 ;
45081 void *argp1 = 0 ;
45082 int res1 = 0 ;
45083 int val2 ;
45084 int ecode2 = 0 ;
45085 bool val3 ;
45086 int ecode3 = 0 ;
45087 PyObject * obj0 = 0 ;
45088 PyObject * obj1 = 0 ;
45089 PyObject * obj2 = 0 ;
45090 char * kwnames[] = {
45091 (char *) "self",(char *) "id",(char *) "check", NULL
45092 };
45093
45094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45096 if (!SWIG_IsOK(res1)) {
45097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45098 }
45099 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45100 ecode2 = SWIG_AsVal_int(obj1, &val2);
45101 if (!SWIG_IsOK(ecode2)) {
45102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45103 }
45104 arg2 = static_cast< int >(val2);
45105 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45106 if (!SWIG_IsOK(ecode3)) {
45107 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45108 }
45109 arg3 = static_cast< bool >(val3);
45110 {
45111 PyThreadState* __tstate = wxPyBeginAllowThreads();
45112 (arg1)->Check(arg2,arg3);
45113 wxPyEndAllowThreads(__tstate);
45114 if (PyErr_Occurred()) SWIG_fail;
45115 }
45116 resultobj = SWIG_Py_Void();
45117 return resultobj;
45118 fail:
45119 return NULL;
45120 }
45121
45122
45123 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45124 PyObject *resultobj = 0;
45125 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45126 int arg2 ;
45127 bool result;
45128 void *argp1 = 0 ;
45129 int res1 = 0 ;
45130 int val2 ;
45131 int ecode2 = 0 ;
45132 PyObject * obj0 = 0 ;
45133 PyObject * obj1 = 0 ;
45134 char * kwnames[] = {
45135 (char *) "self",(char *) "id", NULL
45136 };
45137
45138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45140 if (!SWIG_IsOK(res1)) {
45141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45142 }
45143 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45144 ecode2 = SWIG_AsVal_int(obj1, &val2);
45145 if (!SWIG_IsOK(ecode2)) {
45146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45147 }
45148 arg2 = static_cast< int >(val2);
45149 {
45150 PyThreadState* __tstate = wxPyBeginAllowThreads();
45151 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45152 wxPyEndAllowThreads(__tstate);
45153 if (PyErr_Occurred()) SWIG_fail;
45154 }
45155 {
45156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45157 }
45158 return resultobj;
45159 fail:
45160 return NULL;
45161 }
45162
45163
45164 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45165 PyObject *resultobj = 0;
45166 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45167 int arg2 ;
45168 bool result;
45169 void *argp1 = 0 ;
45170 int res1 = 0 ;
45171 int val2 ;
45172 int ecode2 = 0 ;
45173 PyObject * obj0 = 0 ;
45174 PyObject * obj1 = 0 ;
45175 char * kwnames[] = {
45176 (char *) "self",(char *) "id", NULL
45177 };
45178
45179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45181 if (!SWIG_IsOK(res1)) {
45182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45183 }
45184 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45185 ecode2 = SWIG_AsVal_int(obj1, &val2);
45186 if (!SWIG_IsOK(ecode2)) {
45187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45188 }
45189 arg2 = static_cast< int >(val2);
45190 {
45191 PyThreadState* __tstate = wxPyBeginAllowThreads();
45192 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45193 wxPyEndAllowThreads(__tstate);
45194 if (PyErr_Occurred()) SWIG_fail;
45195 }
45196 {
45197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45198 }
45199 return resultobj;
45200 fail:
45201 return NULL;
45202 }
45203
45204
45205 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45206 PyObject *resultobj = 0;
45207 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45208 int arg2 ;
45209 wxString *arg3 = 0 ;
45210 void *argp1 = 0 ;
45211 int res1 = 0 ;
45212 int val2 ;
45213 int ecode2 = 0 ;
45214 bool temp3 = false ;
45215 PyObject * obj0 = 0 ;
45216 PyObject * obj1 = 0 ;
45217 PyObject * obj2 = 0 ;
45218 char * kwnames[] = {
45219 (char *) "self",(char *) "id",(char *) "label", NULL
45220 };
45221
45222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45224 if (!SWIG_IsOK(res1)) {
45225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45226 }
45227 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45228 ecode2 = SWIG_AsVal_int(obj1, &val2);
45229 if (!SWIG_IsOK(ecode2)) {
45230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45231 }
45232 arg2 = static_cast< int >(val2);
45233 {
45234 arg3 = wxString_in_helper(obj2);
45235 if (arg3 == NULL) SWIG_fail;
45236 temp3 = true;
45237 }
45238 {
45239 PyThreadState* __tstate = wxPyBeginAllowThreads();
45240 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45241 wxPyEndAllowThreads(__tstate);
45242 if (PyErr_Occurred()) SWIG_fail;
45243 }
45244 resultobj = SWIG_Py_Void();
45245 {
45246 if (temp3)
45247 delete arg3;
45248 }
45249 return resultobj;
45250 fail:
45251 {
45252 if (temp3)
45253 delete arg3;
45254 }
45255 return NULL;
45256 }
45257
45258
45259 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45260 PyObject *resultobj = 0;
45261 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45262 int arg2 ;
45263 wxString result;
45264 void *argp1 = 0 ;
45265 int res1 = 0 ;
45266 int val2 ;
45267 int ecode2 = 0 ;
45268 PyObject * obj0 = 0 ;
45269 PyObject * obj1 = 0 ;
45270 char * kwnames[] = {
45271 (char *) "self",(char *) "id", NULL
45272 };
45273
45274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45276 if (!SWIG_IsOK(res1)) {
45277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45278 }
45279 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45280 ecode2 = SWIG_AsVal_int(obj1, &val2);
45281 if (!SWIG_IsOK(ecode2)) {
45282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45283 }
45284 arg2 = static_cast< int >(val2);
45285 {
45286 PyThreadState* __tstate = wxPyBeginAllowThreads();
45287 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45288 wxPyEndAllowThreads(__tstate);
45289 if (PyErr_Occurred()) SWIG_fail;
45290 }
45291 {
45292 #if wxUSE_UNICODE
45293 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45294 #else
45295 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45296 #endif
45297 }
45298 return resultobj;
45299 fail:
45300 return NULL;
45301 }
45302
45303
45304 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45305 PyObject *resultobj = 0;
45306 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45307 int arg2 ;
45308 wxString *arg3 = 0 ;
45309 void *argp1 = 0 ;
45310 int res1 = 0 ;
45311 int val2 ;
45312 int ecode2 = 0 ;
45313 bool temp3 = false ;
45314 PyObject * obj0 = 0 ;
45315 PyObject * obj1 = 0 ;
45316 PyObject * obj2 = 0 ;
45317 char * kwnames[] = {
45318 (char *) "self",(char *) "id",(char *) "helpString", NULL
45319 };
45320
45321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45323 if (!SWIG_IsOK(res1)) {
45324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45325 }
45326 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45327 ecode2 = SWIG_AsVal_int(obj1, &val2);
45328 if (!SWIG_IsOK(ecode2)) {
45329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45330 }
45331 arg2 = static_cast< int >(val2);
45332 {
45333 arg3 = wxString_in_helper(obj2);
45334 if (arg3 == NULL) SWIG_fail;
45335 temp3 = true;
45336 }
45337 {
45338 PyThreadState* __tstate = wxPyBeginAllowThreads();
45339 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45340 wxPyEndAllowThreads(__tstate);
45341 if (PyErr_Occurred()) SWIG_fail;
45342 }
45343 resultobj = SWIG_Py_Void();
45344 {
45345 if (temp3)
45346 delete arg3;
45347 }
45348 return resultobj;
45349 fail:
45350 {
45351 if (temp3)
45352 delete arg3;
45353 }
45354 return NULL;
45355 }
45356
45357
45358 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45359 PyObject *resultobj = 0;
45360 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45361 int arg2 ;
45362 wxString result;
45363 void *argp1 = 0 ;
45364 int res1 = 0 ;
45365 int val2 ;
45366 int ecode2 = 0 ;
45367 PyObject * obj0 = 0 ;
45368 PyObject * obj1 = 0 ;
45369 char * kwnames[] = {
45370 (char *) "self",(char *) "id", NULL
45371 };
45372
45373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45375 if (!SWIG_IsOK(res1)) {
45376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45377 }
45378 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45379 ecode2 = SWIG_AsVal_int(obj1, &val2);
45380 if (!SWIG_IsOK(ecode2)) {
45381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45382 }
45383 arg2 = static_cast< int >(val2);
45384 {
45385 PyThreadState* __tstate = wxPyBeginAllowThreads();
45386 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45387 wxPyEndAllowThreads(__tstate);
45388 if (PyErr_Occurred()) SWIG_fail;
45389 }
45390 {
45391 #if wxUSE_UNICODE
45392 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45393 #else
45394 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45395 #endif
45396 }
45397 return resultobj;
45398 fail:
45399 return NULL;
45400 }
45401
45402
45403 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45404 PyObject *resultobj = 0;
45405 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45406 wxFrame *result = 0 ;
45407 void *argp1 = 0 ;
45408 int res1 = 0 ;
45409 PyObject *swig_obj[1] ;
45410
45411 if (!args) SWIG_fail;
45412 swig_obj[0] = args;
45413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45414 if (!SWIG_IsOK(res1)) {
45415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45416 }
45417 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45418 {
45419 PyThreadState* __tstate = wxPyBeginAllowThreads();
45420 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45421 wxPyEndAllowThreads(__tstate);
45422 if (PyErr_Occurred()) SWIG_fail;
45423 }
45424 {
45425 resultobj = wxPyMake_wxObject(result, (bool)0);
45426 }
45427 return resultobj;
45428 fail:
45429 return NULL;
45430 }
45431
45432
45433 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45434 PyObject *resultobj = 0;
45435 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45436 bool result;
45437 void *argp1 = 0 ;
45438 int res1 = 0 ;
45439 PyObject *swig_obj[1] ;
45440
45441 if (!args) SWIG_fail;
45442 swig_obj[0] = args;
45443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45444 if (!SWIG_IsOK(res1)) {
45445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45446 }
45447 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45448 {
45449 PyThreadState* __tstate = wxPyBeginAllowThreads();
45450 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45451 wxPyEndAllowThreads(__tstate);
45452 if (PyErr_Occurred()) SWIG_fail;
45453 }
45454 {
45455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45456 }
45457 return resultobj;
45458 fail:
45459 return NULL;
45460 }
45461
45462
45463 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45464 PyObject *resultobj = 0;
45465 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45466 wxFrame *arg2 = (wxFrame *) 0 ;
45467 void *argp1 = 0 ;
45468 int res1 = 0 ;
45469 void *argp2 = 0 ;
45470 int res2 = 0 ;
45471 PyObject * obj0 = 0 ;
45472 PyObject * obj1 = 0 ;
45473 char * kwnames[] = {
45474 (char *) "self",(char *) "frame", NULL
45475 };
45476
45477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45479 if (!SWIG_IsOK(res1)) {
45480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45481 }
45482 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45483 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45484 if (!SWIG_IsOK(res2)) {
45485 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45486 }
45487 arg2 = reinterpret_cast< wxFrame * >(argp2);
45488 {
45489 PyThreadState* __tstate = wxPyBeginAllowThreads();
45490 (arg1)->Attach(arg2);
45491 wxPyEndAllowThreads(__tstate);
45492 if (PyErr_Occurred()) SWIG_fail;
45493 }
45494 resultobj = SWIG_Py_Void();
45495 return resultobj;
45496 fail:
45497 return NULL;
45498 }
45499
45500
45501 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45502 PyObject *resultobj = 0;
45503 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45504 void *argp1 = 0 ;
45505 int res1 = 0 ;
45506 PyObject *swig_obj[1] ;
45507
45508 if (!args) SWIG_fail;
45509 swig_obj[0] = args;
45510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45511 if (!SWIG_IsOK(res1)) {
45512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45513 }
45514 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45515 {
45516 PyThreadState* __tstate = wxPyBeginAllowThreads();
45517 (arg1)->Detach();
45518 wxPyEndAllowThreads(__tstate);
45519 if (PyErr_Occurred()) SWIG_fail;
45520 }
45521 resultobj = SWIG_Py_Void();
45522 return resultobj;
45523 fail:
45524 return NULL;
45525 }
45526
45527
45528 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45529 PyObject *resultobj = 0;
45530 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45531 void *argp1 = 0 ;
45532 int res1 = 0 ;
45533 PyObject *swig_obj[1] ;
45534
45535 if (!args) SWIG_fail;
45536 swig_obj[0] = args;
45537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45538 if (!SWIG_IsOK(res1)) {
45539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45540 }
45541 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45542 {
45543 PyThreadState* __tstate = wxPyBeginAllowThreads();
45544 (arg1)->UpdateMenus();
45545 wxPyEndAllowThreads(__tstate);
45546 if (PyErr_Occurred()) SWIG_fail;
45547 }
45548 resultobj = SWIG_Py_Void();
45549 return resultobj;
45550 fail:
45551 return NULL;
45552 }
45553
45554
45555 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45556 PyObject *resultobj = 0;
45557 bool arg1 ;
45558 bool val1 ;
45559 int ecode1 = 0 ;
45560 PyObject * obj0 = 0 ;
45561 char * kwnames[] = {
45562 (char *) "enable", NULL
45563 };
45564
45565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45566 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45567 if (!SWIG_IsOK(ecode1)) {
45568 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45569 }
45570 arg1 = static_cast< bool >(val1);
45571 {
45572 PyThreadState* __tstate = wxPyBeginAllowThreads();
45573 wxMenuBar_SetAutoWindowMenu(arg1);
45574 wxPyEndAllowThreads(__tstate);
45575 if (PyErr_Occurred()) SWIG_fail;
45576 }
45577 resultobj = SWIG_Py_Void();
45578 return resultobj;
45579 fail:
45580 return NULL;
45581 }
45582
45583
45584 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45585 PyObject *resultobj = 0;
45586 bool result;
45587
45588 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45589 {
45590 PyThreadState* __tstate = wxPyBeginAllowThreads();
45591 result = (bool)wxMenuBar_GetAutoWindowMenu();
45592 wxPyEndAllowThreads(__tstate);
45593 if (PyErr_Occurred()) SWIG_fail;
45594 }
45595 {
45596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45597 }
45598 return resultobj;
45599 fail:
45600 return NULL;
45601 }
45602
45603
45604 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45605 PyObject *obj;
45606 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45607 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45608 return SWIG_Py_Void();
45609 }
45610
45611 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45612 return SWIG_Python_InitShadowInstance(args);
45613 }
45614
45615 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45616 PyObject *resultobj = 0;
45617 wxMenu *arg1 = (wxMenu *) NULL ;
45618 int arg2 = (int) wxID_ANY ;
45619 wxString const &arg3_defvalue = wxPyEmptyString ;
45620 wxString *arg3 = (wxString *) &arg3_defvalue ;
45621 wxString const &arg4_defvalue = wxPyEmptyString ;
45622 wxString *arg4 = (wxString *) &arg4_defvalue ;
45623 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45624 wxMenu *arg6 = (wxMenu *) NULL ;
45625 wxMenuItem *result = 0 ;
45626 void *argp1 = 0 ;
45627 int res1 = 0 ;
45628 int val2 ;
45629 int ecode2 = 0 ;
45630 bool temp3 = false ;
45631 bool temp4 = false ;
45632 int val5 ;
45633 int ecode5 = 0 ;
45634 void *argp6 = 0 ;
45635 int res6 = 0 ;
45636 PyObject * obj0 = 0 ;
45637 PyObject * obj1 = 0 ;
45638 PyObject * obj2 = 0 ;
45639 PyObject * obj3 = 0 ;
45640 PyObject * obj4 = 0 ;
45641 PyObject * obj5 = 0 ;
45642 char * kwnames[] = {
45643 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45644 };
45645
45646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45647 if (obj0) {
45648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45649 if (!SWIG_IsOK(res1)) {
45650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
45651 }
45652 arg1 = reinterpret_cast< wxMenu * >(argp1);
45653 }
45654 if (obj1) {
45655 ecode2 = SWIG_AsVal_int(obj1, &val2);
45656 if (!SWIG_IsOK(ecode2)) {
45657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45658 }
45659 arg2 = static_cast< int >(val2);
45660 }
45661 if (obj2) {
45662 {
45663 arg3 = wxString_in_helper(obj2);
45664 if (arg3 == NULL) SWIG_fail;
45665 temp3 = true;
45666 }
45667 }
45668 if (obj3) {
45669 {
45670 arg4 = wxString_in_helper(obj3);
45671 if (arg4 == NULL) SWIG_fail;
45672 temp4 = true;
45673 }
45674 }
45675 if (obj4) {
45676 ecode5 = SWIG_AsVal_int(obj4, &val5);
45677 if (!SWIG_IsOK(ecode5)) {
45678 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
45679 }
45680 arg5 = static_cast< wxItemKind >(val5);
45681 }
45682 if (obj5) {
45683 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
45684 if (!SWIG_IsOK(res6)) {
45685 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
45686 }
45687 arg6 = reinterpret_cast< wxMenu * >(argp6);
45688 }
45689 {
45690 PyThreadState* __tstate = wxPyBeginAllowThreads();
45691 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
45692 wxPyEndAllowThreads(__tstate);
45693 if (PyErr_Occurred()) SWIG_fail;
45694 }
45695 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
45696 {
45697 if (temp3)
45698 delete arg3;
45699 }
45700 {
45701 if (temp4)
45702 delete arg4;
45703 }
45704 return resultobj;
45705 fail:
45706 {
45707 if (temp3)
45708 delete arg3;
45709 }
45710 {
45711 if (temp4)
45712 delete arg4;
45713 }
45714 return NULL;
45715 }
45716
45717
45718 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45719 PyObject *resultobj = 0;
45720 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45721 void *argp1 = 0 ;
45722 int res1 = 0 ;
45723 PyObject *swig_obj[1] ;
45724
45725 if (!args) SWIG_fail;
45726 swig_obj[0] = args;
45727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
45728 if (!SWIG_IsOK(res1)) {
45729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45730 }
45731 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45732 {
45733 PyThreadState* __tstate = wxPyBeginAllowThreads();
45734 delete arg1;
45735
45736 wxPyEndAllowThreads(__tstate);
45737 if (PyErr_Occurred()) SWIG_fail;
45738 }
45739 resultobj = SWIG_Py_Void();
45740 return resultobj;
45741 fail:
45742 return NULL;
45743 }
45744
45745
45746 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45747 PyObject *resultobj = 0;
45748 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45749 wxMenu *result = 0 ;
45750 void *argp1 = 0 ;
45751 int res1 = 0 ;
45752 PyObject *swig_obj[1] ;
45753
45754 if (!args) SWIG_fail;
45755 swig_obj[0] = args;
45756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45757 if (!SWIG_IsOK(res1)) {
45758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45759 }
45760 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45761 {
45762 PyThreadState* __tstate = wxPyBeginAllowThreads();
45763 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
45764 wxPyEndAllowThreads(__tstate);
45765 if (PyErr_Occurred()) SWIG_fail;
45766 }
45767 {
45768 resultobj = wxPyMake_wxObject(result, 0);
45769 }
45770 return resultobj;
45771 fail:
45772 return NULL;
45773 }
45774
45775
45776 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45777 PyObject *resultobj = 0;
45778 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45779 wxMenu *arg2 = (wxMenu *) 0 ;
45780 void *argp1 = 0 ;
45781 int res1 = 0 ;
45782 void *argp2 = 0 ;
45783 int res2 = 0 ;
45784 PyObject * obj0 = 0 ;
45785 PyObject * obj1 = 0 ;
45786 char * kwnames[] = {
45787 (char *) "self",(char *) "menu", NULL
45788 };
45789
45790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45792 if (!SWIG_IsOK(res1)) {
45793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45794 }
45795 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45796 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45797 if (!SWIG_IsOK(res2)) {
45798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
45799 }
45800 arg2 = reinterpret_cast< wxMenu * >(argp2);
45801 {
45802 PyThreadState* __tstate = wxPyBeginAllowThreads();
45803 (arg1)->SetMenu(arg2);
45804 wxPyEndAllowThreads(__tstate);
45805 if (PyErr_Occurred()) SWIG_fail;
45806 }
45807 resultobj = SWIG_Py_Void();
45808 return resultobj;
45809 fail:
45810 return NULL;
45811 }
45812
45813
45814 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45815 PyObject *resultobj = 0;
45816 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45817 int arg2 ;
45818 void *argp1 = 0 ;
45819 int res1 = 0 ;
45820 int val2 ;
45821 int ecode2 = 0 ;
45822 PyObject * obj0 = 0 ;
45823 PyObject * obj1 = 0 ;
45824 char * kwnames[] = {
45825 (char *) "self",(char *) "id", NULL
45826 };
45827
45828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
45829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45830 if (!SWIG_IsOK(res1)) {
45831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45832 }
45833 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45834 ecode2 = SWIG_AsVal_int(obj1, &val2);
45835 if (!SWIG_IsOK(ecode2)) {
45836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
45837 }
45838 arg2 = static_cast< int >(val2);
45839 {
45840 PyThreadState* __tstate = wxPyBeginAllowThreads();
45841 (arg1)->SetId(arg2);
45842 wxPyEndAllowThreads(__tstate);
45843 if (PyErr_Occurred()) SWIG_fail;
45844 }
45845 resultobj = SWIG_Py_Void();
45846 return resultobj;
45847 fail:
45848 return NULL;
45849 }
45850
45851
45852 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45853 PyObject *resultobj = 0;
45854 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45855 int result;
45856 void *argp1 = 0 ;
45857 int res1 = 0 ;
45858 PyObject *swig_obj[1] ;
45859
45860 if (!args) SWIG_fail;
45861 swig_obj[0] = args;
45862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45863 if (!SWIG_IsOK(res1)) {
45864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45865 }
45866 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45867 {
45868 PyThreadState* __tstate = wxPyBeginAllowThreads();
45869 result = (int)((wxMenuItem const *)arg1)->GetId();
45870 wxPyEndAllowThreads(__tstate);
45871 if (PyErr_Occurred()) SWIG_fail;
45872 }
45873 resultobj = SWIG_From_int(static_cast< int >(result));
45874 return resultobj;
45875 fail:
45876 return NULL;
45877 }
45878
45879
45880 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45881 PyObject *resultobj = 0;
45882 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45883 bool result;
45884 void *argp1 = 0 ;
45885 int res1 = 0 ;
45886 PyObject *swig_obj[1] ;
45887
45888 if (!args) SWIG_fail;
45889 swig_obj[0] = args;
45890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45891 if (!SWIG_IsOK(res1)) {
45892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45893 }
45894 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45895 {
45896 PyThreadState* __tstate = wxPyBeginAllowThreads();
45897 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
45898 wxPyEndAllowThreads(__tstate);
45899 if (PyErr_Occurred()) SWIG_fail;
45900 }
45901 {
45902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45903 }
45904 return resultobj;
45905 fail:
45906 return NULL;
45907 }
45908
45909
45910 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45911 PyObject *resultobj = 0;
45912 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45913 wxString *arg2 = 0 ;
45914 void *argp1 = 0 ;
45915 int res1 = 0 ;
45916 bool temp2 = false ;
45917 PyObject * obj0 = 0 ;
45918 PyObject * obj1 = 0 ;
45919 char * kwnames[] = {
45920 (char *) "self",(char *) "str", NULL
45921 };
45922
45923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
45924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45925 if (!SWIG_IsOK(res1)) {
45926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45927 }
45928 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45929 {
45930 arg2 = wxString_in_helper(obj1);
45931 if (arg2 == NULL) SWIG_fail;
45932 temp2 = true;
45933 }
45934 {
45935 PyThreadState* __tstate = wxPyBeginAllowThreads();
45936 (arg1)->SetText((wxString const &)*arg2);
45937 wxPyEndAllowThreads(__tstate);
45938 if (PyErr_Occurred()) SWIG_fail;
45939 }
45940 resultobj = SWIG_Py_Void();
45941 {
45942 if (temp2)
45943 delete arg2;
45944 }
45945 return resultobj;
45946 fail:
45947 {
45948 if (temp2)
45949 delete arg2;
45950 }
45951 return NULL;
45952 }
45953
45954
45955 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45956 PyObject *resultobj = 0;
45957 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45958 wxString result;
45959 void *argp1 = 0 ;
45960 int res1 = 0 ;
45961 PyObject *swig_obj[1] ;
45962
45963 if (!args) SWIG_fail;
45964 swig_obj[0] = args;
45965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45966 if (!SWIG_IsOK(res1)) {
45967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45968 }
45969 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45970 {
45971 PyThreadState* __tstate = wxPyBeginAllowThreads();
45972 result = ((wxMenuItem const *)arg1)->GetLabel();
45973 wxPyEndAllowThreads(__tstate);
45974 if (PyErr_Occurred()) SWIG_fail;
45975 }
45976 {
45977 #if wxUSE_UNICODE
45978 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45979 #else
45980 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45981 #endif
45982 }
45983 return resultobj;
45984 fail:
45985 return NULL;
45986 }
45987
45988
45989 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45990 PyObject *resultobj = 0;
45991 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45992 wxString *result = 0 ;
45993 void *argp1 = 0 ;
45994 int res1 = 0 ;
45995 PyObject *swig_obj[1] ;
45996
45997 if (!args) SWIG_fail;
45998 swig_obj[0] = args;
45999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46000 if (!SWIG_IsOK(res1)) {
46001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46002 }
46003 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46004 {
46005 PyThreadState* __tstate = wxPyBeginAllowThreads();
46006 {
46007 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46008 result = (wxString *) &_result_ref;
46009 }
46010 wxPyEndAllowThreads(__tstate);
46011 if (PyErr_Occurred()) SWIG_fail;
46012 }
46013 {
46014 #if wxUSE_UNICODE
46015 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46016 #else
46017 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46018 #endif
46019 }
46020 return resultobj;
46021 fail:
46022 return NULL;
46023 }
46024
46025
46026 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46027 PyObject *resultobj = 0;
46028 wxString *arg1 = 0 ;
46029 wxString result;
46030 bool temp1 = false ;
46031 PyObject * obj0 = 0 ;
46032 char * kwnames[] = {
46033 (char *) "text", NULL
46034 };
46035
46036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46037 {
46038 arg1 = wxString_in_helper(obj0);
46039 if (arg1 == NULL) SWIG_fail;
46040 temp1 = true;
46041 }
46042 {
46043 PyThreadState* __tstate = wxPyBeginAllowThreads();
46044 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46045 wxPyEndAllowThreads(__tstate);
46046 if (PyErr_Occurred()) SWIG_fail;
46047 }
46048 {
46049 #if wxUSE_UNICODE
46050 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46051 #else
46052 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46053 #endif
46054 }
46055 {
46056 if (temp1)
46057 delete arg1;
46058 }
46059 return resultobj;
46060 fail:
46061 {
46062 if (temp1)
46063 delete arg1;
46064 }
46065 return NULL;
46066 }
46067
46068
46069 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46070 PyObject *resultobj = 0;
46071 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46072 wxItemKind result;
46073 void *argp1 = 0 ;
46074 int res1 = 0 ;
46075 PyObject *swig_obj[1] ;
46076
46077 if (!args) SWIG_fail;
46078 swig_obj[0] = args;
46079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46080 if (!SWIG_IsOK(res1)) {
46081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46082 }
46083 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46084 {
46085 PyThreadState* __tstate = wxPyBeginAllowThreads();
46086 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46087 wxPyEndAllowThreads(__tstate);
46088 if (PyErr_Occurred()) SWIG_fail;
46089 }
46090 resultobj = SWIG_From_int(static_cast< int >(result));
46091 return resultobj;
46092 fail:
46093 return NULL;
46094 }
46095
46096
46097 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46098 PyObject *resultobj = 0;
46099 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46100 wxItemKind arg2 ;
46101 void *argp1 = 0 ;
46102 int res1 = 0 ;
46103 int val2 ;
46104 int ecode2 = 0 ;
46105 PyObject * obj0 = 0 ;
46106 PyObject * obj1 = 0 ;
46107 char * kwnames[] = {
46108 (char *) "self",(char *) "kind", NULL
46109 };
46110
46111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46113 if (!SWIG_IsOK(res1)) {
46114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46115 }
46116 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46117 ecode2 = SWIG_AsVal_int(obj1, &val2);
46118 if (!SWIG_IsOK(ecode2)) {
46119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46120 }
46121 arg2 = static_cast< wxItemKind >(val2);
46122 {
46123 PyThreadState* __tstate = wxPyBeginAllowThreads();
46124 (arg1)->SetKind(arg2);
46125 wxPyEndAllowThreads(__tstate);
46126 if (PyErr_Occurred()) SWIG_fail;
46127 }
46128 resultobj = SWIG_Py_Void();
46129 return resultobj;
46130 fail:
46131 return NULL;
46132 }
46133
46134
46135 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46136 PyObject *resultobj = 0;
46137 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46138 bool arg2 ;
46139 void *argp1 = 0 ;
46140 int res1 = 0 ;
46141 bool val2 ;
46142 int ecode2 = 0 ;
46143 PyObject * obj0 = 0 ;
46144 PyObject * obj1 = 0 ;
46145 char * kwnames[] = {
46146 (char *) "self",(char *) "checkable", NULL
46147 };
46148
46149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46151 if (!SWIG_IsOK(res1)) {
46152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46153 }
46154 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46155 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46156 if (!SWIG_IsOK(ecode2)) {
46157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46158 }
46159 arg2 = static_cast< bool >(val2);
46160 {
46161 PyThreadState* __tstate = wxPyBeginAllowThreads();
46162 (arg1)->SetCheckable(arg2);
46163 wxPyEndAllowThreads(__tstate);
46164 if (PyErr_Occurred()) SWIG_fail;
46165 }
46166 resultobj = SWIG_Py_Void();
46167 return resultobj;
46168 fail:
46169 return NULL;
46170 }
46171
46172
46173 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46174 PyObject *resultobj = 0;
46175 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46176 bool result;
46177 void *argp1 = 0 ;
46178 int res1 = 0 ;
46179 PyObject *swig_obj[1] ;
46180
46181 if (!args) SWIG_fail;
46182 swig_obj[0] = args;
46183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46184 if (!SWIG_IsOK(res1)) {
46185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46186 }
46187 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46188 {
46189 PyThreadState* __tstate = wxPyBeginAllowThreads();
46190 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46191 wxPyEndAllowThreads(__tstate);
46192 if (PyErr_Occurred()) SWIG_fail;
46193 }
46194 {
46195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46196 }
46197 return resultobj;
46198 fail:
46199 return NULL;
46200 }
46201
46202
46203 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46204 PyObject *resultobj = 0;
46205 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46206 bool result;
46207 void *argp1 = 0 ;
46208 int res1 = 0 ;
46209 PyObject *swig_obj[1] ;
46210
46211 if (!args) SWIG_fail;
46212 swig_obj[0] = args;
46213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46214 if (!SWIG_IsOK(res1)) {
46215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46216 }
46217 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46218 {
46219 PyThreadState* __tstate = wxPyBeginAllowThreads();
46220 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46221 wxPyEndAllowThreads(__tstate);
46222 if (PyErr_Occurred()) SWIG_fail;
46223 }
46224 {
46225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46226 }
46227 return resultobj;
46228 fail:
46229 return NULL;
46230 }
46231
46232
46233 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46234 PyObject *resultobj = 0;
46235 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46236 wxMenu *arg2 = (wxMenu *) 0 ;
46237 void *argp1 = 0 ;
46238 int res1 = 0 ;
46239 void *argp2 = 0 ;
46240 int res2 = 0 ;
46241 PyObject * obj0 = 0 ;
46242 PyObject * obj1 = 0 ;
46243 char * kwnames[] = {
46244 (char *) "self",(char *) "menu", NULL
46245 };
46246
46247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46249 if (!SWIG_IsOK(res1)) {
46250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46251 }
46252 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46253 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46254 if (!SWIG_IsOK(res2)) {
46255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46256 }
46257 arg2 = reinterpret_cast< wxMenu * >(argp2);
46258 {
46259 PyThreadState* __tstate = wxPyBeginAllowThreads();
46260 (arg1)->SetSubMenu(arg2);
46261 wxPyEndAllowThreads(__tstate);
46262 if (PyErr_Occurred()) SWIG_fail;
46263 }
46264 resultobj = SWIG_Py_Void();
46265 return resultobj;
46266 fail:
46267 return NULL;
46268 }
46269
46270
46271 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46272 PyObject *resultobj = 0;
46273 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46274 wxMenu *result = 0 ;
46275 void *argp1 = 0 ;
46276 int res1 = 0 ;
46277 PyObject *swig_obj[1] ;
46278
46279 if (!args) SWIG_fail;
46280 swig_obj[0] = args;
46281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46282 if (!SWIG_IsOK(res1)) {
46283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46284 }
46285 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46286 {
46287 PyThreadState* __tstate = wxPyBeginAllowThreads();
46288 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46289 wxPyEndAllowThreads(__tstate);
46290 if (PyErr_Occurred()) SWIG_fail;
46291 }
46292 {
46293 resultobj = wxPyMake_wxObject(result, 0);
46294 }
46295 return resultobj;
46296 fail:
46297 return NULL;
46298 }
46299
46300
46301 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46302 PyObject *resultobj = 0;
46303 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46304 bool arg2 = (bool) true ;
46305 void *argp1 = 0 ;
46306 int res1 = 0 ;
46307 bool val2 ;
46308 int ecode2 = 0 ;
46309 PyObject * obj0 = 0 ;
46310 PyObject * obj1 = 0 ;
46311 char * kwnames[] = {
46312 (char *) "self",(char *) "enable", NULL
46313 };
46314
46315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46317 if (!SWIG_IsOK(res1)) {
46318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46319 }
46320 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46321 if (obj1) {
46322 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46323 if (!SWIG_IsOK(ecode2)) {
46324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46325 }
46326 arg2 = static_cast< bool >(val2);
46327 }
46328 {
46329 PyThreadState* __tstate = wxPyBeginAllowThreads();
46330 (arg1)->Enable(arg2);
46331 wxPyEndAllowThreads(__tstate);
46332 if (PyErr_Occurred()) SWIG_fail;
46333 }
46334 resultobj = SWIG_Py_Void();
46335 return resultobj;
46336 fail:
46337 return NULL;
46338 }
46339
46340
46341 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46342 PyObject *resultobj = 0;
46343 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46344 bool result;
46345 void *argp1 = 0 ;
46346 int res1 = 0 ;
46347 PyObject *swig_obj[1] ;
46348
46349 if (!args) SWIG_fail;
46350 swig_obj[0] = args;
46351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46352 if (!SWIG_IsOK(res1)) {
46353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46354 }
46355 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46356 {
46357 PyThreadState* __tstate = wxPyBeginAllowThreads();
46358 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46359 wxPyEndAllowThreads(__tstate);
46360 if (PyErr_Occurred()) SWIG_fail;
46361 }
46362 {
46363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46364 }
46365 return resultobj;
46366 fail:
46367 return NULL;
46368 }
46369
46370
46371 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46372 PyObject *resultobj = 0;
46373 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46374 bool arg2 = (bool) true ;
46375 void *argp1 = 0 ;
46376 int res1 = 0 ;
46377 bool val2 ;
46378 int ecode2 = 0 ;
46379 PyObject * obj0 = 0 ;
46380 PyObject * obj1 = 0 ;
46381 char * kwnames[] = {
46382 (char *) "self",(char *) "check", NULL
46383 };
46384
46385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46387 if (!SWIG_IsOK(res1)) {
46388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46389 }
46390 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46391 if (obj1) {
46392 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46393 if (!SWIG_IsOK(ecode2)) {
46394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46395 }
46396 arg2 = static_cast< bool >(val2);
46397 }
46398 {
46399 PyThreadState* __tstate = wxPyBeginAllowThreads();
46400 (arg1)->Check(arg2);
46401 wxPyEndAllowThreads(__tstate);
46402 if (PyErr_Occurred()) SWIG_fail;
46403 }
46404 resultobj = SWIG_Py_Void();
46405 return resultobj;
46406 fail:
46407 return NULL;
46408 }
46409
46410
46411 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46412 PyObject *resultobj = 0;
46413 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46414 bool result;
46415 void *argp1 = 0 ;
46416 int res1 = 0 ;
46417 PyObject *swig_obj[1] ;
46418
46419 if (!args) SWIG_fail;
46420 swig_obj[0] = args;
46421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46422 if (!SWIG_IsOK(res1)) {
46423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46424 }
46425 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46426 {
46427 PyThreadState* __tstate = wxPyBeginAllowThreads();
46428 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46429 wxPyEndAllowThreads(__tstate);
46430 if (PyErr_Occurred()) SWIG_fail;
46431 }
46432 {
46433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46434 }
46435 return resultobj;
46436 fail:
46437 return NULL;
46438 }
46439
46440
46441 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46442 PyObject *resultobj = 0;
46443 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46444 void *argp1 = 0 ;
46445 int res1 = 0 ;
46446 PyObject *swig_obj[1] ;
46447
46448 if (!args) SWIG_fail;
46449 swig_obj[0] = args;
46450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46451 if (!SWIG_IsOK(res1)) {
46452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46453 }
46454 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46455 {
46456 PyThreadState* __tstate = wxPyBeginAllowThreads();
46457 (arg1)->Toggle();
46458 wxPyEndAllowThreads(__tstate);
46459 if (PyErr_Occurred()) SWIG_fail;
46460 }
46461 resultobj = SWIG_Py_Void();
46462 return resultobj;
46463 fail:
46464 return NULL;
46465 }
46466
46467
46468 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46469 PyObject *resultobj = 0;
46470 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46471 wxString *arg2 = 0 ;
46472 void *argp1 = 0 ;
46473 int res1 = 0 ;
46474 bool temp2 = false ;
46475 PyObject * obj0 = 0 ;
46476 PyObject * obj1 = 0 ;
46477 char * kwnames[] = {
46478 (char *) "self",(char *) "str", NULL
46479 };
46480
46481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46483 if (!SWIG_IsOK(res1)) {
46484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46485 }
46486 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46487 {
46488 arg2 = wxString_in_helper(obj1);
46489 if (arg2 == NULL) SWIG_fail;
46490 temp2 = true;
46491 }
46492 {
46493 PyThreadState* __tstate = wxPyBeginAllowThreads();
46494 (arg1)->SetHelp((wxString const &)*arg2);
46495 wxPyEndAllowThreads(__tstate);
46496 if (PyErr_Occurred()) SWIG_fail;
46497 }
46498 resultobj = SWIG_Py_Void();
46499 {
46500 if (temp2)
46501 delete arg2;
46502 }
46503 return resultobj;
46504 fail:
46505 {
46506 if (temp2)
46507 delete arg2;
46508 }
46509 return NULL;
46510 }
46511
46512
46513 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46514 PyObject *resultobj = 0;
46515 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46516 wxString *result = 0 ;
46517 void *argp1 = 0 ;
46518 int res1 = 0 ;
46519 PyObject *swig_obj[1] ;
46520
46521 if (!args) SWIG_fail;
46522 swig_obj[0] = args;
46523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46524 if (!SWIG_IsOK(res1)) {
46525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46526 }
46527 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46528 {
46529 PyThreadState* __tstate = wxPyBeginAllowThreads();
46530 {
46531 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46532 result = (wxString *) &_result_ref;
46533 }
46534 wxPyEndAllowThreads(__tstate);
46535 if (PyErr_Occurred()) SWIG_fail;
46536 }
46537 {
46538 #if wxUSE_UNICODE
46539 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46540 #else
46541 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46542 #endif
46543 }
46544 return resultobj;
46545 fail:
46546 return NULL;
46547 }
46548
46549
46550 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46551 PyObject *resultobj = 0;
46552 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46553 wxAcceleratorEntry *result = 0 ;
46554 void *argp1 = 0 ;
46555 int res1 = 0 ;
46556 PyObject *swig_obj[1] ;
46557
46558 if (!args) SWIG_fail;
46559 swig_obj[0] = args;
46560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46561 if (!SWIG_IsOK(res1)) {
46562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46563 }
46564 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46565 {
46566 PyThreadState* __tstate = wxPyBeginAllowThreads();
46567 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46568 wxPyEndAllowThreads(__tstate);
46569 if (PyErr_Occurred()) SWIG_fail;
46570 }
46571 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46572 return resultobj;
46573 fail:
46574 return NULL;
46575 }
46576
46577
46578 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46579 PyObject *resultobj = 0;
46580 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46581 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46582 void *argp1 = 0 ;
46583 int res1 = 0 ;
46584 void *argp2 = 0 ;
46585 int res2 = 0 ;
46586 PyObject * obj0 = 0 ;
46587 PyObject * obj1 = 0 ;
46588 char * kwnames[] = {
46589 (char *) "self",(char *) "accel", NULL
46590 };
46591
46592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46594 if (!SWIG_IsOK(res1)) {
46595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46596 }
46597 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46598 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46599 if (!SWIG_IsOK(res2)) {
46600 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46601 }
46602 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46603 {
46604 PyThreadState* __tstate = wxPyBeginAllowThreads();
46605 (arg1)->SetAccel(arg2);
46606 wxPyEndAllowThreads(__tstate);
46607 if (PyErr_Occurred()) SWIG_fail;
46608 }
46609 resultobj = SWIG_Py_Void();
46610 return resultobj;
46611 fail:
46612 return NULL;
46613 }
46614
46615
46616 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46617 PyObject *resultobj = 0;
46618 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46619 wxBitmap *arg2 = 0 ;
46620 void *argp1 = 0 ;
46621 int res1 = 0 ;
46622 void *argp2 = 0 ;
46623 int res2 = 0 ;
46624 PyObject * obj0 = 0 ;
46625 PyObject * obj1 = 0 ;
46626 char * kwnames[] = {
46627 (char *) "self",(char *) "bitmap", NULL
46628 };
46629
46630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46632 if (!SWIG_IsOK(res1)) {
46633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46634 }
46635 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46636 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46637 if (!SWIG_IsOK(res2)) {
46638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46639 }
46640 if (!argp2) {
46641 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46642 }
46643 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46644 {
46645 PyThreadState* __tstate = wxPyBeginAllowThreads();
46646 (arg1)->SetBitmap((wxBitmap const &)*arg2);
46647 wxPyEndAllowThreads(__tstate);
46648 if (PyErr_Occurred()) SWIG_fail;
46649 }
46650 resultobj = SWIG_Py_Void();
46651 return resultobj;
46652 fail:
46653 return NULL;
46654 }
46655
46656
46657 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46658 PyObject *resultobj = 0;
46659 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46660 wxBitmap *result = 0 ;
46661 void *argp1 = 0 ;
46662 int res1 = 0 ;
46663 PyObject *swig_obj[1] ;
46664
46665 if (!args) SWIG_fail;
46666 swig_obj[0] = args;
46667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46668 if (!SWIG_IsOK(res1)) {
46669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46670 }
46671 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46672 {
46673 PyThreadState* __tstate = wxPyBeginAllowThreads();
46674 {
46675 wxBitmap const &_result_ref = (arg1)->GetBitmap();
46676 result = (wxBitmap *) &_result_ref;
46677 }
46678 wxPyEndAllowThreads(__tstate);
46679 if (PyErr_Occurred()) SWIG_fail;
46680 }
46681 {
46682 wxBitmap* resultptr = new wxBitmap(*result);
46683 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46684 }
46685 return resultobj;
46686 fail:
46687 return NULL;
46688 }
46689
46690
46691 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46692 PyObject *resultobj = 0;
46693 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46694 wxFont *arg2 = 0 ;
46695 void *argp1 = 0 ;
46696 int res1 = 0 ;
46697 void *argp2 = 0 ;
46698 int res2 = 0 ;
46699 PyObject * obj0 = 0 ;
46700 PyObject * obj1 = 0 ;
46701 char * kwnames[] = {
46702 (char *) "self",(char *) "font", NULL
46703 };
46704
46705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
46706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46707 if (!SWIG_IsOK(res1)) {
46708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46709 }
46710 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46711 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
46712 if (!SWIG_IsOK(res2)) {
46713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46714 }
46715 if (!argp2) {
46716 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46717 }
46718 arg2 = reinterpret_cast< wxFont * >(argp2);
46719 {
46720 PyThreadState* __tstate = wxPyBeginAllowThreads();
46721 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
46722 wxPyEndAllowThreads(__tstate);
46723 if (PyErr_Occurred()) SWIG_fail;
46724 }
46725 resultobj = SWIG_Py_Void();
46726 return resultobj;
46727 fail:
46728 return NULL;
46729 }
46730
46731
46732 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46733 PyObject *resultobj = 0;
46734 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46735 wxFont result;
46736 void *argp1 = 0 ;
46737 int res1 = 0 ;
46738 PyObject *swig_obj[1] ;
46739
46740 if (!args) SWIG_fail;
46741 swig_obj[0] = args;
46742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46743 if (!SWIG_IsOK(res1)) {
46744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46745 }
46746 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46747 {
46748 PyThreadState* __tstate = wxPyBeginAllowThreads();
46749 result = wxMenuItem_GetFont(arg1);
46750 wxPyEndAllowThreads(__tstate);
46751 if (PyErr_Occurred()) SWIG_fail;
46752 }
46753 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
46754 return resultobj;
46755 fail:
46756 return NULL;
46757 }
46758
46759
46760 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46761 PyObject *resultobj = 0;
46762 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46763 wxColour *arg2 = 0 ;
46764 void *argp1 = 0 ;
46765 int res1 = 0 ;
46766 wxColour temp2 ;
46767 PyObject * obj0 = 0 ;
46768 PyObject * obj1 = 0 ;
46769 char * kwnames[] = {
46770 (char *) "self",(char *) "colText", NULL
46771 };
46772
46773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
46774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46775 if (!SWIG_IsOK(res1)) {
46776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46777 }
46778 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46779 {
46780 arg2 = &temp2;
46781 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46782 }
46783 {
46784 PyThreadState* __tstate = wxPyBeginAllowThreads();
46785 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
46786 wxPyEndAllowThreads(__tstate);
46787 if (PyErr_Occurred()) SWIG_fail;
46788 }
46789 resultobj = SWIG_Py_Void();
46790 return resultobj;
46791 fail:
46792 return NULL;
46793 }
46794
46795
46796 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46797 PyObject *resultobj = 0;
46798 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46799 wxColour result;
46800 void *argp1 = 0 ;
46801 int res1 = 0 ;
46802 PyObject *swig_obj[1] ;
46803
46804 if (!args) SWIG_fail;
46805 swig_obj[0] = args;
46806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46807 if (!SWIG_IsOK(res1)) {
46808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46809 }
46810 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46811 {
46812 PyThreadState* __tstate = wxPyBeginAllowThreads();
46813 result = wxMenuItem_GetTextColour(arg1);
46814 wxPyEndAllowThreads(__tstate);
46815 if (PyErr_Occurred()) SWIG_fail;
46816 }
46817 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46818 return resultobj;
46819 fail:
46820 return NULL;
46821 }
46822
46823
46824 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46825 PyObject *resultobj = 0;
46826 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46827 wxColour *arg2 = 0 ;
46828 void *argp1 = 0 ;
46829 int res1 = 0 ;
46830 wxColour temp2 ;
46831 PyObject * obj0 = 0 ;
46832 PyObject * obj1 = 0 ;
46833 char * kwnames[] = {
46834 (char *) "self",(char *) "colBack", NULL
46835 };
46836
46837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
46838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46839 if (!SWIG_IsOK(res1)) {
46840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46841 }
46842 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46843 {
46844 arg2 = &temp2;
46845 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46846 }
46847 {
46848 PyThreadState* __tstate = wxPyBeginAllowThreads();
46849 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
46850 wxPyEndAllowThreads(__tstate);
46851 if (PyErr_Occurred()) SWIG_fail;
46852 }
46853 resultobj = SWIG_Py_Void();
46854 return resultobj;
46855 fail:
46856 return NULL;
46857 }
46858
46859
46860 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46861 PyObject *resultobj = 0;
46862 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46863 wxColour result;
46864 void *argp1 = 0 ;
46865 int res1 = 0 ;
46866 PyObject *swig_obj[1] ;
46867
46868 if (!args) SWIG_fail;
46869 swig_obj[0] = args;
46870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46871 if (!SWIG_IsOK(res1)) {
46872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46873 }
46874 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46875 {
46876 PyThreadState* __tstate = wxPyBeginAllowThreads();
46877 result = wxMenuItem_GetBackgroundColour(arg1);
46878 wxPyEndAllowThreads(__tstate);
46879 if (PyErr_Occurred()) SWIG_fail;
46880 }
46881 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46882 return resultobj;
46883 fail:
46884 return NULL;
46885 }
46886
46887
46888 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46889 PyObject *resultobj = 0;
46890 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46891 wxBitmap *arg2 = 0 ;
46892 wxBitmap const &arg3_defvalue = wxNullBitmap ;
46893 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
46894 void *argp1 = 0 ;
46895 int res1 = 0 ;
46896 void *argp2 = 0 ;
46897 int res2 = 0 ;
46898 void *argp3 = 0 ;
46899 int res3 = 0 ;
46900 PyObject * obj0 = 0 ;
46901 PyObject * obj1 = 0 ;
46902 PyObject * obj2 = 0 ;
46903 char * kwnames[] = {
46904 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
46905 };
46906
46907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46909 if (!SWIG_IsOK(res1)) {
46910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46911 }
46912 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46913 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46914 if (!SWIG_IsOK(res2)) {
46915 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46916 }
46917 if (!argp2) {
46918 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46919 }
46920 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46921 if (obj2) {
46922 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
46923 if (!SWIG_IsOK(res3)) {
46924 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46925 }
46926 if (!argp3) {
46927 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46928 }
46929 arg3 = reinterpret_cast< wxBitmap * >(argp3);
46930 }
46931 {
46932 PyThreadState* __tstate = wxPyBeginAllowThreads();
46933 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
46934 wxPyEndAllowThreads(__tstate);
46935 if (PyErr_Occurred()) SWIG_fail;
46936 }
46937 resultobj = SWIG_Py_Void();
46938 return resultobj;
46939 fail:
46940 return NULL;
46941 }
46942
46943
46944 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46945 PyObject *resultobj = 0;
46946 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46947 wxBitmap *arg2 = 0 ;
46948 void *argp1 = 0 ;
46949 int res1 = 0 ;
46950 void *argp2 = 0 ;
46951 int res2 = 0 ;
46952 PyObject * obj0 = 0 ;
46953 PyObject * obj1 = 0 ;
46954 char * kwnames[] = {
46955 (char *) "self",(char *) "bmpDisabled", NULL
46956 };
46957
46958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46960 if (!SWIG_IsOK(res1)) {
46961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46962 }
46963 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46964 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46965 if (!SWIG_IsOK(res2)) {
46966 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46967 }
46968 if (!argp2) {
46969 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46970 }
46971 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46972 {
46973 PyThreadState* __tstate = wxPyBeginAllowThreads();
46974 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
46975 wxPyEndAllowThreads(__tstate);
46976 if (PyErr_Occurred()) SWIG_fail;
46977 }
46978 resultobj = SWIG_Py_Void();
46979 return resultobj;
46980 fail:
46981 return NULL;
46982 }
46983
46984
46985 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46986 PyObject *resultobj = 0;
46987 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46988 wxBitmap *result = 0 ;
46989 void *argp1 = 0 ;
46990 int res1 = 0 ;
46991 PyObject *swig_obj[1] ;
46992
46993 if (!args) SWIG_fail;
46994 swig_obj[0] = args;
46995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46996 if (!SWIG_IsOK(res1)) {
46997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46998 }
46999 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47000 {
47001 PyThreadState* __tstate = wxPyBeginAllowThreads();
47002 {
47003 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
47004 result = (wxBitmap *) &_result_ref;
47005 }
47006 wxPyEndAllowThreads(__tstate);
47007 if (PyErr_Occurred()) SWIG_fail;
47008 }
47009 {
47010 wxBitmap* resultptr = new wxBitmap(*result);
47011 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47012 }
47013 return resultobj;
47014 fail:
47015 return NULL;
47016 }
47017
47018
47019 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47020 PyObject *resultobj = 0;
47021 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47022 int arg2 ;
47023 void *argp1 = 0 ;
47024 int res1 = 0 ;
47025 int val2 ;
47026 int ecode2 = 0 ;
47027 PyObject * obj0 = 0 ;
47028 PyObject * obj1 = 0 ;
47029 char * kwnames[] = {
47030 (char *) "self",(char *) "nWidth", NULL
47031 };
47032
47033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47035 if (!SWIG_IsOK(res1)) {
47036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47037 }
47038 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47039 ecode2 = SWIG_AsVal_int(obj1, &val2);
47040 if (!SWIG_IsOK(ecode2)) {
47041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47042 }
47043 arg2 = static_cast< int >(val2);
47044 {
47045 PyThreadState* __tstate = wxPyBeginAllowThreads();
47046 wxMenuItem_SetMarginWidth(arg1,arg2);
47047 wxPyEndAllowThreads(__tstate);
47048 if (PyErr_Occurred()) SWIG_fail;
47049 }
47050 resultobj = SWIG_Py_Void();
47051 return resultobj;
47052 fail:
47053 return NULL;
47054 }
47055
47056
47057 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47058 PyObject *resultobj = 0;
47059 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47060 int result;
47061 void *argp1 = 0 ;
47062 int res1 = 0 ;
47063 PyObject *swig_obj[1] ;
47064
47065 if (!args) SWIG_fail;
47066 swig_obj[0] = args;
47067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47068 if (!SWIG_IsOK(res1)) {
47069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47070 }
47071 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47072 {
47073 PyThreadState* __tstate = wxPyBeginAllowThreads();
47074 result = (int)wxMenuItem_GetMarginWidth(arg1);
47075 wxPyEndAllowThreads(__tstate);
47076 if (PyErr_Occurred()) SWIG_fail;
47077 }
47078 resultobj = SWIG_From_int(static_cast< int >(result));
47079 return resultobj;
47080 fail:
47081 return NULL;
47082 }
47083
47084
47085 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47086 PyObject *resultobj = 0;
47087 int result;
47088
47089 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47090 {
47091 PyThreadState* __tstate = wxPyBeginAllowThreads();
47092 result = (int)wxMenuItem_GetDefaultMarginWidth();
47093 wxPyEndAllowThreads(__tstate);
47094 if (PyErr_Occurred()) SWIG_fail;
47095 }
47096 resultobj = SWIG_From_int(static_cast< int >(result));
47097 return resultobj;
47098 fail:
47099 return NULL;
47100 }
47101
47102
47103 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47104 PyObject *resultobj = 0;
47105 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47106 bool result;
47107 void *argp1 = 0 ;
47108 int res1 = 0 ;
47109 PyObject *swig_obj[1] ;
47110
47111 if (!args) SWIG_fail;
47112 swig_obj[0] = args;
47113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47114 if (!SWIG_IsOK(res1)) {
47115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47116 }
47117 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47118 {
47119 PyThreadState* __tstate = wxPyBeginAllowThreads();
47120 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
47121 wxPyEndAllowThreads(__tstate);
47122 if (PyErr_Occurred()) SWIG_fail;
47123 }
47124 {
47125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47126 }
47127 return resultobj;
47128 fail:
47129 return NULL;
47130 }
47131
47132
47133 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47134 PyObject *resultobj = 0;
47135 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47136 bool arg2 = (bool) true ;
47137 void *argp1 = 0 ;
47138 int res1 = 0 ;
47139 bool val2 ;
47140 int ecode2 = 0 ;
47141 PyObject * obj0 = 0 ;
47142 PyObject * obj1 = 0 ;
47143 char * kwnames[] = {
47144 (char *) "self",(char *) "ownerDrawn", NULL
47145 };
47146
47147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47149 if (!SWIG_IsOK(res1)) {
47150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47151 }
47152 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47153 if (obj1) {
47154 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47155 if (!SWIG_IsOK(ecode2)) {
47156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47157 }
47158 arg2 = static_cast< bool >(val2);
47159 }
47160 {
47161 PyThreadState* __tstate = wxPyBeginAllowThreads();
47162 wxMenuItem_SetOwnerDrawn(arg1,arg2);
47163 wxPyEndAllowThreads(__tstate);
47164 if (PyErr_Occurred()) SWIG_fail;
47165 }
47166 resultobj = SWIG_Py_Void();
47167 return resultobj;
47168 fail:
47169 return NULL;
47170 }
47171
47172
47173 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47174 PyObject *resultobj = 0;
47175 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47176 void *argp1 = 0 ;
47177 int res1 = 0 ;
47178 PyObject *swig_obj[1] ;
47179
47180 if (!args) SWIG_fail;
47181 swig_obj[0] = args;
47182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47183 if (!SWIG_IsOK(res1)) {
47184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47185 }
47186 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47187 {
47188 PyThreadState* __tstate = wxPyBeginAllowThreads();
47189 wxMenuItem_ResetOwnerDrawn(arg1);
47190 wxPyEndAllowThreads(__tstate);
47191 if (PyErr_Occurred()) SWIG_fail;
47192 }
47193 resultobj = SWIG_Py_Void();
47194 return resultobj;
47195 fail:
47196 return NULL;
47197 }
47198
47199
47200 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47201 PyObject *obj;
47202 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47203 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47204 return SWIG_Py_Void();
47205 }
47206
47207 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47208 return SWIG_Python_InitShadowInstance(args);
47209 }
47210
47211 SWIGINTERN int ControlNameStr_set(PyObject *) {
47212 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47213 return 1;
47214 }
47215
47216
47217 SWIGINTERN PyObject *ControlNameStr_get(void) {
47218 PyObject *pyobj = 0;
47219
47220 {
47221 #if wxUSE_UNICODE
47222 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47223 #else
47224 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47225 #endif
47226 }
47227 return pyobj;
47228 }
47229
47230
47231 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47232 PyObject *resultobj = 0;
47233 wxWindow *arg1 = (wxWindow *) 0 ;
47234 int arg2 = (int) -1 ;
47235 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47236 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47237 wxSize const &arg4_defvalue = wxDefaultSize ;
47238 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47239 long arg5 = (long) 0 ;
47240 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47241 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47242 wxString const &arg7_defvalue = wxPyControlNameStr ;
47243 wxString *arg7 = (wxString *) &arg7_defvalue ;
47244 wxControl *result = 0 ;
47245 void *argp1 = 0 ;
47246 int res1 = 0 ;
47247 int val2 ;
47248 int ecode2 = 0 ;
47249 wxPoint temp3 ;
47250 wxSize temp4 ;
47251 long val5 ;
47252 int ecode5 = 0 ;
47253 void *argp6 = 0 ;
47254 int res6 = 0 ;
47255 bool temp7 = false ;
47256 PyObject * obj0 = 0 ;
47257 PyObject * obj1 = 0 ;
47258 PyObject * obj2 = 0 ;
47259 PyObject * obj3 = 0 ;
47260 PyObject * obj4 = 0 ;
47261 PyObject * obj5 = 0 ;
47262 PyObject * obj6 = 0 ;
47263 char * kwnames[] = {
47264 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47265 };
47266
47267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47269 if (!SWIG_IsOK(res1)) {
47270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47271 }
47272 arg1 = reinterpret_cast< wxWindow * >(argp1);
47273 if (obj1) {
47274 ecode2 = SWIG_AsVal_int(obj1, &val2);
47275 if (!SWIG_IsOK(ecode2)) {
47276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47277 }
47278 arg2 = static_cast< int >(val2);
47279 }
47280 if (obj2) {
47281 {
47282 arg3 = &temp3;
47283 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47284 }
47285 }
47286 if (obj3) {
47287 {
47288 arg4 = &temp4;
47289 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47290 }
47291 }
47292 if (obj4) {
47293 ecode5 = SWIG_AsVal_long(obj4, &val5);
47294 if (!SWIG_IsOK(ecode5)) {
47295 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47296 }
47297 arg5 = static_cast< long >(val5);
47298 }
47299 if (obj5) {
47300 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47301 if (!SWIG_IsOK(res6)) {
47302 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47303 }
47304 if (!argp6) {
47305 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47306 }
47307 arg6 = reinterpret_cast< wxValidator * >(argp6);
47308 }
47309 if (obj6) {
47310 {
47311 arg7 = wxString_in_helper(obj6);
47312 if (arg7 == NULL) SWIG_fail;
47313 temp7 = true;
47314 }
47315 }
47316 {
47317 if (!wxPyCheckForApp()) SWIG_fail;
47318 PyThreadState* __tstate = wxPyBeginAllowThreads();
47319 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47320 wxPyEndAllowThreads(__tstate);
47321 if (PyErr_Occurred()) SWIG_fail;
47322 }
47323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47324 {
47325 if (temp7)
47326 delete arg7;
47327 }
47328 return resultobj;
47329 fail:
47330 {
47331 if (temp7)
47332 delete arg7;
47333 }
47334 return NULL;
47335 }
47336
47337
47338 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47339 PyObject *resultobj = 0;
47340 wxControl *result = 0 ;
47341
47342 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47343 {
47344 if (!wxPyCheckForApp()) SWIG_fail;
47345 PyThreadState* __tstate = wxPyBeginAllowThreads();
47346 result = (wxControl *)new wxControl();
47347 wxPyEndAllowThreads(__tstate);
47348 if (PyErr_Occurred()) SWIG_fail;
47349 }
47350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47351 return resultobj;
47352 fail:
47353 return NULL;
47354 }
47355
47356
47357 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47358 PyObject *resultobj = 0;
47359 wxControl *arg1 = (wxControl *) 0 ;
47360 wxWindow *arg2 = (wxWindow *) 0 ;
47361 int arg3 = (int) -1 ;
47362 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47363 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47364 wxSize const &arg5_defvalue = wxDefaultSize ;
47365 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47366 long arg6 = (long) 0 ;
47367 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47368 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47369 wxString const &arg8_defvalue = wxPyControlNameStr ;
47370 wxString *arg8 = (wxString *) &arg8_defvalue ;
47371 bool result;
47372 void *argp1 = 0 ;
47373 int res1 = 0 ;
47374 void *argp2 = 0 ;
47375 int res2 = 0 ;
47376 int val3 ;
47377 int ecode3 = 0 ;
47378 wxPoint temp4 ;
47379 wxSize temp5 ;
47380 long val6 ;
47381 int ecode6 = 0 ;
47382 void *argp7 = 0 ;
47383 int res7 = 0 ;
47384 bool temp8 = false ;
47385 PyObject * obj0 = 0 ;
47386 PyObject * obj1 = 0 ;
47387 PyObject * obj2 = 0 ;
47388 PyObject * obj3 = 0 ;
47389 PyObject * obj4 = 0 ;
47390 PyObject * obj5 = 0 ;
47391 PyObject * obj6 = 0 ;
47392 PyObject * obj7 = 0 ;
47393 char * kwnames[] = {
47394 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47395 };
47396
47397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47399 if (!SWIG_IsOK(res1)) {
47400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47401 }
47402 arg1 = reinterpret_cast< wxControl * >(argp1);
47403 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47404 if (!SWIG_IsOK(res2)) {
47405 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47406 }
47407 arg2 = reinterpret_cast< wxWindow * >(argp2);
47408 if (obj2) {
47409 ecode3 = SWIG_AsVal_int(obj2, &val3);
47410 if (!SWIG_IsOK(ecode3)) {
47411 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47412 }
47413 arg3 = static_cast< int >(val3);
47414 }
47415 if (obj3) {
47416 {
47417 arg4 = &temp4;
47418 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47419 }
47420 }
47421 if (obj4) {
47422 {
47423 arg5 = &temp5;
47424 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47425 }
47426 }
47427 if (obj5) {
47428 ecode6 = SWIG_AsVal_long(obj5, &val6);
47429 if (!SWIG_IsOK(ecode6)) {
47430 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47431 }
47432 arg6 = static_cast< long >(val6);
47433 }
47434 if (obj6) {
47435 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47436 if (!SWIG_IsOK(res7)) {
47437 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47438 }
47439 if (!argp7) {
47440 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47441 }
47442 arg7 = reinterpret_cast< wxValidator * >(argp7);
47443 }
47444 if (obj7) {
47445 {
47446 arg8 = wxString_in_helper(obj7);
47447 if (arg8 == NULL) SWIG_fail;
47448 temp8 = true;
47449 }
47450 }
47451 {
47452 PyThreadState* __tstate = wxPyBeginAllowThreads();
47453 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47454 wxPyEndAllowThreads(__tstate);
47455 if (PyErr_Occurred()) SWIG_fail;
47456 }
47457 {
47458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47459 }
47460 {
47461 if (temp8)
47462 delete arg8;
47463 }
47464 return resultobj;
47465 fail:
47466 {
47467 if (temp8)
47468 delete arg8;
47469 }
47470 return NULL;
47471 }
47472
47473
47474 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47475 PyObject *resultobj = 0;
47476 wxControl *arg1 = (wxControl *) 0 ;
47477 int result;
47478 void *argp1 = 0 ;
47479 int res1 = 0 ;
47480 PyObject *swig_obj[1] ;
47481
47482 if (!args) SWIG_fail;
47483 swig_obj[0] = args;
47484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47485 if (!SWIG_IsOK(res1)) {
47486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47487 }
47488 arg1 = reinterpret_cast< wxControl * >(argp1);
47489 {
47490 PyThreadState* __tstate = wxPyBeginAllowThreads();
47491 result = (int)((wxControl const *)arg1)->GetAlignment();
47492 wxPyEndAllowThreads(__tstate);
47493 if (PyErr_Occurred()) SWIG_fail;
47494 }
47495 resultobj = SWIG_From_int(static_cast< int >(result));
47496 return resultobj;
47497 fail:
47498 return NULL;
47499 }
47500
47501
47502 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47503 PyObject *resultobj = 0;
47504 wxControl *arg1 = (wxControl *) 0 ;
47505 wxString result;
47506 void *argp1 = 0 ;
47507 int res1 = 0 ;
47508 PyObject *swig_obj[1] ;
47509
47510 if (!args) SWIG_fail;
47511 swig_obj[0] = args;
47512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47513 if (!SWIG_IsOK(res1)) {
47514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47515 }
47516 arg1 = reinterpret_cast< wxControl * >(argp1);
47517 {
47518 PyThreadState* __tstate = wxPyBeginAllowThreads();
47519 result = ((wxControl const *)arg1)->GetLabelText();
47520 wxPyEndAllowThreads(__tstate);
47521 if (PyErr_Occurred()) SWIG_fail;
47522 }
47523 {
47524 #if wxUSE_UNICODE
47525 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47526 #else
47527 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47528 #endif
47529 }
47530 return resultobj;
47531 fail:
47532 return NULL;
47533 }
47534
47535
47536 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47537 PyObject *resultobj = 0;
47538 wxControl *arg1 = (wxControl *) 0 ;
47539 wxCommandEvent *arg2 = 0 ;
47540 void *argp1 = 0 ;
47541 int res1 = 0 ;
47542 void *argp2 = 0 ;
47543 int res2 = 0 ;
47544 PyObject * obj0 = 0 ;
47545 PyObject * obj1 = 0 ;
47546 char * kwnames[] = {
47547 (char *) "self",(char *) "event", NULL
47548 };
47549
47550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47552 if (!SWIG_IsOK(res1)) {
47553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47554 }
47555 arg1 = reinterpret_cast< wxControl * >(argp1);
47556 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47557 if (!SWIG_IsOK(res2)) {
47558 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47559 }
47560 if (!argp2) {
47561 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47562 }
47563 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47564 {
47565 PyThreadState* __tstate = wxPyBeginAllowThreads();
47566 (arg1)->Command(*arg2);
47567 wxPyEndAllowThreads(__tstate);
47568 if (PyErr_Occurred()) SWIG_fail;
47569 }
47570 resultobj = SWIG_Py_Void();
47571 return resultobj;
47572 fail:
47573 return NULL;
47574 }
47575
47576
47577 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47578 PyObject *resultobj = 0;
47579 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47580 SwigValueWrapper<wxVisualAttributes > result;
47581 int val1 ;
47582 int ecode1 = 0 ;
47583 PyObject * obj0 = 0 ;
47584 char * kwnames[] = {
47585 (char *) "variant", NULL
47586 };
47587
47588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47589 if (obj0) {
47590 ecode1 = SWIG_AsVal_int(obj0, &val1);
47591 if (!SWIG_IsOK(ecode1)) {
47592 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47593 }
47594 arg1 = static_cast< wxWindowVariant >(val1);
47595 }
47596 {
47597 if (!wxPyCheckForApp()) SWIG_fail;
47598 PyThreadState* __tstate = wxPyBeginAllowThreads();
47599 result = wxControl::GetClassDefaultAttributes(arg1);
47600 wxPyEndAllowThreads(__tstate);
47601 if (PyErr_Occurred()) SWIG_fail;
47602 }
47603 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47604 return resultobj;
47605 fail:
47606 return NULL;
47607 }
47608
47609
47610 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47611 PyObject *obj;
47612 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47613 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47614 return SWIG_Py_Void();
47615 }
47616
47617 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47618 return SWIG_Python_InitShadowInstance(args);
47619 }
47620
47621 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47622 PyObject *resultobj = 0;
47623 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47624 wxString *arg2 = 0 ;
47625 PyObject *arg3 = (PyObject *) NULL ;
47626 int result;
47627 void *argp1 = 0 ;
47628 int res1 = 0 ;
47629 bool temp2 = false ;
47630 PyObject * obj0 = 0 ;
47631 PyObject * obj1 = 0 ;
47632 PyObject * obj2 = 0 ;
47633 char * kwnames[] = {
47634 (char *) "self",(char *) "item",(char *) "clientData", NULL
47635 };
47636
47637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47639 if (!SWIG_IsOK(res1)) {
47640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47641 }
47642 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47643 {
47644 arg2 = wxString_in_helper(obj1);
47645 if (arg2 == NULL) SWIG_fail;
47646 temp2 = true;
47647 }
47648 if (obj2) {
47649 arg3 = obj2;
47650 }
47651 {
47652 PyThreadState* __tstate = wxPyBeginAllowThreads();
47653 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47654 wxPyEndAllowThreads(__tstate);
47655 if (PyErr_Occurred()) SWIG_fail;
47656 }
47657 resultobj = SWIG_From_int(static_cast< int >(result));
47658 {
47659 if (temp2)
47660 delete arg2;
47661 }
47662 return resultobj;
47663 fail:
47664 {
47665 if (temp2)
47666 delete arg2;
47667 }
47668 return NULL;
47669 }
47670
47671
47672 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47673 PyObject *resultobj = 0;
47674 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47675 wxArrayString *arg2 = 0 ;
47676 void *argp1 = 0 ;
47677 int res1 = 0 ;
47678 bool temp2 = false ;
47679 PyObject * obj0 = 0 ;
47680 PyObject * obj1 = 0 ;
47681 char * kwnames[] = {
47682 (char *) "self",(char *) "strings", NULL
47683 };
47684
47685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) 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_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47689 }
47690 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47691 {
47692 if (! PySequence_Check(obj1)) {
47693 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
47694 SWIG_fail;
47695 }
47696 arg2 = new wxArrayString;
47697 temp2 = true;
47698 int i, len=PySequence_Length(obj1);
47699 for (i=0; i<len; i++) {
47700 PyObject* item = PySequence_GetItem(obj1, i);
47701 wxString* s = wxString_in_helper(item);
47702 if (PyErr_Occurred()) SWIG_fail;
47703 arg2->Add(*s);
47704 delete s;
47705 Py_DECREF(item);
47706 }
47707 }
47708 {
47709 PyThreadState* __tstate = wxPyBeginAllowThreads();
47710 (arg1)->Append((wxArrayString const &)*arg2);
47711 wxPyEndAllowThreads(__tstate);
47712 if (PyErr_Occurred()) SWIG_fail;
47713 }
47714 resultobj = SWIG_Py_Void();
47715 {
47716 if (temp2) delete arg2;
47717 }
47718 return resultobj;
47719 fail:
47720 {
47721 if (temp2) delete arg2;
47722 }
47723 return NULL;
47724 }
47725
47726
47727 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47728 PyObject *resultobj = 0;
47729 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47730 wxString *arg2 = 0 ;
47731 unsigned int arg3 ;
47732 PyObject *arg4 = (PyObject *) NULL ;
47733 int result;
47734 void *argp1 = 0 ;
47735 int res1 = 0 ;
47736 bool temp2 = false ;
47737 unsigned int val3 ;
47738 int ecode3 = 0 ;
47739 PyObject * obj0 = 0 ;
47740 PyObject * obj1 = 0 ;
47741 PyObject * obj2 = 0 ;
47742 PyObject * obj3 = 0 ;
47743 char * kwnames[] = {
47744 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
47745 };
47746
47747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47749 if (!SWIG_IsOK(res1)) {
47750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47751 }
47752 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47753 {
47754 arg2 = wxString_in_helper(obj1);
47755 if (arg2 == NULL) SWIG_fail;
47756 temp2 = true;
47757 }
47758 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
47759 if (!SWIG_IsOK(ecode3)) {
47760 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
47761 }
47762 arg3 = static_cast< unsigned int >(val3);
47763 if (obj3) {
47764 arg4 = obj3;
47765 }
47766 {
47767 PyThreadState* __tstate = wxPyBeginAllowThreads();
47768 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
47769 wxPyEndAllowThreads(__tstate);
47770 if (PyErr_Occurred()) SWIG_fail;
47771 }
47772 resultobj = SWIG_From_int(static_cast< int >(result));
47773 {
47774 if (temp2)
47775 delete arg2;
47776 }
47777 return resultobj;
47778 fail:
47779 {
47780 if (temp2)
47781 delete arg2;
47782 }
47783 return NULL;
47784 }
47785
47786
47787 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47788 PyObject *resultobj = 0;
47789 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47790 void *argp1 = 0 ;
47791 int res1 = 0 ;
47792 PyObject *swig_obj[1] ;
47793
47794 if (!args) SWIG_fail;
47795 swig_obj[0] = args;
47796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47797 if (!SWIG_IsOK(res1)) {
47798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47799 }
47800 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47801 {
47802 PyThreadState* __tstate = wxPyBeginAllowThreads();
47803 (arg1)->Clear();
47804 wxPyEndAllowThreads(__tstate);
47805 if (PyErr_Occurred()) SWIG_fail;
47806 }
47807 resultobj = SWIG_Py_Void();
47808 return resultobj;
47809 fail:
47810 return NULL;
47811 }
47812
47813
47814 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47815 PyObject *resultobj = 0;
47816 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47817 unsigned int arg2 ;
47818 void *argp1 = 0 ;
47819 int res1 = 0 ;
47820 unsigned int val2 ;
47821 int ecode2 = 0 ;
47822 PyObject * obj0 = 0 ;
47823 PyObject * obj1 = 0 ;
47824 char * kwnames[] = {
47825 (char *) "self",(char *) "n", NULL
47826 };
47827
47828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
47829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47830 if (!SWIG_IsOK(res1)) {
47831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47832 }
47833 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47834 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47835 if (!SWIG_IsOK(ecode2)) {
47836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
47837 }
47838 arg2 = static_cast< unsigned int >(val2);
47839 {
47840 PyThreadState* __tstate = wxPyBeginAllowThreads();
47841 (arg1)->Delete(arg2);
47842 wxPyEndAllowThreads(__tstate);
47843 if (PyErr_Occurred()) SWIG_fail;
47844 }
47845 resultobj = SWIG_Py_Void();
47846 return resultobj;
47847 fail:
47848 return NULL;
47849 }
47850
47851
47852 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47853 PyObject *resultobj = 0;
47854 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47855 unsigned int arg2 ;
47856 PyObject *result = 0 ;
47857 void *argp1 = 0 ;
47858 int res1 = 0 ;
47859 unsigned int val2 ;
47860 int ecode2 = 0 ;
47861 PyObject * obj0 = 0 ;
47862 PyObject * obj1 = 0 ;
47863 char * kwnames[] = {
47864 (char *) "self",(char *) "n", NULL
47865 };
47866
47867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
47868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47869 if (!SWIG_IsOK(res1)) {
47870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47871 }
47872 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47873 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47874 if (!SWIG_IsOK(ecode2)) {
47875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47876 }
47877 arg2 = static_cast< unsigned int >(val2);
47878 {
47879 PyThreadState* __tstate = wxPyBeginAllowThreads();
47880 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
47881 wxPyEndAllowThreads(__tstate);
47882 if (PyErr_Occurred()) SWIG_fail;
47883 }
47884 resultobj = result;
47885 return resultobj;
47886 fail:
47887 return NULL;
47888 }
47889
47890
47891 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47892 PyObject *resultobj = 0;
47893 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47894 unsigned int arg2 ;
47895 PyObject *arg3 = (PyObject *) 0 ;
47896 void *argp1 = 0 ;
47897 int res1 = 0 ;
47898 unsigned int val2 ;
47899 int ecode2 = 0 ;
47900 PyObject * obj0 = 0 ;
47901 PyObject * obj1 = 0 ;
47902 PyObject * obj2 = 0 ;
47903 char * kwnames[] = {
47904 (char *) "self",(char *) "n",(char *) "clientData", NULL
47905 };
47906
47907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47909 if (!SWIG_IsOK(res1)) {
47910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47911 }
47912 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47913 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47914 if (!SWIG_IsOK(ecode2)) {
47915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47916 }
47917 arg2 = static_cast< unsigned int >(val2);
47918 arg3 = obj2;
47919 {
47920 PyThreadState* __tstate = wxPyBeginAllowThreads();
47921 wxItemContainer_SetClientData(arg1,arg2,arg3);
47922 wxPyEndAllowThreads(__tstate);
47923 if (PyErr_Occurred()) SWIG_fail;
47924 }
47925 resultobj = SWIG_Py_Void();
47926 return resultobj;
47927 fail:
47928 return NULL;
47929 }
47930
47931
47932 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47933 PyObject *resultobj = 0;
47934 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47935 unsigned int result;
47936 void *argp1 = 0 ;
47937 int res1 = 0 ;
47938 PyObject *swig_obj[1] ;
47939
47940 if (!args) SWIG_fail;
47941 swig_obj[0] = args;
47942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47943 if (!SWIG_IsOK(res1)) {
47944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47945 }
47946 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47947 {
47948 PyThreadState* __tstate = wxPyBeginAllowThreads();
47949 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
47950 wxPyEndAllowThreads(__tstate);
47951 if (PyErr_Occurred()) SWIG_fail;
47952 }
47953 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
47954 return resultobj;
47955 fail:
47956 return NULL;
47957 }
47958
47959
47960 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47961 PyObject *resultobj = 0;
47962 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47963 bool result;
47964 void *argp1 = 0 ;
47965 int res1 = 0 ;
47966 PyObject *swig_obj[1] ;
47967
47968 if (!args) SWIG_fail;
47969 swig_obj[0] = args;
47970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47971 if (!SWIG_IsOK(res1)) {
47972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47973 }
47974 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47975 {
47976 PyThreadState* __tstate = wxPyBeginAllowThreads();
47977 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
47978 wxPyEndAllowThreads(__tstate);
47979 if (PyErr_Occurred()) SWIG_fail;
47980 }
47981 {
47982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47983 }
47984 return resultobj;
47985 fail:
47986 return NULL;
47987 }
47988
47989
47990 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47991 PyObject *resultobj = 0;
47992 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47993 unsigned int arg2 ;
47994 wxString result;
47995 void *argp1 = 0 ;
47996 int res1 = 0 ;
47997 unsigned int val2 ;
47998 int ecode2 = 0 ;
47999 PyObject * obj0 = 0 ;
48000 PyObject * obj1 = 0 ;
48001 char * kwnames[] = {
48002 (char *) "self",(char *) "n", NULL
48003 };
48004
48005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48007 if (!SWIG_IsOK(res1)) {
48008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48009 }
48010 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48011 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
48012 if (!SWIG_IsOK(ecode2)) {
48013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
48014 }
48015 arg2 = static_cast< unsigned int >(val2);
48016 {
48017 PyThreadState* __tstate = wxPyBeginAllowThreads();
48018 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48019 wxPyEndAllowThreads(__tstate);
48020 if (PyErr_Occurred()) SWIG_fail;
48021 }
48022 {
48023 #if wxUSE_UNICODE
48024 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48025 #else
48026 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48027 #endif
48028 }
48029 return resultobj;
48030 fail:
48031 return NULL;
48032 }
48033
48034
48035 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48036 PyObject *resultobj = 0;
48037 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48038 wxArrayString result;
48039 void *argp1 = 0 ;
48040 int res1 = 0 ;
48041 PyObject *swig_obj[1] ;
48042
48043 if (!args) SWIG_fail;
48044 swig_obj[0] = args;
48045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48046 if (!SWIG_IsOK(res1)) {
48047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48048 }
48049 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48050 {
48051 PyThreadState* __tstate = wxPyBeginAllowThreads();
48052 result = ((wxItemContainer const *)arg1)->GetStrings();
48053 wxPyEndAllowThreads(__tstate);
48054 if (PyErr_Occurred()) SWIG_fail;
48055 }
48056 {
48057 resultobj = wxArrayString2PyList_helper(result);
48058 }
48059 return resultobj;
48060 fail:
48061 return NULL;
48062 }
48063
48064
48065 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48066 PyObject *resultobj = 0;
48067 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48068 unsigned int arg2 ;
48069 wxString *arg3 = 0 ;
48070 void *argp1 = 0 ;
48071 int res1 = 0 ;
48072 unsigned int val2 ;
48073 int ecode2 = 0 ;
48074 bool temp3 = false ;
48075 PyObject * obj0 = 0 ;
48076 PyObject * obj1 = 0 ;
48077 PyObject * obj2 = 0 ;
48078 char * kwnames[] = {
48079 (char *) "self",(char *) "n",(char *) "s", NULL
48080 };
48081
48082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48084 if (!SWIG_IsOK(res1)) {
48085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48086 }
48087 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48088 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
48089 if (!SWIG_IsOK(ecode2)) {
48090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
48091 }
48092 arg2 = static_cast< unsigned int >(val2);
48093 {
48094 arg3 = wxString_in_helper(obj2);
48095 if (arg3 == NULL) SWIG_fail;
48096 temp3 = true;
48097 }
48098 {
48099 PyThreadState* __tstate = wxPyBeginAllowThreads();
48100 (arg1)->SetString(arg2,(wxString const &)*arg3);
48101 wxPyEndAllowThreads(__tstate);
48102 if (PyErr_Occurred()) SWIG_fail;
48103 }
48104 resultobj = SWIG_Py_Void();
48105 {
48106 if (temp3)
48107 delete arg3;
48108 }
48109 return resultobj;
48110 fail:
48111 {
48112 if (temp3)
48113 delete arg3;
48114 }
48115 return NULL;
48116 }
48117
48118
48119 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48120 PyObject *resultobj = 0;
48121 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48122 wxString *arg2 = 0 ;
48123 int result;
48124 void *argp1 = 0 ;
48125 int res1 = 0 ;
48126 bool temp2 = false ;
48127 PyObject * obj0 = 0 ;
48128 PyObject * obj1 = 0 ;
48129 char * kwnames[] = {
48130 (char *) "self",(char *) "s", NULL
48131 };
48132
48133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48135 if (!SWIG_IsOK(res1)) {
48136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48137 }
48138 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48139 {
48140 arg2 = wxString_in_helper(obj1);
48141 if (arg2 == NULL) SWIG_fail;
48142 temp2 = true;
48143 }
48144 {
48145 PyThreadState* __tstate = wxPyBeginAllowThreads();
48146 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48147 wxPyEndAllowThreads(__tstate);
48148 if (PyErr_Occurred()) SWIG_fail;
48149 }
48150 resultobj = SWIG_From_int(static_cast< int >(result));
48151 {
48152 if (temp2)
48153 delete arg2;
48154 }
48155 return resultobj;
48156 fail:
48157 {
48158 if (temp2)
48159 delete arg2;
48160 }
48161 return NULL;
48162 }
48163
48164
48165 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48166 PyObject *resultobj = 0;
48167 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48168 int arg2 ;
48169 void *argp1 = 0 ;
48170 int res1 = 0 ;
48171 int val2 ;
48172 int ecode2 = 0 ;
48173 PyObject * obj0 = 0 ;
48174 PyObject * obj1 = 0 ;
48175 char * kwnames[] = {
48176 (char *) "self",(char *) "n", NULL
48177 };
48178
48179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48181 if (!SWIG_IsOK(res1)) {
48182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48183 }
48184 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48185 ecode2 = SWIG_AsVal_int(obj1, &val2);
48186 if (!SWIG_IsOK(ecode2)) {
48187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48188 }
48189 arg2 = static_cast< int >(val2);
48190 {
48191 PyThreadState* __tstate = wxPyBeginAllowThreads();
48192 (arg1)->SetSelection(arg2);
48193 wxPyEndAllowThreads(__tstate);
48194 if (PyErr_Occurred()) SWIG_fail;
48195 }
48196 resultobj = SWIG_Py_Void();
48197 return resultobj;
48198 fail:
48199 return NULL;
48200 }
48201
48202
48203 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48204 PyObject *resultobj = 0;
48205 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48206 int result;
48207 void *argp1 = 0 ;
48208 int res1 = 0 ;
48209 PyObject *swig_obj[1] ;
48210
48211 if (!args) SWIG_fail;
48212 swig_obj[0] = args;
48213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48214 if (!SWIG_IsOK(res1)) {
48215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48216 }
48217 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48218 {
48219 PyThreadState* __tstate = wxPyBeginAllowThreads();
48220 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48221 wxPyEndAllowThreads(__tstate);
48222 if (PyErr_Occurred()) SWIG_fail;
48223 }
48224 resultobj = SWIG_From_int(static_cast< int >(result));
48225 return resultobj;
48226 fail:
48227 return NULL;
48228 }
48229
48230
48231 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48232 PyObject *resultobj = 0;
48233 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48234 wxString *arg2 = 0 ;
48235 bool result;
48236 void *argp1 = 0 ;
48237 int res1 = 0 ;
48238 bool temp2 = false ;
48239 PyObject * obj0 = 0 ;
48240 PyObject * obj1 = 0 ;
48241 char * kwnames[] = {
48242 (char *) "self",(char *) "s", NULL
48243 };
48244
48245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48247 if (!SWIG_IsOK(res1)) {
48248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48249 }
48250 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48251 {
48252 arg2 = wxString_in_helper(obj1);
48253 if (arg2 == NULL) SWIG_fail;
48254 temp2 = true;
48255 }
48256 {
48257 PyThreadState* __tstate = wxPyBeginAllowThreads();
48258 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48259 wxPyEndAllowThreads(__tstate);
48260 if (PyErr_Occurred()) SWIG_fail;
48261 }
48262 {
48263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48264 }
48265 {
48266 if (temp2)
48267 delete arg2;
48268 }
48269 return resultobj;
48270 fail:
48271 {
48272 if (temp2)
48273 delete arg2;
48274 }
48275 return NULL;
48276 }
48277
48278
48279 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48280 PyObject *resultobj = 0;
48281 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48282 wxString result;
48283 void *argp1 = 0 ;
48284 int res1 = 0 ;
48285 PyObject *swig_obj[1] ;
48286
48287 if (!args) SWIG_fail;
48288 swig_obj[0] = args;
48289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48290 if (!SWIG_IsOK(res1)) {
48291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48292 }
48293 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48294 {
48295 PyThreadState* __tstate = wxPyBeginAllowThreads();
48296 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48297 wxPyEndAllowThreads(__tstate);
48298 if (PyErr_Occurred()) SWIG_fail;
48299 }
48300 {
48301 #if wxUSE_UNICODE
48302 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48303 #else
48304 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48305 #endif
48306 }
48307 return resultobj;
48308 fail:
48309 return NULL;
48310 }
48311
48312
48313 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48314 PyObject *resultobj = 0;
48315 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48316 int arg2 ;
48317 void *argp1 = 0 ;
48318 int res1 = 0 ;
48319 int val2 ;
48320 int ecode2 = 0 ;
48321 PyObject * obj0 = 0 ;
48322 PyObject * obj1 = 0 ;
48323 char * kwnames[] = {
48324 (char *) "self",(char *) "n", NULL
48325 };
48326
48327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48329 if (!SWIG_IsOK(res1)) {
48330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48331 }
48332 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48333 ecode2 = SWIG_AsVal_int(obj1, &val2);
48334 if (!SWIG_IsOK(ecode2)) {
48335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48336 }
48337 arg2 = static_cast< int >(val2);
48338 {
48339 PyThreadState* __tstate = wxPyBeginAllowThreads();
48340 (arg1)->Select(arg2);
48341 wxPyEndAllowThreads(__tstate);
48342 if (PyErr_Occurred()) SWIG_fail;
48343 }
48344 resultobj = SWIG_Py_Void();
48345 return resultobj;
48346 fail:
48347 return NULL;
48348 }
48349
48350
48351 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48352 PyObject *obj;
48353 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48354 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48355 return SWIG_Py_Void();
48356 }
48357
48358 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48359 PyObject *obj;
48360 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48361 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48362 return SWIG_Py_Void();
48363 }
48364
48365 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48366 PyObject *resultobj = 0;
48367 wxSizerItem *result = 0 ;
48368
48369 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
48370 {
48371 PyThreadState* __tstate = wxPyBeginAllowThreads();
48372 result = (wxSizerItem *)new wxSizerItem();
48373 wxPyEndAllowThreads(__tstate);
48374 if (PyErr_Occurred()) SWIG_fail;
48375 }
48376 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
48377 return resultobj;
48378 fail:
48379 return NULL;
48380 }
48381
48382
48383 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48384 PyObject *resultobj = 0;
48385 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48386 void *argp1 = 0 ;
48387 int res1 = 0 ;
48388 PyObject *swig_obj[1] ;
48389
48390 if (!args) SWIG_fail;
48391 swig_obj[0] = args;
48392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48393 if (!SWIG_IsOK(res1)) {
48394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48395 }
48396 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48397 {
48398 PyThreadState* __tstate = wxPyBeginAllowThreads();
48399 delete arg1;
48400
48401 wxPyEndAllowThreads(__tstate);
48402 if (PyErr_Occurred()) SWIG_fail;
48403 }
48404 resultobj = SWIG_Py_Void();
48405 return resultobj;
48406 fail:
48407 return NULL;
48408 }
48409
48410
48411 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48412 PyObject *resultobj = 0;
48413 wxWindow *arg1 = (wxWindow *) 0 ;
48414 int arg2 ;
48415 int arg3 ;
48416 int arg4 ;
48417 PyObject *arg5 = (PyObject *) NULL ;
48418 wxSizerItem *result = 0 ;
48419 void *argp1 = 0 ;
48420 int res1 = 0 ;
48421 int val2 ;
48422 int ecode2 = 0 ;
48423 int val3 ;
48424 int ecode3 = 0 ;
48425 int val4 ;
48426 int ecode4 = 0 ;
48427 PyObject * obj0 = 0 ;
48428 PyObject * obj1 = 0 ;
48429 PyObject * obj2 = 0 ;
48430 PyObject * obj3 = 0 ;
48431 PyObject * obj4 = 0 ;
48432 char * kwnames[] = {
48433 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48434 };
48435
48436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48438 if (!SWIG_IsOK(res1)) {
48439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
48440 }
48441 arg1 = reinterpret_cast< wxWindow * >(argp1);
48442 ecode2 = SWIG_AsVal_int(obj1, &val2);
48443 if (!SWIG_IsOK(ecode2)) {
48444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
48445 }
48446 arg2 = static_cast< int >(val2);
48447 ecode3 = SWIG_AsVal_int(obj2, &val3);
48448 if (!SWIG_IsOK(ecode3)) {
48449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
48450 }
48451 arg3 = static_cast< int >(val3);
48452 ecode4 = SWIG_AsVal_int(obj3, &val4);
48453 if (!SWIG_IsOK(ecode4)) {
48454 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
48455 }
48456 arg4 = static_cast< int >(val4);
48457 if (obj4) {
48458 arg5 = obj4;
48459 }
48460 {
48461 PyThreadState* __tstate = wxPyBeginAllowThreads();
48462 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48463 wxPyEndAllowThreads(__tstate);
48464 if (PyErr_Occurred()) SWIG_fail;
48465 }
48466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48467 return resultobj;
48468 fail:
48469 return NULL;
48470 }
48471
48472
48473 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48474 PyObject *resultobj = 0;
48475 int arg1 ;
48476 int arg2 ;
48477 int arg3 ;
48478 int arg4 ;
48479 int arg5 ;
48480 PyObject *arg6 = (PyObject *) NULL ;
48481 wxSizerItem *result = 0 ;
48482 int val1 ;
48483 int ecode1 = 0 ;
48484 int val2 ;
48485 int ecode2 = 0 ;
48486 int val3 ;
48487 int ecode3 = 0 ;
48488 int val4 ;
48489 int ecode4 = 0 ;
48490 int val5 ;
48491 int ecode5 = 0 ;
48492 PyObject * obj0 = 0 ;
48493 PyObject * obj1 = 0 ;
48494 PyObject * obj2 = 0 ;
48495 PyObject * obj3 = 0 ;
48496 PyObject * obj4 = 0 ;
48497 PyObject * obj5 = 0 ;
48498 char * kwnames[] = {
48499 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48500 };
48501
48502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
48503 ecode1 = SWIG_AsVal_int(obj0, &val1);
48504 if (!SWIG_IsOK(ecode1)) {
48505 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
48506 }
48507 arg1 = static_cast< int >(val1);
48508 ecode2 = SWIG_AsVal_int(obj1, &val2);
48509 if (!SWIG_IsOK(ecode2)) {
48510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
48511 }
48512 arg2 = static_cast< int >(val2);
48513 ecode3 = SWIG_AsVal_int(obj2, &val3);
48514 if (!SWIG_IsOK(ecode3)) {
48515 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
48516 }
48517 arg3 = static_cast< int >(val3);
48518 ecode4 = SWIG_AsVal_int(obj3, &val4);
48519 if (!SWIG_IsOK(ecode4)) {
48520 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
48521 }
48522 arg4 = static_cast< int >(val4);
48523 ecode5 = SWIG_AsVal_int(obj4, &val5);
48524 if (!SWIG_IsOK(ecode5)) {
48525 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
48526 }
48527 arg5 = static_cast< int >(val5);
48528 if (obj5) {
48529 arg6 = obj5;
48530 }
48531 {
48532 PyThreadState* __tstate = wxPyBeginAllowThreads();
48533 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
48534 wxPyEndAllowThreads(__tstate);
48535 if (PyErr_Occurred()) SWIG_fail;
48536 }
48537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48538 return resultobj;
48539 fail:
48540 return NULL;
48541 }
48542
48543
48544 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48545 PyObject *resultobj = 0;
48546 wxSizer *arg1 = (wxSizer *) 0 ;
48547 int arg2 ;
48548 int arg3 ;
48549 int arg4 ;
48550 PyObject *arg5 = (PyObject *) NULL ;
48551 wxSizerItem *result = 0 ;
48552 int res1 = 0 ;
48553 int val2 ;
48554 int ecode2 = 0 ;
48555 int val3 ;
48556 int ecode3 = 0 ;
48557 int val4 ;
48558 int ecode4 = 0 ;
48559 PyObject * obj0 = 0 ;
48560 PyObject * obj1 = 0 ;
48561 PyObject * obj2 = 0 ;
48562 PyObject * obj3 = 0 ;
48563 PyObject * obj4 = 0 ;
48564 char * kwnames[] = {
48565 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48566 };
48567
48568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48569 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
48570 if (!SWIG_IsOK(res1)) {
48571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48572 }
48573 ecode2 = SWIG_AsVal_int(obj1, &val2);
48574 if (!SWIG_IsOK(ecode2)) {
48575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
48576 }
48577 arg2 = static_cast< int >(val2);
48578 ecode3 = SWIG_AsVal_int(obj2, &val3);
48579 if (!SWIG_IsOK(ecode3)) {
48580 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
48581 }
48582 arg3 = static_cast< int >(val3);
48583 ecode4 = SWIG_AsVal_int(obj3, &val4);
48584 if (!SWIG_IsOK(ecode4)) {
48585 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
48586 }
48587 arg4 = static_cast< int >(val4);
48588 if (obj4) {
48589 arg5 = obj4;
48590 }
48591 {
48592 PyThreadState* __tstate = wxPyBeginAllowThreads();
48593 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48594 wxPyEndAllowThreads(__tstate);
48595 if (PyErr_Occurred()) SWIG_fail;
48596 }
48597 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48598 return resultobj;
48599 fail:
48600 return NULL;
48601 }
48602
48603
48604 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48605 PyObject *resultobj = 0;
48606 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48607 void *argp1 = 0 ;
48608 int res1 = 0 ;
48609 PyObject *swig_obj[1] ;
48610
48611 if (!args) SWIG_fail;
48612 swig_obj[0] = args;
48613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48614 if (!SWIG_IsOK(res1)) {
48615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48616 }
48617 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48618 {
48619 PyThreadState* __tstate = wxPyBeginAllowThreads();
48620 (arg1)->DeleteWindows();
48621 wxPyEndAllowThreads(__tstate);
48622 if (PyErr_Occurred()) SWIG_fail;
48623 }
48624 resultobj = SWIG_Py_Void();
48625 return resultobj;
48626 fail:
48627 return NULL;
48628 }
48629
48630
48631 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48632 PyObject *resultobj = 0;
48633 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48634 void *argp1 = 0 ;
48635 int res1 = 0 ;
48636 PyObject *swig_obj[1] ;
48637
48638 if (!args) SWIG_fail;
48639 swig_obj[0] = args;
48640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48641 if (!SWIG_IsOK(res1)) {
48642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48643 }
48644 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48645 {
48646 PyThreadState* __tstate = wxPyBeginAllowThreads();
48647 (arg1)->DetachSizer();
48648 wxPyEndAllowThreads(__tstate);
48649 if (PyErr_Occurred()) SWIG_fail;
48650 }
48651 resultobj = SWIG_Py_Void();
48652 return resultobj;
48653 fail:
48654 return NULL;
48655 }
48656
48657
48658 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48659 PyObject *resultobj = 0;
48660 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48661 wxSize result;
48662 void *argp1 = 0 ;
48663 int res1 = 0 ;
48664 PyObject *swig_obj[1] ;
48665
48666 if (!args) SWIG_fail;
48667 swig_obj[0] = args;
48668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48669 if (!SWIG_IsOK(res1)) {
48670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48671 }
48672 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48673 {
48674 PyThreadState* __tstate = wxPyBeginAllowThreads();
48675 result = (arg1)->GetSize();
48676 wxPyEndAllowThreads(__tstate);
48677 if (PyErr_Occurred()) SWIG_fail;
48678 }
48679 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48680 return resultobj;
48681 fail:
48682 return NULL;
48683 }
48684
48685
48686 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48687 PyObject *resultobj = 0;
48688 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48689 wxSize result;
48690 void *argp1 = 0 ;
48691 int res1 = 0 ;
48692 PyObject *swig_obj[1] ;
48693
48694 if (!args) SWIG_fail;
48695 swig_obj[0] = args;
48696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48697 if (!SWIG_IsOK(res1)) {
48698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48699 }
48700 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48701 {
48702 PyThreadState* __tstate = wxPyBeginAllowThreads();
48703 result = (arg1)->CalcMin();
48704 wxPyEndAllowThreads(__tstate);
48705 if (PyErr_Occurred()) SWIG_fail;
48706 }
48707 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48708 return resultobj;
48709 fail:
48710 return NULL;
48711 }
48712
48713
48714 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48715 PyObject *resultobj = 0;
48716 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48717 wxPoint *arg2 = 0 ;
48718 wxSize *arg3 = 0 ;
48719 void *argp1 = 0 ;
48720 int res1 = 0 ;
48721 wxPoint temp2 ;
48722 wxSize temp3 ;
48723 PyObject * obj0 = 0 ;
48724 PyObject * obj1 = 0 ;
48725 PyObject * obj2 = 0 ;
48726 char * kwnames[] = {
48727 (char *) "self",(char *) "pos",(char *) "size", NULL
48728 };
48729
48730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48732 if (!SWIG_IsOK(res1)) {
48733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48734 }
48735 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48736 {
48737 arg2 = &temp2;
48738 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
48739 }
48740 {
48741 arg3 = &temp3;
48742 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48743 }
48744 {
48745 PyThreadState* __tstate = wxPyBeginAllowThreads();
48746 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
48747 wxPyEndAllowThreads(__tstate);
48748 if (PyErr_Occurred()) SWIG_fail;
48749 }
48750 resultobj = SWIG_Py_Void();
48751 return resultobj;
48752 fail:
48753 return NULL;
48754 }
48755
48756
48757 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48758 PyObject *resultobj = 0;
48759 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48760 wxSize result;
48761 void *argp1 = 0 ;
48762 int res1 = 0 ;
48763 PyObject *swig_obj[1] ;
48764
48765 if (!args) SWIG_fail;
48766 swig_obj[0] = args;
48767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48768 if (!SWIG_IsOK(res1)) {
48769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48770 }
48771 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48772 {
48773 PyThreadState* __tstate = wxPyBeginAllowThreads();
48774 result = (arg1)->GetMinSize();
48775 wxPyEndAllowThreads(__tstate);
48776 if (PyErr_Occurred()) SWIG_fail;
48777 }
48778 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48779 return resultobj;
48780 fail:
48781 return NULL;
48782 }
48783
48784
48785 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48786 PyObject *resultobj = 0;
48787 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48788 wxSize result;
48789 void *argp1 = 0 ;
48790 int res1 = 0 ;
48791 PyObject *swig_obj[1] ;
48792
48793 if (!args) SWIG_fail;
48794 swig_obj[0] = args;
48795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48796 if (!SWIG_IsOK(res1)) {
48797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
48798 }
48799 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48800 {
48801 PyThreadState* __tstate = wxPyBeginAllowThreads();
48802 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
48803 wxPyEndAllowThreads(__tstate);
48804 if (PyErr_Occurred()) SWIG_fail;
48805 }
48806 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48807 return resultobj;
48808 fail:
48809 return NULL;
48810 }
48811
48812
48813 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48814 PyObject *resultobj = 0;
48815 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48816 int arg2 ;
48817 int arg3 ;
48818 void *argp1 = 0 ;
48819 int res1 = 0 ;
48820 int val2 ;
48821 int ecode2 = 0 ;
48822 int val3 ;
48823 int ecode3 = 0 ;
48824 PyObject * obj0 = 0 ;
48825 PyObject * obj1 = 0 ;
48826 PyObject * obj2 = 0 ;
48827 char * kwnames[] = {
48828 (char *) "self",(char *) "x",(char *) "y", NULL
48829 };
48830
48831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48833 if (!SWIG_IsOK(res1)) {
48834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48835 }
48836 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48837 ecode2 = SWIG_AsVal_int(obj1, &val2);
48838 if (!SWIG_IsOK(ecode2)) {
48839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
48840 }
48841 arg2 = static_cast< int >(val2);
48842 ecode3 = SWIG_AsVal_int(obj2, &val3);
48843 if (!SWIG_IsOK(ecode3)) {
48844 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
48845 }
48846 arg3 = static_cast< int >(val3);
48847 {
48848 PyThreadState* __tstate = wxPyBeginAllowThreads();
48849 (arg1)->SetInitSize(arg2,arg3);
48850 wxPyEndAllowThreads(__tstate);
48851 if (PyErr_Occurred()) SWIG_fail;
48852 }
48853 resultobj = SWIG_Py_Void();
48854 return resultobj;
48855 fail:
48856 return NULL;
48857 }
48858
48859
48860 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48861 PyObject *resultobj = 0;
48862 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48863 int arg2 ;
48864 int arg3 ;
48865 void *argp1 = 0 ;
48866 int res1 = 0 ;
48867 int val2 ;
48868 int ecode2 = 0 ;
48869 int val3 ;
48870 int ecode3 = 0 ;
48871 PyObject * obj0 = 0 ;
48872 PyObject * obj1 = 0 ;
48873 PyObject * obj2 = 0 ;
48874 char * kwnames[] = {
48875 (char *) "self",(char *) "width",(char *) "height", NULL
48876 };
48877
48878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48880 if (!SWIG_IsOK(res1)) {
48881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48882 }
48883 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48884 ecode2 = SWIG_AsVal_int(obj1, &val2);
48885 if (!SWIG_IsOK(ecode2)) {
48886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
48887 }
48888 arg2 = static_cast< int >(val2);
48889 ecode3 = SWIG_AsVal_int(obj2, &val3);
48890 if (!SWIG_IsOK(ecode3)) {
48891 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
48892 }
48893 arg3 = static_cast< int >(val3);
48894 {
48895 PyThreadState* __tstate = wxPyBeginAllowThreads();
48896 (arg1)->SetRatio(arg2,arg3);
48897 wxPyEndAllowThreads(__tstate);
48898 if (PyErr_Occurred()) SWIG_fail;
48899 }
48900 resultobj = SWIG_Py_Void();
48901 return resultobj;
48902 fail:
48903 return NULL;
48904 }
48905
48906
48907 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48908 PyObject *resultobj = 0;
48909 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48910 wxSize *arg2 = 0 ;
48911 void *argp1 = 0 ;
48912 int res1 = 0 ;
48913 wxSize temp2 ;
48914 PyObject * obj0 = 0 ;
48915 PyObject * obj1 = 0 ;
48916 char * kwnames[] = {
48917 (char *) "self",(char *) "size", NULL
48918 };
48919
48920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
48921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48922 if (!SWIG_IsOK(res1)) {
48923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48924 }
48925 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48926 {
48927 arg2 = &temp2;
48928 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48929 }
48930 {
48931 PyThreadState* __tstate = wxPyBeginAllowThreads();
48932 (arg1)->SetRatio((wxSize const &)*arg2);
48933 wxPyEndAllowThreads(__tstate);
48934 if (PyErr_Occurred()) SWIG_fail;
48935 }
48936 resultobj = SWIG_Py_Void();
48937 return resultobj;
48938 fail:
48939 return NULL;
48940 }
48941
48942
48943 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48944 PyObject *resultobj = 0;
48945 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48946 float arg2 ;
48947 void *argp1 = 0 ;
48948 int res1 = 0 ;
48949 float val2 ;
48950 int ecode2 = 0 ;
48951 PyObject * obj0 = 0 ;
48952 PyObject * obj1 = 0 ;
48953 char * kwnames[] = {
48954 (char *) "self",(char *) "ratio", NULL
48955 };
48956
48957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
48958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48959 if (!SWIG_IsOK(res1)) {
48960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48961 }
48962 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48963 ecode2 = SWIG_AsVal_float(obj1, &val2);
48964 if (!SWIG_IsOK(ecode2)) {
48965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
48966 }
48967 arg2 = static_cast< float >(val2);
48968 {
48969 PyThreadState* __tstate = wxPyBeginAllowThreads();
48970 (arg1)->SetRatio(arg2);
48971 wxPyEndAllowThreads(__tstate);
48972 if (PyErr_Occurred()) SWIG_fail;
48973 }
48974 resultobj = SWIG_Py_Void();
48975 return resultobj;
48976 fail:
48977 return NULL;
48978 }
48979
48980
48981 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48982 PyObject *resultobj = 0;
48983 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48984 float result;
48985 void *argp1 = 0 ;
48986 int res1 = 0 ;
48987 PyObject *swig_obj[1] ;
48988
48989 if (!args) SWIG_fail;
48990 swig_obj[0] = args;
48991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48992 if (!SWIG_IsOK(res1)) {
48993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48994 }
48995 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48996 {
48997 PyThreadState* __tstate = wxPyBeginAllowThreads();
48998 result = (float)(arg1)->GetRatio();
48999 wxPyEndAllowThreads(__tstate);
49000 if (PyErr_Occurred()) SWIG_fail;
49001 }
49002 resultobj = SWIG_From_float(static_cast< float >(result));
49003 return resultobj;
49004 fail:
49005 return NULL;
49006 }
49007
49008
49009 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49010 PyObject *resultobj = 0;
49011 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49012 wxRect result;
49013 void *argp1 = 0 ;
49014 int res1 = 0 ;
49015 PyObject *swig_obj[1] ;
49016
49017 if (!args) SWIG_fail;
49018 swig_obj[0] = args;
49019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49020 if (!SWIG_IsOK(res1)) {
49021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49022 }
49023 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49024 {
49025 PyThreadState* __tstate = wxPyBeginAllowThreads();
49026 result = (arg1)->GetRect();
49027 wxPyEndAllowThreads(__tstate);
49028 if (PyErr_Occurred()) SWIG_fail;
49029 }
49030 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
49031 return resultobj;
49032 fail:
49033 return NULL;
49034 }
49035
49036
49037 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49038 PyObject *resultobj = 0;
49039 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49040 bool result;
49041 void *argp1 = 0 ;
49042 int res1 = 0 ;
49043 PyObject *swig_obj[1] ;
49044
49045 if (!args) SWIG_fail;
49046 swig_obj[0] = args;
49047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49048 if (!SWIG_IsOK(res1)) {
49049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49050 }
49051 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49052 {
49053 PyThreadState* __tstate = wxPyBeginAllowThreads();
49054 result = (bool)(arg1)->IsWindow();
49055 wxPyEndAllowThreads(__tstate);
49056 if (PyErr_Occurred()) SWIG_fail;
49057 }
49058 {
49059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49060 }
49061 return resultobj;
49062 fail:
49063 return NULL;
49064 }
49065
49066
49067 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49068 PyObject *resultobj = 0;
49069 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49070 bool result;
49071 void *argp1 = 0 ;
49072 int res1 = 0 ;
49073 PyObject *swig_obj[1] ;
49074
49075 if (!args) SWIG_fail;
49076 swig_obj[0] = args;
49077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49078 if (!SWIG_IsOK(res1)) {
49079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49080 }
49081 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49082 {
49083 PyThreadState* __tstate = wxPyBeginAllowThreads();
49084 result = (bool)(arg1)->IsSizer();
49085 wxPyEndAllowThreads(__tstate);
49086 if (PyErr_Occurred()) SWIG_fail;
49087 }
49088 {
49089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49090 }
49091 return resultobj;
49092 fail:
49093 return NULL;
49094 }
49095
49096
49097 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49098 PyObject *resultobj = 0;
49099 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49100 bool result;
49101 void *argp1 = 0 ;
49102 int res1 = 0 ;
49103 PyObject *swig_obj[1] ;
49104
49105 if (!args) SWIG_fail;
49106 swig_obj[0] = args;
49107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49108 if (!SWIG_IsOK(res1)) {
49109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49110 }
49111 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49112 {
49113 PyThreadState* __tstate = wxPyBeginAllowThreads();
49114 result = (bool)(arg1)->IsSpacer();
49115 wxPyEndAllowThreads(__tstate);
49116 if (PyErr_Occurred()) SWIG_fail;
49117 }
49118 {
49119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49120 }
49121 return resultobj;
49122 fail:
49123 return NULL;
49124 }
49125
49126
49127 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49128 PyObject *resultobj = 0;
49129 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49130 int arg2 ;
49131 void *argp1 = 0 ;
49132 int res1 = 0 ;
49133 int val2 ;
49134 int ecode2 = 0 ;
49135 PyObject * obj0 = 0 ;
49136 PyObject * obj1 = 0 ;
49137 char * kwnames[] = {
49138 (char *) "self",(char *) "proportion", NULL
49139 };
49140
49141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
49142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49143 if (!SWIG_IsOK(res1)) {
49144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49145 }
49146 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49147 ecode2 = SWIG_AsVal_int(obj1, &val2);
49148 if (!SWIG_IsOK(ecode2)) {
49149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
49150 }
49151 arg2 = static_cast< int >(val2);
49152 {
49153 PyThreadState* __tstate = wxPyBeginAllowThreads();
49154 (arg1)->SetProportion(arg2);
49155 wxPyEndAllowThreads(__tstate);
49156 if (PyErr_Occurred()) SWIG_fail;
49157 }
49158 resultobj = SWIG_Py_Void();
49159 return resultobj;
49160 fail:
49161 return NULL;
49162 }
49163
49164
49165 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49166 PyObject *resultobj = 0;
49167 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49168 int result;
49169 void *argp1 = 0 ;
49170 int res1 = 0 ;
49171 PyObject *swig_obj[1] ;
49172
49173 if (!args) SWIG_fail;
49174 swig_obj[0] = args;
49175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49176 if (!SWIG_IsOK(res1)) {
49177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49178 }
49179 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49180 {
49181 PyThreadState* __tstate = wxPyBeginAllowThreads();
49182 result = (int)(arg1)->GetProportion();
49183 wxPyEndAllowThreads(__tstate);
49184 if (PyErr_Occurred()) SWIG_fail;
49185 }
49186 resultobj = SWIG_From_int(static_cast< int >(result));
49187 return resultobj;
49188 fail:
49189 return NULL;
49190 }
49191
49192
49193 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49194 PyObject *resultobj = 0;
49195 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49196 int arg2 ;
49197 void *argp1 = 0 ;
49198 int res1 = 0 ;
49199 int val2 ;
49200 int ecode2 = 0 ;
49201 PyObject * obj0 = 0 ;
49202 PyObject * obj1 = 0 ;
49203 char * kwnames[] = {
49204 (char *) "self",(char *) "flag", NULL
49205 };
49206
49207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
49208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49209 if (!SWIG_IsOK(res1)) {
49210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49211 }
49212 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49213 ecode2 = SWIG_AsVal_int(obj1, &val2);
49214 if (!SWIG_IsOK(ecode2)) {
49215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
49216 }
49217 arg2 = static_cast< int >(val2);
49218 {
49219 PyThreadState* __tstate = wxPyBeginAllowThreads();
49220 (arg1)->SetFlag(arg2);
49221 wxPyEndAllowThreads(__tstate);
49222 if (PyErr_Occurred()) SWIG_fail;
49223 }
49224 resultobj = SWIG_Py_Void();
49225 return resultobj;
49226 fail:
49227 return NULL;
49228 }
49229
49230
49231 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49232 PyObject *resultobj = 0;
49233 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49234 int result;
49235 void *argp1 = 0 ;
49236 int res1 = 0 ;
49237 PyObject *swig_obj[1] ;
49238
49239 if (!args) SWIG_fail;
49240 swig_obj[0] = args;
49241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49242 if (!SWIG_IsOK(res1)) {
49243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49244 }
49245 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49246 {
49247 PyThreadState* __tstate = wxPyBeginAllowThreads();
49248 result = (int)(arg1)->GetFlag();
49249 wxPyEndAllowThreads(__tstate);
49250 if (PyErr_Occurred()) SWIG_fail;
49251 }
49252 resultobj = SWIG_From_int(static_cast< int >(result));
49253 return resultobj;
49254 fail:
49255 return NULL;
49256 }
49257
49258
49259 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49260 PyObject *resultobj = 0;
49261 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49262 int arg2 ;
49263 void *argp1 = 0 ;
49264 int res1 = 0 ;
49265 int val2 ;
49266 int ecode2 = 0 ;
49267 PyObject * obj0 = 0 ;
49268 PyObject * obj1 = 0 ;
49269 char * kwnames[] = {
49270 (char *) "self",(char *) "border", NULL
49271 };
49272
49273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49275 if (!SWIG_IsOK(res1)) {
49276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49277 }
49278 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49279 ecode2 = SWIG_AsVal_int(obj1, &val2);
49280 if (!SWIG_IsOK(ecode2)) {
49281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
49282 }
49283 arg2 = static_cast< int >(val2);
49284 {
49285 PyThreadState* __tstate = wxPyBeginAllowThreads();
49286 (arg1)->SetBorder(arg2);
49287 wxPyEndAllowThreads(__tstate);
49288 if (PyErr_Occurred()) SWIG_fail;
49289 }
49290 resultobj = SWIG_Py_Void();
49291 return resultobj;
49292 fail:
49293 return NULL;
49294 }
49295
49296
49297 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49298 PyObject *resultobj = 0;
49299 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49300 int result;
49301 void *argp1 = 0 ;
49302 int res1 = 0 ;
49303 PyObject *swig_obj[1] ;
49304
49305 if (!args) SWIG_fail;
49306 swig_obj[0] = args;
49307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49308 if (!SWIG_IsOK(res1)) {
49309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49310 }
49311 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49312 {
49313 PyThreadState* __tstate = wxPyBeginAllowThreads();
49314 result = (int)(arg1)->GetBorder();
49315 wxPyEndAllowThreads(__tstate);
49316 if (PyErr_Occurred()) SWIG_fail;
49317 }
49318 resultobj = SWIG_From_int(static_cast< int >(result));
49319 return resultobj;
49320 fail:
49321 return NULL;
49322 }
49323
49324
49325 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49326 PyObject *resultobj = 0;
49327 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49328 wxWindow *result = 0 ;
49329 void *argp1 = 0 ;
49330 int res1 = 0 ;
49331 PyObject *swig_obj[1] ;
49332
49333 if (!args) SWIG_fail;
49334 swig_obj[0] = args;
49335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49336 if (!SWIG_IsOK(res1)) {
49337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49338 }
49339 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49340 {
49341 PyThreadState* __tstate = wxPyBeginAllowThreads();
49342 result = (wxWindow *)(arg1)->GetWindow();
49343 wxPyEndAllowThreads(__tstate);
49344 if (PyErr_Occurred()) SWIG_fail;
49345 }
49346 {
49347 resultobj = wxPyMake_wxObject(result, 0);
49348 }
49349 return resultobj;
49350 fail:
49351 return NULL;
49352 }
49353
49354
49355 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49356 PyObject *resultobj = 0;
49357 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49358 wxWindow *arg2 = (wxWindow *) 0 ;
49359 void *argp1 = 0 ;
49360 int res1 = 0 ;
49361 void *argp2 = 0 ;
49362 int res2 = 0 ;
49363 PyObject * obj0 = 0 ;
49364 PyObject * obj1 = 0 ;
49365 char * kwnames[] = {
49366 (char *) "self",(char *) "window", NULL
49367 };
49368
49369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
49370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49371 if (!SWIG_IsOK(res1)) {
49372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49373 }
49374 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49375 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49376 if (!SWIG_IsOK(res2)) {
49377 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
49378 }
49379 arg2 = reinterpret_cast< wxWindow * >(argp2);
49380 {
49381 PyThreadState* __tstate = wxPyBeginAllowThreads();
49382 (arg1)->SetWindow(arg2);
49383 wxPyEndAllowThreads(__tstate);
49384 if (PyErr_Occurred()) SWIG_fail;
49385 }
49386 resultobj = SWIG_Py_Void();
49387 return resultobj;
49388 fail:
49389 return NULL;
49390 }
49391
49392
49393 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49394 PyObject *resultobj = 0;
49395 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49396 wxSizer *result = 0 ;
49397 void *argp1 = 0 ;
49398 int res1 = 0 ;
49399 PyObject *swig_obj[1] ;
49400
49401 if (!args) SWIG_fail;
49402 swig_obj[0] = args;
49403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49404 if (!SWIG_IsOK(res1)) {
49405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49406 }
49407 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49408 {
49409 PyThreadState* __tstate = wxPyBeginAllowThreads();
49410 result = (wxSizer *)(arg1)->GetSizer();
49411 wxPyEndAllowThreads(__tstate);
49412 if (PyErr_Occurred()) SWIG_fail;
49413 }
49414 {
49415 resultobj = wxPyMake_wxObject(result, (bool)0);
49416 }
49417 return resultobj;
49418 fail:
49419 return NULL;
49420 }
49421
49422
49423 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49424 PyObject *resultobj = 0;
49425 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49426 wxSizer *arg2 = (wxSizer *) 0 ;
49427 void *argp1 = 0 ;
49428 int res1 = 0 ;
49429 int res2 = 0 ;
49430 PyObject * obj0 = 0 ;
49431 PyObject * obj1 = 0 ;
49432 char * kwnames[] = {
49433 (char *) "self",(char *) "sizer", NULL
49434 };
49435
49436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49438 if (!SWIG_IsOK(res1)) {
49439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49440 }
49441 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49442 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49443 if (!SWIG_IsOK(res2)) {
49444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
49445 }
49446 {
49447 PyThreadState* __tstate = wxPyBeginAllowThreads();
49448 (arg1)->SetSizer(arg2);
49449 wxPyEndAllowThreads(__tstate);
49450 if (PyErr_Occurred()) SWIG_fail;
49451 }
49452 resultobj = SWIG_Py_Void();
49453 return resultobj;
49454 fail:
49455 return NULL;
49456 }
49457
49458
49459 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49460 PyObject *resultobj = 0;
49461 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49462 wxSize result;
49463 void *argp1 = 0 ;
49464 int res1 = 0 ;
49465 PyObject *swig_obj[1] ;
49466
49467 if (!args) SWIG_fail;
49468 swig_obj[0] = args;
49469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49470 if (!SWIG_IsOK(res1)) {
49471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49472 }
49473 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49474 {
49475 PyThreadState* __tstate = wxPyBeginAllowThreads();
49476 result = (arg1)->GetSpacer();
49477 wxPyEndAllowThreads(__tstate);
49478 if (PyErr_Occurred()) SWIG_fail;
49479 }
49480 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49481 return resultobj;
49482 fail:
49483 return NULL;
49484 }
49485
49486
49487 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49488 PyObject *resultobj = 0;
49489 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49490 wxSize *arg2 = 0 ;
49491 void *argp1 = 0 ;
49492 int res1 = 0 ;
49493 wxSize temp2 ;
49494 PyObject * obj0 = 0 ;
49495 PyObject * obj1 = 0 ;
49496 char * kwnames[] = {
49497 (char *) "self",(char *) "size", NULL
49498 };
49499
49500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
49501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49502 if (!SWIG_IsOK(res1)) {
49503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49504 }
49505 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49506 {
49507 arg2 = &temp2;
49508 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49509 }
49510 {
49511 PyThreadState* __tstate = wxPyBeginAllowThreads();
49512 (arg1)->SetSpacer((wxSize const &)*arg2);
49513 wxPyEndAllowThreads(__tstate);
49514 if (PyErr_Occurred()) SWIG_fail;
49515 }
49516 resultobj = SWIG_Py_Void();
49517 return resultobj;
49518 fail:
49519 return NULL;
49520 }
49521
49522
49523 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49524 PyObject *resultobj = 0;
49525 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49526 bool arg2 ;
49527 void *argp1 = 0 ;
49528 int res1 = 0 ;
49529 bool val2 ;
49530 int ecode2 = 0 ;
49531 PyObject * obj0 = 0 ;
49532 PyObject * obj1 = 0 ;
49533 char * kwnames[] = {
49534 (char *) "self",(char *) "show", NULL
49535 };
49536
49537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
49538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49539 if (!SWIG_IsOK(res1)) {
49540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49541 }
49542 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49543 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49544 if (!SWIG_IsOK(ecode2)) {
49545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
49546 }
49547 arg2 = static_cast< bool >(val2);
49548 {
49549 PyThreadState* __tstate = wxPyBeginAllowThreads();
49550 (arg1)->Show(arg2);
49551 wxPyEndAllowThreads(__tstate);
49552 if (PyErr_Occurred()) SWIG_fail;
49553 }
49554 resultobj = SWIG_Py_Void();
49555 return resultobj;
49556 fail:
49557 return NULL;
49558 }
49559
49560
49561 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49562 PyObject *resultobj = 0;
49563 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49564 bool result;
49565 void *argp1 = 0 ;
49566 int res1 = 0 ;
49567 PyObject *swig_obj[1] ;
49568
49569 if (!args) SWIG_fail;
49570 swig_obj[0] = args;
49571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49572 if (!SWIG_IsOK(res1)) {
49573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49574 }
49575 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49576 {
49577 PyThreadState* __tstate = wxPyBeginAllowThreads();
49578 result = (bool)(arg1)->IsShown();
49579 wxPyEndAllowThreads(__tstate);
49580 if (PyErr_Occurred()) SWIG_fail;
49581 }
49582 {
49583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49584 }
49585 return resultobj;
49586 fail:
49587 return NULL;
49588 }
49589
49590
49591 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49592 PyObject *resultobj = 0;
49593 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49594 wxPoint result;
49595 void *argp1 = 0 ;
49596 int res1 = 0 ;
49597 PyObject *swig_obj[1] ;
49598
49599 if (!args) SWIG_fail;
49600 swig_obj[0] = args;
49601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49602 if (!SWIG_IsOK(res1)) {
49603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49604 }
49605 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49606 {
49607 PyThreadState* __tstate = wxPyBeginAllowThreads();
49608 result = (arg1)->GetPosition();
49609 wxPyEndAllowThreads(__tstate);
49610 if (PyErr_Occurred()) SWIG_fail;
49611 }
49612 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
49613 return resultobj;
49614 fail:
49615 return NULL;
49616 }
49617
49618
49619 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49620 PyObject *resultobj = 0;
49621 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49622 PyObject *result = 0 ;
49623 void *argp1 = 0 ;
49624 int res1 = 0 ;
49625 PyObject *swig_obj[1] ;
49626
49627 if (!args) SWIG_fail;
49628 swig_obj[0] = args;
49629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49630 if (!SWIG_IsOK(res1)) {
49631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49632 }
49633 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49634 {
49635 PyThreadState* __tstate = wxPyBeginAllowThreads();
49636 result = (PyObject *)wxSizerItem_GetUserData(arg1);
49637 wxPyEndAllowThreads(__tstate);
49638 if (PyErr_Occurred()) SWIG_fail;
49639 }
49640 resultobj = result;
49641 return resultobj;
49642 fail:
49643 return NULL;
49644 }
49645
49646
49647 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49648 PyObject *resultobj = 0;
49649 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49650 PyObject *arg2 = (PyObject *) 0 ;
49651 void *argp1 = 0 ;
49652 int res1 = 0 ;
49653 PyObject * obj0 = 0 ;
49654 PyObject * obj1 = 0 ;
49655 char * kwnames[] = {
49656 (char *) "self",(char *) "userData", NULL
49657 };
49658
49659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
49660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49661 if (!SWIG_IsOK(res1)) {
49662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49663 }
49664 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49665 arg2 = obj1;
49666 {
49667 PyThreadState* __tstate = wxPyBeginAllowThreads();
49668 wxSizerItem_SetUserData(arg1,arg2);
49669 wxPyEndAllowThreads(__tstate);
49670 if (PyErr_Occurred()) SWIG_fail;
49671 }
49672 resultobj = SWIG_Py_Void();
49673 return resultobj;
49674 fail:
49675 return NULL;
49676 }
49677
49678
49679 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49680 PyObject *obj;
49681 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49682 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
49683 return SWIG_Py_Void();
49684 }
49685
49686 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49687 return SWIG_Python_InitShadowInstance(args);
49688 }
49689
49690 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49691 PyObject *resultobj = 0;
49692 wxSizer *arg1 = (wxSizer *) 0 ;
49693 void *argp1 = 0 ;
49694 int res1 = 0 ;
49695 PyObject *swig_obj[1] ;
49696
49697 if (!args) SWIG_fail;
49698 swig_obj[0] = args;
49699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49700 if (!SWIG_IsOK(res1)) {
49701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49702 }
49703 arg1 = reinterpret_cast< wxSizer * >(argp1);
49704 {
49705 PyThreadState* __tstate = wxPyBeginAllowThreads();
49706 delete arg1;
49707
49708 wxPyEndAllowThreads(__tstate);
49709 if (PyErr_Occurred()) SWIG_fail;
49710 }
49711 resultobj = SWIG_Py_Void();
49712 return resultobj;
49713 fail:
49714 return NULL;
49715 }
49716
49717
49718 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49719 PyObject *resultobj = 0;
49720 wxSizer *arg1 = (wxSizer *) 0 ;
49721 PyObject *arg2 = (PyObject *) 0 ;
49722 void *argp1 = 0 ;
49723 int res1 = 0 ;
49724 PyObject * obj0 = 0 ;
49725 PyObject * obj1 = 0 ;
49726 char * kwnames[] = {
49727 (char *) "self",(char *) "_self", NULL
49728 };
49729
49730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
49731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49732 if (!SWIG_IsOK(res1)) {
49733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
49734 }
49735 arg1 = reinterpret_cast< wxSizer * >(argp1);
49736 arg2 = obj1;
49737 {
49738 PyThreadState* __tstate = wxPyBeginAllowThreads();
49739 wxSizer__setOORInfo(arg1,arg2);
49740 wxPyEndAllowThreads(__tstate);
49741 if (PyErr_Occurred()) SWIG_fail;
49742 }
49743 resultobj = SWIG_Py_Void();
49744 return resultobj;
49745 fail:
49746 return NULL;
49747 }
49748
49749
49750 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49751 PyObject *resultobj = 0;
49752 wxSizer *arg1 = (wxSizer *) 0 ;
49753 PyObject *arg2 = (PyObject *) 0 ;
49754 int arg3 = (int) 0 ;
49755 int arg4 = (int) 0 ;
49756 int arg5 = (int) 0 ;
49757 PyObject *arg6 = (PyObject *) NULL ;
49758 wxSizerItem *result = 0 ;
49759 void *argp1 = 0 ;
49760 int res1 = 0 ;
49761 int val3 ;
49762 int ecode3 = 0 ;
49763 int val4 ;
49764 int ecode4 = 0 ;
49765 int val5 ;
49766 int ecode5 = 0 ;
49767 PyObject * obj0 = 0 ;
49768 PyObject * obj1 = 0 ;
49769 PyObject * obj2 = 0 ;
49770 PyObject * obj3 = 0 ;
49771 PyObject * obj4 = 0 ;
49772 PyObject * obj5 = 0 ;
49773 char * kwnames[] = {
49774 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49775 };
49776
49777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49779 if (!SWIG_IsOK(res1)) {
49780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
49781 }
49782 arg1 = reinterpret_cast< wxSizer * >(argp1);
49783 arg2 = obj1;
49784 if (obj2) {
49785 ecode3 = SWIG_AsVal_int(obj2, &val3);
49786 if (!SWIG_IsOK(ecode3)) {
49787 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
49788 }
49789 arg3 = static_cast< int >(val3);
49790 }
49791 if (obj3) {
49792 ecode4 = SWIG_AsVal_int(obj3, &val4);
49793 if (!SWIG_IsOK(ecode4)) {
49794 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
49795 }
49796 arg4 = static_cast< int >(val4);
49797 }
49798 if (obj4) {
49799 ecode5 = SWIG_AsVal_int(obj4, &val5);
49800 if (!SWIG_IsOK(ecode5)) {
49801 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
49802 }
49803 arg5 = static_cast< int >(val5);
49804 }
49805 if (obj5) {
49806 arg6 = obj5;
49807 }
49808 {
49809 PyThreadState* __tstate = wxPyBeginAllowThreads();
49810 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
49811 wxPyEndAllowThreads(__tstate);
49812 if (PyErr_Occurred()) SWIG_fail;
49813 }
49814 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49815 return resultobj;
49816 fail:
49817 return NULL;
49818 }
49819
49820
49821 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49822 PyObject *resultobj = 0;
49823 wxSizer *arg1 = (wxSizer *) 0 ;
49824 int arg2 ;
49825 PyObject *arg3 = (PyObject *) 0 ;
49826 int arg4 = (int) 0 ;
49827 int arg5 = (int) 0 ;
49828 int arg6 = (int) 0 ;
49829 PyObject *arg7 = (PyObject *) NULL ;
49830 wxSizerItem *result = 0 ;
49831 void *argp1 = 0 ;
49832 int res1 = 0 ;
49833 int val2 ;
49834 int ecode2 = 0 ;
49835 int val4 ;
49836 int ecode4 = 0 ;
49837 int val5 ;
49838 int ecode5 = 0 ;
49839 int val6 ;
49840 int ecode6 = 0 ;
49841 PyObject * obj0 = 0 ;
49842 PyObject * obj1 = 0 ;
49843 PyObject * obj2 = 0 ;
49844 PyObject * obj3 = 0 ;
49845 PyObject * obj4 = 0 ;
49846 PyObject * obj5 = 0 ;
49847 PyObject * obj6 = 0 ;
49848 char * kwnames[] = {
49849 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49850 };
49851
49852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49854 if (!SWIG_IsOK(res1)) {
49855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
49856 }
49857 arg1 = reinterpret_cast< wxSizer * >(argp1);
49858 ecode2 = SWIG_AsVal_int(obj1, &val2);
49859 if (!SWIG_IsOK(ecode2)) {
49860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
49861 }
49862 arg2 = static_cast< int >(val2);
49863 arg3 = obj2;
49864 if (obj3) {
49865 ecode4 = SWIG_AsVal_int(obj3, &val4);
49866 if (!SWIG_IsOK(ecode4)) {
49867 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
49868 }
49869 arg4 = static_cast< int >(val4);
49870 }
49871 if (obj4) {
49872 ecode5 = SWIG_AsVal_int(obj4, &val5);
49873 if (!SWIG_IsOK(ecode5)) {
49874 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
49875 }
49876 arg5 = static_cast< int >(val5);
49877 }
49878 if (obj5) {
49879 ecode6 = SWIG_AsVal_int(obj5, &val6);
49880 if (!SWIG_IsOK(ecode6)) {
49881 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
49882 }
49883 arg6 = static_cast< int >(val6);
49884 }
49885 if (obj6) {
49886 arg7 = obj6;
49887 }
49888 {
49889 PyThreadState* __tstate = wxPyBeginAllowThreads();
49890 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
49891 wxPyEndAllowThreads(__tstate);
49892 if (PyErr_Occurred()) SWIG_fail;
49893 }
49894 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49895 return resultobj;
49896 fail:
49897 return NULL;
49898 }
49899
49900
49901 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49902 PyObject *resultobj = 0;
49903 wxSizer *arg1 = (wxSizer *) 0 ;
49904 PyObject *arg2 = (PyObject *) 0 ;
49905 int arg3 = (int) 0 ;
49906 int arg4 = (int) 0 ;
49907 int arg5 = (int) 0 ;
49908 PyObject *arg6 = (PyObject *) NULL ;
49909 wxSizerItem *result = 0 ;
49910 void *argp1 = 0 ;
49911 int res1 = 0 ;
49912 int val3 ;
49913 int ecode3 = 0 ;
49914 int val4 ;
49915 int ecode4 = 0 ;
49916 int val5 ;
49917 int ecode5 = 0 ;
49918 PyObject * obj0 = 0 ;
49919 PyObject * obj1 = 0 ;
49920 PyObject * obj2 = 0 ;
49921 PyObject * obj3 = 0 ;
49922 PyObject * obj4 = 0 ;
49923 PyObject * obj5 = 0 ;
49924 char * kwnames[] = {
49925 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49926 };
49927
49928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49930 if (!SWIG_IsOK(res1)) {
49931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
49932 }
49933 arg1 = reinterpret_cast< wxSizer * >(argp1);
49934 arg2 = obj1;
49935 if (obj2) {
49936 ecode3 = SWIG_AsVal_int(obj2, &val3);
49937 if (!SWIG_IsOK(ecode3)) {
49938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
49939 }
49940 arg3 = static_cast< int >(val3);
49941 }
49942 if (obj3) {
49943 ecode4 = SWIG_AsVal_int(obj3, &val4);
49944 if (!SWIG_IsOK(ecode4)) {
49945 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
49946 }
49947 arg4 = static_cast< int >(val4);
49948 }
49949 if (obj4) {
49950 ecode5 = SWIG_AsVal_int(obj4, &val5);
49951 if (!SWIG_IsOK(ecode5)) {
49952 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
49953 }
49954 arg5 = static_cast< int >(val5);
49955 }
49956 if (obj5) {
49957 arg6 = obj5;
49958 }
49959 {
49960 PyThreadState* __tstate = wxPyBeginAllowThreads();
49961 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
49962 wxPyEndAllowThreads(__tstate);
49963 if (PyErr_Occurred()) SWIG_fail;
49964 }
49965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49966 return resultobj;
49967 fail:
49968 return NULL;
49969 }
49970
49971
49972 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49973 PyObject *resultobj = 0;
49974 wxSizer *arg1 = (wxSizer *) 0 ;
49975 PyObject *arg2 = (PyObject *) 0 ;
49976 bool result;
49977 void *argp1 = 0 ;
49978 int res1 = 0 ;
49979 PyObject * obj0 = 0 ;
49980 PyObject * obj1 = 0 ;
49981 char * kwnames[] = {
49982 (char *) "self",(char *) "item", NULL
49983 };
49984
49985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
49986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49987 if (!SWIG_IsOK(res1)) {
49988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
49989 }
49990 arg1 = reinterpret_cast< wxSizer * >(argp1);
49991 arg2 = obj1;
49992 {
49993 PyThreadState* __tstate = wxPyBeginAllowThreads();
49994 result = (bool)wxSizer_Remove(arg1,arg2);
49995 wxPyEndAllowThreads(__tstate);
49996 if (PyErr_Occurred()) SWIG_fail;
49997 }
49998 {
49999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50000 }
50001 return resultobj;
50002 fail:
50003 return NULL;
50004 }
50005
50006
50007 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50008 PyObject *resultobj = 0;
50009 wxSizer *arg1 = (wxSizer *) 0 ;
50010 PyObject *arg2 = (PyObject *) 0 ;
50011 bool result;
50012 void *argp1 = 0 ;
50013 int res1 = 0 ;
50014 PyObject * obj0 = 0 ;
50015 PyObject * obj1 = 0 ;
50016 char * kwnames[] = {
50017 (char *) "self",(char *) "item", NULL
50018 };
50019
50020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
50021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50022 if (!SWIG_IsOK(res1)) {
50023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
50024 }
50025 arg1 = reinterpret_cast< wxSizer * >(argp1);
50026 arg2 = obj1;
50027 {
50028 PyThreadState* __tstate = wxPyBeginAllowThreads();
50029 result = (bool)wxSizer_Detach(arg1,arg2);
50030 wxPyEndAllowThreads(__tstate);
50031 if (PyErr_Occurred()) SWIG_fail;
50032 }
50033 {
50034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50035 }
50036 return resultobj;
50037 fail:
50038 return NULL;
50039 }
50040
50041
50042 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50043 PyObject *resultobj = 0;
50044 wxSizer *arg1 = (wxSizer *) 0 ;
50045 PyObject *arg2 = (PyObject *) 0 ;
50046 wxSizerItem *result = 0 ;
50047 void *argp1 = 0 ;
50048 int res1 = 0 ;
50049 PyObject * obj0 = 0 ;
50050 PyObject * obj1 = 0 ;
50051 char * kwnames[] = {
50052 (char *) "self",(char *) "item", NULL
50053 };
50054
50055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
50056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50057 if (!SWIG_IsOK(res1)) {
50058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50059 }
50060 arg1 = reinterpret_cast< wxSizer * >(argp1);
50061 arg2 = obj1;
50062 {
50063 PyThreadState* __tstate = wxPyBeginAllowThreads();
50064 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
50065 wxPyEndAllowThreads(__tstate);
50066 if (PyErr_Occurred()) SWIG_fail;
50067 }
50068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50069 return resultobj;
50070 fail:
50071 return NULL;
50072 }
50073
50074
50075 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50076 PyObject *resultobj = 0;
50077 wxSizer *arg1 = (wxSizer *) 0 ;
50078 PyObject *arg2 = (PyObject *) 0 ;
50079 wxSize *arg3 = 0 ;
50080 void *argp1 = 0 ;
50081 int res1 = 0 ;
50082 wxSize temp3 ;
50083 PyObject * obj0 = 0 ;
50084 PyObject * obj1 = 0 ;
50085 PyObject * obj2 = 0 ;
50086 char * kwnames[] = {
50087 (char *) "self",(char *) "item",(char *) "size", NULL
50088 };
50089
50090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50092 if (!SWIG_IsOK(res1)) {
50093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50094 }
50095 arg1 = reinterpret_cast< wxSizer * >(argp1);
50096 arg2 = obj1;
50097 {
50098 arg3 = &temp3;
50099 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50100 }
50101 {
50102 PyThreadState* __tstate = wxPyBeginAllowThreads();
50103 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
50104 wxPyEndAllowThreads(__tstate);
50105 if (PyErr_Occurred()) SWIG_fail;
50106 }
50107 resultobj = SWIG_Py_Void();
50108 return resultobj;
50109 fail:
50110 return NULL;
50111 }
50112
50113
50114 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50115 PyObject *resultobj = 0;
50116 wxSizer *arg1 = (wxSizer *) 0 ;
50117 wxWindow *arg2 = (wxWindow *) 0 ;
50118 wxWindow *arg3 = (wxWindow *) 0 ;
50119 bool arg4 = (bool) false ;
50120 bool result;
50121 void *argp1 = 0 ;
50122 int res1 = 0 ;
50123 void *argp2 = 0 ;
50124 int res2 = 0 ;
50125 void *argp3 = 0 ;
50126 int res3 = 0 ;
50127 bool val4 ;
50128 int ecode4 = 0 ;
50129 PyObject * obj0 = 0 ;
50130 PyObject * obj1 = 0 ;
50131 PyObject * obj2 = 0 ;
50132 PyObject * obj3 = 0 ;
50133 char * kwnames[] = {
50134 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
50135 };
50136
50137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50139 if (!SWIG_IsOK(res1)) {
50140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
50141 }
50142 arg1 = reinterpret_cast< wxSizer * >(argp1);
50143 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50144 if (!SWIG_IsOK(res2)) {
50145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
50146 }
50147 arg2 = reinterpret_cast< wxWindow * >(argp2);
50148 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50149 if (!SWIG_IsOK(res3)) {
50150 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
50151 }
50152 arg3 = reinterpret_cast< wxWindow * >(argp3);
50153 if (obj3) {
50154 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50155 if (!SWIG_IsOK(ecode4)) {
50156 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
50157 }
50158 arg4 = static_cast< bool >(val4);
50159 }
50160 {
50161 PyThreadState* __tstate = wxPyBeginAllowThreads();
50162 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50163 wxPyEndAllowThreads(__tstate);
50164 if (PyErr_Occurred()) SWIG_fail;
50165 }
50166 {
50167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50168 }
50169 return resultobj;
50170 fail:
50171 return NULL;
50172 }
50173
50174
50175 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50176 PyObject *resultobj = 0;
50177 wxSizer *arg1 = (wxSizer *) 0 ;
50178 wxSizer *arg2 = (wxSizer *) 0 ;
50179 wxSizer *arg3 = (wxSizer *) 0 ;
50180 bool arg4 = (bool) false ;
50181 bool result;
50182 void *argp1 = 0 ;
50183 int res1 = 0 ;
50184 void *argp2 = 0 ;
50185 int res2 = 0 ;
50186 void *argp3 = 0 ;
50187 int res3 = 0 ;
50188 bool val4 ;
50189 int ecode4 = 0 ;
50190 PyObject * obj0 = 0 ;
50191 PyObject * obj1 = 0 ;
50192 PyObject * obj2 = 0 ;
50193 PyObject * obj3 = 0 ;
50194 char * kwnames[] = {
50195 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
50196 };
50197
50198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50200 if (!SWIG_IsOK(res1)) {
50201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50202 }
50203 arg1 = reinterpret_cast< wxSizer * >(argp1);
50204 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50205 if (!SWIG_IsOK(res2)) {
50206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50207 }
50208 arg2 = reinterpret_cast< wxSizer * >(argp2);
50209 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
50210 if (!SWIG_IsOK(res3)) {
50211 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
50212 }
50213 arg3 = reinterpret_cast< wxSizer * >(argp3);
50214 if (obj3) {
50215 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50216 if (!SWIG_IsOK(ecode4)) {
50217 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
50218 }
50219 arg4 = static_cast< bool >(val4);
50220 }
50221 {
50222 PyThreadState* __tstate = wxPyBeginAllowThreads();
50223 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50224 wxPyEndAllowThreads(__tstate);
50225 if (PyErr_Occurred()) SWIG_fail;
50226 }
50227 {
50228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50229 }
50230 return resultobj;
50231 fail:
50232 return NULL;
50233 }
50234
50235
50236 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50237 PyObject *resultobj = 0;
50238 wxSizer *arg1 = (wxSizer *) 0 ;
50239 size_t arg2 ;
50240 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50241 bool result;
50242 void *argp1 = 0 ;
50243 int res1 = 0 ;
50244 size_t val2 ;
50245 int ecode2 = 0 ;
50246 void *argp3 = 0 ;
50247 int res3 = 0 ;
50248 PyObject * obj0 = 0 ;
50249 PyObject * obj1 = 0 ;
50250 PyObject * obj2 = 0 ;
50251 char * kwnames[] = {
50252 (char *) "self",(char *) "index",(char *) "newitem", NULL
50253 };
50254
50255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50257 if (!SWIG_IsOK(res1)) {
50258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50259 }
50260 arg1 = reinterpret_cast< wxSizer * >(argp1);
50261 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50262 if (!SWIG_IsOK(ecode2)) {
50263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
50264 }
50265 arg2 = static_cast< size_t >(val2);
50266 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50267 if (!SWIG_IsOK(res3)) {
50268 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50269 }
50270 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
50271 {
50272 PyThreadState* __tstate = wxPyBeginAllowThreads();
50273 result = (bool)(arg1)->Replace(arg2,arg3);
50274 wxPyEndAllowThreads(__tstate);
50275 if (PyErr_Occurred()) SWIG_fail;
50276 }
50277 {
50278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50279 }
50280 return resultobj;
50281 fail:
50282 return NULL;
50283 }
50284
50285
50286 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50287 PyObject *resultobj = 0;
50288 wxSizer *arg1 = (wxSizer *) 0 ;
50289 wxWindow *arg2 = (wxWindow *) 0 ;
50290 void *argp1 = 0 ;
50291 int res1 = 0 ;
50292 void *argp2 = 0 ;
50293 int res2 = 0 ;
50294 PyObject * obj0 = 0 ;
50295 PyObject * obj1 = 0 ;
50296 char * kwnames[] = {
50297 (char *) "self",(char *) "window", NULL
50298 };
50299
50300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50302 if (!SWIG_IsOK(res1)) {
50303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
50304 }
50305 arg1 = reinterpret_cast< wxSizer * >(argp1);
50306 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50307 if (!SWIG_IsOK(res2)) {
50308 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50309 }
50310 arg2 = reinterpret_cast< wxWindow * >(argp2);
50311 {
50312 PyThreadState* __tstate = wxPyBeginAllowThreads();
50313 (arg1)->SetContainingWindow(arg2);
50314 wxPyEndAllowThreads(__tstate);
50315 if (PyErr_Occurred()) SWIG_fail;
50316 }
50317 resultobj = SWIG_Py_Void();
50318 return resultobj;
50319 fail:
50320 return NULL;
50321 }
50322
50323
50324 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50325 PyObject *resultobj = 0;
50326 wxSizer *arg1 = (wxSizer *) 0 ;
50327 wxWindow *result = 0 ;
50328 void *argp1 = 0 ;
50329 int res1 = 0 ;
50330 PyObject *swig_obj[1] ;
50331
50332 if (!args) SWIG_fail;
50333 swig_obj[0] = args;
50334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50335 if (!SWIG_IsOK(res1)) {
50336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
50337 }
50338 arg1 = reinterpret_cast< wxSizer * >(argp1);
50339 {
50340 PyThreadState* __tstate = wxPyBeginAllowThreads();
50341 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
50342 wxPyEndAllowThreads(__tstate);
50343 if (PyErr_Occurred()) SWIG_fail;
50344 }
50345 {
50346 resultobj = wxPyMake_wxObject(result, 0);
50347 }
50348 return resultobj;
50349 fail:
50350 return NULL;
50351 }
50352
50353
50354 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50355 PyObject *resultobj = 0;
50356 wxSizer *arg1 = (wxSizer *) 0 ;
50357 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50358 wxSizerItem *result = 0 ;
50359 void *argp1 = 0 ;
50360 int res1 = 0 ;
50361 int res2 = 0 ;
50362 PyObject * obj0 = 0 ;
50363 PyObject * obj1 = 0 ;
50364 char * kwnames[] = {
50365 (char *) "self",(char *) "item", NULL
50366 };
50367
50368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50370 if (!SWIG_IsOK(res1)) {
50371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50372 }
50373 arg1 = reinterpret_cast< wxSizer * >(argp1);
50374 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50375 if (!SWIG_IsOK(res2)) {
50376 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50377 }
50378 {
50379 PyThreadState* __tstate = wxPyBeginAllowThreads();
50380 result = (wxSizerItem *)(arg1)->Add(arg2);
50381 wxPyEndAllowThreads(__tstate);
50382 if (PyErr_Occurred()) SWIG_fail;
50383 }
50384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50385 return resultobj;
50386 fail:
50387 return NULL;
50388 }
50389
50390
50391 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50392 PyObject *resultobj = 0;
50393 wxSizer *arg1 = (wxSizer *) 0 ;
50394 size_t arg2 ;
50395 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50396 wxSizerItem *result = 0 ;
50397 void *argp1 = 0 ;
50398 int res1 = 0 ;
50399 size_t val2 ;
50400 int ecode2 = 0 ;
50401 int res3 = 0 ;
50402 PyObject * obj0 = 0 ;
50403 PyObject * obj1 = 0 ;
50404 PyObject * obj2 = 0 ;
50405 char * kwnames[] = {
50406 (char *) "self",(char *) "index",(char *) "item", NULL
50407 };
50408
50409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50411 if (!SWIG_IsOK(res1)) {
50412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50413 }
50414 arg1 = reinterpret_cast< wxSizer * >(argp1);
50415 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50416 if (!SWIG_IsOK(ecode2)) {
50417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
50418 }
50419 arg2 = static_cast< size_t >(val2);
50420 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50421 if (!SWIG_IsOK(res3)) {
50422 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50423 }
50424 {
50425 PyThreadState* __tstate = wxPyBeginAllowThreads();
50426 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
50427 wxPyEndAllowThreads(__tstate);
50428 if (PyErr_Occurred()) SWIG_fail;
50429 }
50430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50431 return resultobj;
50432 fail:
50433 return NULL;
50434 }
50435
50436
50437 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50438 PyObject *resultobj = 0;
50439 wxSizer *arg1 = (wxSizer *) 0 ;
50440 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50441 wxSizerItem *result = 0 ;
50442 void *argp1 = 0 ;
50443 int res1 = 0 ;
50444 int res2 = 0 ;
50445 PyObject * obj0 = 0 ;
50446 PyObject * obj1 = 0 ;
50447 char * kwnames[] = {
50448 (char *) "self",(char *) "item", NULL
50449 };
50450
50451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
50452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50453 if (!SWIG_IsOK(res1)) {
50454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50455 }
50456 arg1 = reinterpret_cast< wxSizer * >(argp1);
50457 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50458 if (!SWIG_IsOK(res2)) {
50459 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50460 }
50461 {
50462 PyThreadState* __tstate = wxPyBeginAllowThreads();
50463 result = (wxSizerItem *)(arg1)->Prepend(arg2);
50464 wxPyEndAllowThreads(__tstate);
50465 if (PyErr_Occurred()) SWIG_fail;
50466 }
50467 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50468 return resultobj;
50469 fail:
50470 return NULL;
50471 }
50472
50473
50474 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50475 PyObject *resultobj = 0;
50476 wxSizer *arg1 = (wxSizer *) 0 ;
50477 int arg2 ;
50478 int arg3 ;
50479 int arg4 ;
50480 int arg5 ;
50481 void *argp1 = 0 ;
50482 int res1 = 0 ;
50483 int val2 ;
50484 int ecode2 = 0 ;
50485 int val3 ;
50486 int ecode3 = 0 ;
50487 int val4 ;
50488 int ecode4 = 0 ;
50489 int val5 ;
50490 int ecode5 = 0 ;
50491 PyObject * obj0 = 0 ;
50492 PyObject * obj1 = 0 ;
50493 PyObject * obj2 = 0 ;
50494 PyObject * obj3 = 0 ;
50495 PyObject * obj4 = 0 ;
50496 char * kwnames[] = {
50497 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
50498 };
50499
50500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50502 if (!SWIG_IsOK(res1)) {
50503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
50504 }
50505 arg1 = reinterpret_cast< wxSizer * >(argp1);
50506 ecode2 = SWIG_AsVal_int(obj1, &val2);
50507 if (!SWIG_IsOK(ecode2)) {
50508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
50509 }
50510 arg2 = static_cast< int >(val2);
50511 ecode3 = SWIG_AsVal_int(obj2, &val3);
50512 if (!SWIG_IsOK(ecode3)) {
50513 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
50514 }
50515 arg3 = static_cast< int >(val3);
50516 ecode4 = SWIG_AsVal_int(obj3, &val4);
50517 if (!SWIG_IsOK(ecode4)) {
50518 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
50519 }
50520 arg4 = static_cast< int >(val4);
50521 ecode5 = SWIG_AsVal_int(obj4, &val5);
50522 if (!SWIG_IsOK(ecode5)) {
50523 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
50524 }
50525 arg5 = static_cast< int >(val5);
50526 {
50527 PyThreadState* __tstate = wxPyBeginAllowThreads();
50528 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
50529 wxPyEndAllowThreads(__tstate);
50530 if (PyErr_Occurred()) SWIG_fail;
50531 }
50532 resultobj = SWIG_Py_Void();
50533 return resultobj;
50534 fail:
50535 return NULL;
50536 }
50537
50538
50539 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50540 PyObject *resultobj = 0;
50541 wxSizer *arg1 = (wxSizer *) 0 ;
50542 wxSize *arg2 = 0 ;
50543 void *argp1 = 0 ;
50544 int res1 = 0 ;
50545 wxSize temp2 ;
50546 PyObject * obj0 = 0 ;
50547 PyObject * obj1 = 0 ;
50548 char * kwnames[] = {
50549 (char *) "self",(char *) "size", NULL
50550 };
50551
50552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
50553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50554 if (!SWIG_IsOK(res1)) {
50555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50556 }
50557 arg1 = reinterpret_cast< wxSizer * >(argp1);
50558 {
50559 arg2 = &temp2;
50560 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50561 }
50562 {
50563 PyThreadState* __tstate = wxPyBeginAllowThreads();
50564 (arg1)->SetMinSize((wxSize const &)*arg2);
50565 wxPyEndAllowThreads(__tstate);
50566 if (PyErr_Occurred()) SWIG_fail;
50567 }
50568 resultobj = SWIG_Py_Void();
50569 return resultobj;
50570 fail:
50571 return NULL;
50572 }
50573
50574
50575 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50576 PyObject *resultobj = 0;
50577 wxSizer *arg1 = (wxSizer *) 0 ;
50578 wxSize result;
50579 void *argp1 = 0 ;
50580 int res1 = 0 ;
50581 PyObject *swig_obj[1] ;
50582
50583 if (!args) SWIG_fail;
50584 swig_obj[0] = args;
50585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50586 if (!SWIG_IsOK(res1)) {
50587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50588 }
50589 arg1 = reinterpret_cast< wxSizer * >(argp1);
50590 {
50591 PyThreadState* __tstate = wxPyBeginAllowThreads();
50592 result = (arg1)->GetSize();
50593 wxPyEndAllowThreads(__tstate);
50594 if (PyErr_Occurred()) SWIG_fail;
50595 }
50596 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50597 return resultobj;
50598 fail:
50599 return NULL;
50600 }
50601
50602
50603 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50604 PyObject *resultobj = 0;
50605 wxSizer *arg1 = (wxSizer *) 0 ;
50606 wxPoint result;
50607 void *argp1 = 0 ;
50608 int res1 = 0 ;
50609 PyObject *swig_obj[1] ;
50610
50611 if (!args) SWIG_fail;
50612 swig_obj[0] = args;
50613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50614 if (!SWIG_IsOK(res1)) {
50615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
50616 }
50617 arg1 = reinterpret_cast< wxSizer * >(argp1);
50618 {
50619 PyThreadState* __tstate = wxPyBeginAllowThreads();
50620 result = (arg1)->GetPosition();
50621 wxPyEndAllowThreads(__tstate);
50622 if (PyErr_Occurred()) SWIG_fail;
50623 }
50624 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50625 return resultobj;
50626 fail:
50627 return NULL;
50628 }
50629
50630
50631 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50632 PyObject *resultobj = 0;
50633 wxSizer *arg1 = (wxSizer *) 0 ;
50634 wxSize result;
50635 void *argp1 = 0 ;
50636 int res1 = 0 ;
50637 PyObject *swig_obj[1] ;
50638
50639 if (!args) SWIG_fail;
50640 swig_obj[0] = args;
50641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50642 if (!SWIG_IsOK(res1)) {
50643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50644 }
50645 arg1 = reinterpret_cast< wxSizer * >(argp1);
50646 {
50647 PyThreadState* __tstate = wxPyBeginAllowThreads();
50648 result = (arg1)->GetMinSize();
50649 wxPyEndAllowThreads(__tstate);
50650 if (PyErr_Occurred()) SWIG_fail;
50651 }
50652 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50653 return resultobj;
50654 fail:
50655 return NULL;
50656 }
50657
50658
50659 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50660 PyObject *resultobj = 0;
50661 wxSizer *arg1 = (wxSizer *) 0 ;
50662 void *argp1 = 0 ;
50663 int res1 = 0 ;
50664 PyObject *swig_obj[1] ;
50665
50666 if (!args) SWIG_fail;
50667 swig_obj[0] = args;
50668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50669 if (!SWIG_IsOK(res1)) {
50670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
50671 }
50672 arg1 = reinterpret_cast< wxSizer * >(argp1);
50673 {
50674 PyThreadState* __tstate = wxPyBeginAllowThreads();
50675 (arg1)->RecalcSizes();
50676 wxPyEndAllowThreads(__tstate);
50677 if (PyErr_Occurred()) SWIG_fail;
50678 }
50679 resultobj = SWIG_Py_Void();
50680 return resultobj;
50681 fail:
50682 return NULL;
50683 }
50684
50685
50686 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50687 PyObject *resultobj = 0;
50688 wxSizer *arg1 = (wxSizer *) 0 ;
50689 wxSize result;
50690 void *argp1 = 0 ;
50691 int res1 = 0 ;
50692 PyObject *swig_obj[1] ;
50693
50694 if (!args) SWIG_fail;
50695 swig_obj[0] = args;
50696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50697 if (!SWIG_IsOK(res1)) {
50698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
50699 }
50700 arg1 = reinterpret_cast< wxSizer * >(argp1);
50701 {
50702 PyThreadState* __tstate = wxPyBeginAllowThreads();
50703 result = (arg1)->CalcMin();
50704 wxPyEndAllowThreads(__tstate);
50705 if (PyErr_Occurred()) SWIG_fail;
50706 }
50707 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50708 return resultobj;
50709 fail:
50710 return NULL;
50711 }
50712
50713
50714 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50715 PyObject *resultobj = 0;
50716 wxSizer *arg1 = (wxSizer *) 0 ;
50717 void *argp1 = 0 ;
50718 int res1 = 0 ;
50719 PyObject *swig_obj[1] ;
50720
50721 if (!args) SWIG_fail;
50722 swig_obj[0] = args;
50723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50724 if (!SWIG_IsOK(res1)) {
50725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
50726 }
50727 arg1 = reinterpret_cast< wxSizer * >(argp1);
50728 {
50729 PyThreadState* __tstate = wxPyBeginAllowThreads();
50730 (arg1)->Layout();
50731 wxPyEndAllowThreads(__tstate);
50732 if (PyErr_Occurred()) SWIG_fail;
50733 }
50734 resultobj = SWIG_Py_Void();
50735 return resultobj;
50736 fail:
50737 return NULL;
50738 }
50739
50740
50741 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50742 PyObject *resultobj = 0;
50743 wxSizer *arg1 = (wxSizer *) 0 ;
50744 wxWindow *arg2 = (wxWindow *) 0 ;
50745 wxSize result;
50746 void *argp1 = 0 ;
50747 int res1 = 0 ;
50748 void *argp2 = 0 ;
50749 int res2 = 0 ;
50750 PyObject * obj0 = 0 ;
50751 PyObject * obj1 = 0 ;
50752 char * kwnames[] = {
50753 (char *) "self",(char *) "window", NULL
50754 };
50755
50756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
50757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50758 if (!SWIG_IsOK(res1)) {
50759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
50760 }
50761 arg1 = reinterpret_cast< wxSizer * >(argp1);
50762 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50763 if (!SWIG_IsOK(res2)) {
50764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
50765 }
50766 arg2 = reinterpret_cast< wxWindow * >(argp2);
50767 {
50768 PyThreadState* __tstate = wxPyBeginAllowThreads();
50769 result = (arg1)->Fit(arg2);
50770 wxPyEndAllowThreads(__tstate);
50771 if (PyErr_Occurred()) SWIG_fail;
50772 }
50773 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50774 return resultobj;
50775 fail:
50776 return NULL;
50777 }
50778
50779
50780 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50781 PyObject *resultobj = 0;
50782 wxSizer *arg1 = (wxSizer *) 0 ;
50783 wxWindow *arg2 = (wxWindow *) 0 ;
50784 void *argp1 = 0 ;
50785 int res1 = 0 ;
50786 void *argp2 = 0 ;
50787 int res2 = 0 ;
50788 PyObject * obj0 = 0 ;
50789 PyObject * obj1 = 0 ;
50790 char * kwnames[] = {
50791 (char *) "self",(char *) "window", NULL
50792 };
50793
50794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
50795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50796 if (!SWIG_IsOK(res1)) {
50797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
50798 }
50799 arg1 = reinterpret_cast< wxSizer * >(argp1);
50800 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50801 if (!SWIG_IsOK(res2)) {
50802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
50803 }
50804 arg2 = reinterpret_cast< wxWindow * >(argp2);
50805 {
50806 PyThreadState* __tstate = wxPyBeginAllowThreads();
50807 (arg1)->FitInside(arg2);
50808 wxPyEndAllowThreads(__tstate);
50809 if (PyErr_Occurred()) SWIG_fail;
50810 }
50811 resultobj = SWIG_Py_Void();
50812 return resultobj;
50813 fail:
50814 return NULL;
50815 }
50816
50817
50818 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50819 PyObject *resultobj = 0;
50820 wxSizer *arg1 = (wxSizer *) 0 ;
50821 wxWindow *arg2 = (wxWindow *) 0 ;
50822 void *argp1 = 0 ;
50823 int res1 = 0 ;
50824 void *argp2 = 0 ;
50825 int res2 = 0 ;
50826 PyObject * obj0 = 0 ;
50827 PyObject * obj1 = 0 ;
50828 char * kwnames[] = {
50829 (char *) "self",(char *) "window", NULL
50830 };
50831
50832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50834 if (!SWIG_IsOK(res1)) {
50835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50836 }
50837 arg1 = reinterpret_cast< wxSizer * >(argp1);
50838 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50839 if (!SWIG_IsOK(res2)) {
50840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50841 }
50842 arg2 = reinterpret_cast< wxWindow * >(argp2);
50843 {
50844 PyThreadState* __tstate = wxPyBeginAllowThreads();
50845 (arg1)->SetSizeHints(arg2);
50846 wxPyEndAllowThreads(__tstate);
50847 if (PyErr_Occurred()) SWIG_fail;
50848 }
50849 resultobj = SWIG_Py_Void();
50850 return resultobj;
50851 fail:
50852 return NULL;
50853 }
50854
50855
50856 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50857 PyObject *resultobj = 0;
50858 wxSizer *arg1 = (wxSizer *) 0 ;
50859 wxWindow *arg2 = (wxWindow *) 0 ;
50860 void *argp1 = 0 ;
50861 int res1 = 0 ;
50862 void *argp2 = 0 ;
50863 int res2 = 0 ;
50864 PyObject * obj0 = 0 ;
50865 PyObject * obj1 = 0 ;
50866 char * kwnames[] = {
50867 (char *) "self",(char *) "window", NULL
50868 };
50869
50870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50872 if (!SWIG_IsOK(res1)) {
50873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50874 }
50875 arg1 = reinterpret_cast< wxSizer * >(argp1);
50876 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50877 if (!SWIG_IsOK(res2)) {
50878 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50879 }
50880 arg2 = reinterpret_cast< wxWindow * >(argp2);
50881 {
50882 PyThreadState* __tstate = wxPyBeginAllowThreads();
50883 (arg1)->SetVirtualSizeHints(arg2);
50884 wxPyEndAllowThreads(__tstate);
50885 if (PyErr_Occurred()) SWIG_fail;
50886 }
50887 resultobj = SWIG_Py_Void();
50888 return resultobj;
50889 fail:
50890 return NULL;
50891 }
50892
50893
50894 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50895 PyObject *resultobj = 0;
50896 wxSizer *arg1 = (wxSizer *) 0 ;
50897 bool arg2 = (bool) false ;
50898 void *argp1 = 0 ;
50899 int res1 = 0 ;
50900 bool val2 ;
50901 int ecode2 = 0 ;
50902 PyObject * obj0 = 0 ;
50903 PyObject * obj1 = 0 ;
50904 char * kwnames[] = {
50905 (char *) "self",(char *) "deleteWindows", NULL
50906 };
50907
50908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
50909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50910 if (!SWIG_IsOK(res1)) {
50911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
50912 }
50913 arg1 = reinterpret_cast< wxSizer * >(argp1);
50914 if (obj1) {
50915 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50916 if (!SWIG_IsOK(ecode2)) {
50917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
50918 }
50919 arg2 = static_cast< bool >(val2);
50920 }
50921 {
50922 PyThreadState* __tstate = wxPyBeginAllowThreads();
50923 (arg1)->Clear(arg2);
50924 wxPyEndAllowThreads(__tstate);
50925 if (PyErr_Occurred()) SWIG_fail;
50926 }
50927 resultobj = SWIG_Py_Void();
50928 return resultobj;
50929 fail:
50930 return NULL;
50931 }
50932
50933
50934 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50935 PyObject *resultobj = 0;
50936 wxSizer *arg1 = (wxSizer *) 0 ;
50937 void *argp1 = 0 ;
50938 int res1 = 0 ;
50939 PyObject *swig_obj[1] ;
50940
50941 if (!args) SWIG_fail;
50942 swig_obj[0] = args;
50943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50944 if (!SWIG_IsOK(res1)) {
50945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
50946 }
50947 arg1 = reinterpret_cast< wxSizer * >(argp1);
50948 {
50949 PyThreadState* __tstate = wxPyBeginAllowThreads();
50950 (arg1)->DeleteWindows();
50951 wxPyEndAllowThreads(__tstate);
50952 if (PyErr_Occurred()) SWIG_fail;
50953 }
50954 resultobj = SWIG_Py_Void();
50955 return resultobj;
50956 fail:
50957 return NULL;
50958 }
50959
50960
50961 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50962 PyObject *resultobj = 0;
50963 wxSizer *arg1 = (wxSizer *) 0 ;
50964 PyObject *result = 0 ;
50965 void *argp1 = 0 ;
50966 int res1 = 0 ;
50967 PyObject *swig_obj[1] ;
50968
50969 if (!args) SWIG_fail;
50970 swig_obj[0] = args;
50971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50972 if (!SWIG_IsOK(res1)) {
50973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
50974 }
50975 arg1 = reinterpret_cast< wxSizer * >(argp1);
50976 {
50977 PyThreadState* __tstate = wxPyBeginAllowThreads();
50978 result = (PyObject *)wxSizer_GetChildren(arg1);
50979 wxPyEndAllowThreads(__tstate);
50980 if (PyErr_Occurred()) SWIG_fail;
50981 }
50982 resultobj = result;
50983 return resultobj;
50984 fail:
50985 return NULL;
50986 }
50987
50988
50989 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50990 PyObject *resultobj = 0;
50991 wxSizer *arg1 = (wxSizer *) 0 ;
50992 PyObject *arg2 = (PyObject *) 0 ;
50993 bool arg3 = (bool) true ;
50994 bool arg4 = (bool) false ;
50995 bool result;
50996 void *argp1 = 0 ;
50997 int res1 = 0 ;
50998 bool val3 ;
50999 int ecode3 = 0 ;
51000 bool val4 ;
51001 int ecode4 = 0 ;
51002 PyObject * obj0 = 0 ;
51003 PyObject * obj1 = 0 ;
51004 PyObject * obj2 = 0 ;
51005 PyObject * obj3 = 0 ;
51006 char * kwnames[] = {
51007 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
51008 };
51009
51010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51012 if (!SWIG_IsOK(res1)) {
51013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
51014 }
51015 arg1 = reinterpret_cast< wxSizer * >(argp1);
51016 arg2 = obj1;
51017 if (obj2) {
51018 ecode3 = SWIG_AsVal_bool(obj2, &val3);
51019 if (!SWIG_IsOK(ecode3)) {
51020 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
51021 }
51022 arg3 = static_cast< bool >(val3);
51023 }
51024 if (obj3) {
51025 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51026 if (!SWIG_IsOK(ecode4)) {
51027 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
51028 }
51029 arg4 = static_cast< bool >(val4);
51030 }
51031 {
51032 PyThreadState* __tstate = wxPyBeginAllowThreads();
51033 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
51034 wxPyEndAllowThreads(__tstate);
51035 if (PyErr_Occurred()) SWIG_fail;
51036 }
51037 {
51038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51039 }
51040 return resultobj;
51041 fail:
51042 return NULL;
51043 }
51044
51045
51046 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51047 PyObject *resultobj = 0;
51048 wxSizer *arg1 = (wxSizer *) 0 ;
51049 PyObject *arg2 = (PyObject *) 0 ;
51050 bool result;
51051 void *argp1 = 0 ;
51052 int res1 = 0 ;
51053 PyObject * obj0 = 0 ;
51054 PyObject * obj1 = 0 ;
51055 char * kwnames[] = {
51056 (char *) "self",(char *) "item", NULL
51057 };
51058
51059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
51060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51061 if (!SWIG_IsOK(res1)) {
51062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
51063 }
51064 arg1 = reinterpret_cast< wxSizer * >(argp1);
51065 arg2 = obj1;
51066 {
51067 PyThreadState* __tstate = wxPyBeginAllowThreads();
51068 result = (bool)wxSizer_IsShown(arg1,arg2);
51069 wxPyEndAllowThreads(__tstate);
51070 if (PyErr_Occurred()) SWIG_fail;
51071 }
51072 {
51073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51074 }
51075 return resultobj;
51076 fail:
51077 return NULL;
51078 }
51079
51080
51081 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51082 PyObject *resultobj = 0;
51083 wxSizer *arg1 = (wxSizer *) 0 ;
51084 bool arg2 ;
51085 void *argp1 = 0 ;
51086 int res1 = 0 ;
51087 bool val2 ;
51088 int ecode2 = 0 ;
51089 PyObject * obj0 = 0 ;
51090 PyObject * obj1 = 0 ;
51091 char * kwnames[] = {
51092 (char *) "self",(char *) "show", NULL
51093 };
51094
51095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
51096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51097 if (!SWIG_IsOK(res1)) {
51098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
51099 }
51100 arg1 = reinterpret_cast< wxSizer * >(argp1);
51101 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51102 if (!SWIG_IsOK(ecode2)) {
51103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
51104 }
51105 arg2 = static_cast< bool >(val2);
51106 {
51107 PyThreadState* __tstate = wxPyBeginAllowThreads();
51108 (arg1)->ShowItems(arg2);
51109 wxPyEndAllowThreads(__tstate);
51110 if (PyErr_Occurred()) SWIG_fail;
51111 }
51112 resultobj = SWIG_Py_Void();
51113 return resultobj;
51114 fail:
51115 return NULL;
51116 }
51117
51118
51119 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51120 PyObject *obj;
51121 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51122 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
51123 return SWIG_Py_Void();
51124 }
51125
51126 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51127 PyObject *resultobj = 0;
51128 wxPySizer *result = 0 ;
51129
51130 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
51131 {
51132 PyThreadState* __tstate = wxPyBeginAllowThreads();
51133 result = (wxPySizer *)new wxPySizer();
51134 wxPyEndAllowThreads(__tstate);
51135 if (PyErr_Occurred()) SWIG_fail;
51136 }
51137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
51138 return resultobj;
51139 fail:
51140 return NULL;
51141 }
51142
51143
51144 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51145 PyObject *resultobj = 0;
51146 wxPySizer *arg1 = (wxPySizer *) 0 ;
51147 PyObject *arg2 = (PyObject *) 0 ;
51148 PyObject *arg3 = (PyObject *) 0 ;
51149 void *argp1 = 0 ;
51150 int res1 = 0 ;
51151 PyObject * obj0 = 0 ;
51152 PyObject * obj1 = 0 ;
51153 PyObject * obj2 = 0 ;
51154 char * kwnames[] = {
51155 (char *) "self",(char *) "self",(char *) "_class", NULL
51156 };
51157
51158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
51160 if (!SWIG_IsOK(res1)) {
51161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
51162 }
51163 arg1 = reinterpret_cast< wxPySizer * >(argp1);
51164 arg2 = obj1;
51165 arg3 = obj2;
51166 {
51167 PyThreadState* __tstate = wxPyBeginAllowThreads();
51168 (arg1)->_setCallbackInfo(arg2,arg3);
51169 wxPyEndAllowThreads(__tstate);
51170 if (PyErr_Occurred()) SWIG_fail;
51171 }
51172 resultobj = SWIG_Py_Void();
51173 return resultobj;
51174 fail:
51175 return NULL;
51176 }
51177
51178
51179 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51180 PyObject *obj;
51181 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51182 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
51183 return SWIG_Py_Void();
51184 }
51185
51186 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51187 return SWIG_Python_InitShadowInstance(args);
51188 }
51189
51190 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51191 PyObject *resultobj = 0;
51192 int arg1 = (int) wxHORIZONTAL ;
51193 wxBoxSizer *result = 0 ;
51194 int val1 ;
51195 int ecode1 = 0 ;
51196 PyObject * obj0 = 0 ;
51197 char * kwnames[] = {
51198 (char *) "orient", NULL
51199 };
51200
51201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
51202 if (obj0) {
51203 ecode1 = SWIG_AsVal_int(obj0, &val1);
51204 if (!SWIG_IsOK(ecode1)) {
51205 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
51206 }
51207 arg1 = static_cast< int >(val1);
51208 }
51209 {
51210 PyThreadState* __tstate = wxPyBeginAllowThreads();
51211 result = (wxBoxSizer *)new wxBoxSizer(arg1);
51212 wxPyEndAllowThreads(__tstate);
51213 if (PyErr_Occurred()) SWIG_fail;
51214 }
51215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
51216 return resultobj;
51217 fail:
51218 return NULL;
51219 }
51220
51221
51222 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51223 PyObject *resultobj = 0;
51224 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51225 int result;
51226 void *argp1 = 0 ;
51227 int res1 = 0 ;
51228 PyObject *swig_obj[1] ;
51229
51230 if (!args) SWIG_fail;
51231 swig_obj[0] = args;
51232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51233 if (!SWIG_IsOK(res1)) {
51234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51235 }
51236 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51237 {
51238 PyThreadState* __tstate = wxPyBeginAllowThreads();
51239 result = (int)(arg1)->GetOrientation();
51240 wxPyEndAllowThreads(__tstate);
51241 if (PyErr_Occurred()) SWIG_fail;
51242 }
51243 resultobj = SWIG_From_int(static_cast< int >(result));
51244 return resultobj;
51245 fail:
51246 return NULL;
51247 }
51248
51249
51250 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51251 PyObject *resultobj = 0;
51252 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51253 int arg2 ;
51254 void *argp1 = 0 ;
51255 int res1 = 0 ;
51256 int val2 ;
51257 int ecode2 = 0 ;
51258 PyObject * obj0 = 0 ;
51259 PyObject * obj1 = 0 ;
51260 char * kwnames[] = {
51261 (char *) "self",(char *) "orient", NULL
51262 };
51263
51264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
51265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51266 if (!SWIG_IsOK(res1)) {
51267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51268 }
51269 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51270 ecode2 = SWIG_AsVal_int(obj1, &val2);
51271 if (!SWIG_IsOK(ecode2)) {
51272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
51273 }
51274 arg2 = static_cast< int >(val2);
51275 {
51276 PyThreadState* __tstate = wxPyBeginAllowThreads();
51277 (arg1)->SetOrientation(arg2);
51278 wxPyEndAllowThreads(__tstate);
51279 if (PyErr_Occurred()) SWIG_fail;
51280 }
51281 resultobj = SWIG_Py_Void();
51282 return resultobj;
51283 fail:
51284 return NULL;
51285 }
51286
51287
51288 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51289 PyObject *obj;
51290 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51291 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
51292 return SWIG_Py_Void();
51293 }
51294
51295 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51296 return SWIG_Python_InitShadowInstance(args);
51297 }
51298
51299 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51300 PyObject *resultobj = 0;
51301 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
51302 int arg2 = (int) wxHORIZONTAL ;
51303 wxStaticBoxSizer *result = 0 ;
51304 void *argp1 = 0 ;
51305 int res1 = 0 ;
51306 int val2 ;
51307 int ecode2 = 0 ;
51308 PyObject * obj0 = 0 ;
51309 PyObject * obj1 = 0 ;
51310 char * kwnames[] = {
51311 (char *) "box",(char *) "orient", NULL
51312 };
51313
51314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
51316 if (!SWIG_IsOK(res1)) {
51317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
51318 }
51319 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
51320 if (obj1) {
51321 ecode2 = SWIG_AsVal_int(obj1, &val2);
51322 if (!SWIG_IsOK(ecode2)) {
51323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
51324 }
51325 arg2 = static_cast< int >(val2);
51326 }
51327 {
51328 PyThreadState* __tstate = wxPyBeginAllowThreads();
51329 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
51330 wxPyEndAllowThreads(__tstate);
51331 if (PyErr_Occurred()) SWIG_fail;
51332 }
51333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
51334 return resultobj;
51335 fail:
51336 return NULL;
51337 }
51338
51339
51340 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51341 PyObject *resultobj = 0;
51342 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
51343 wxStaticBox *result = 0 ;
51344 void *argp1 = 0 ;
51345 int res1 = 0 ;
51346 PyObject *swig_obj[1] ;
51347
51348 if (!args) SWIG_fail;
51349 swig_obj[0] = args;
51350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
51351 if (!SWIG_IsOK(res1)) {
51352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
51353 }
51354 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
51355 {
51356 PyThreadState* __tstate = wxPyBeginAllowThreads();
51357 result = (wxStaticBox *)(arg1)->GetStaticBox();
51358 wxPyEndAllowThreads(__tstate);
51359 if (PyErr_Occurred()) SWIG_fail;
51360 }
51361 {
51362 resultobj = wxPyMake_wxObject(result, (bool)0);
51363 }
51364 return resultobj;
51365 fail:
51366 return NULL;
51367 }
51368
51369
51370 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51371 PyObject *obj;
51372 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51373 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
51374 return SWIG_Py_Void();
51375 }
51376
51377 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51378 return SWIG_Python_InitShadowInstance(args);
51379 }
51380
51381 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51382 PyObject *resultobj = 0;
51383 int arg1 = (int) 1 ;
51384 int arg2 = (int) 0 ;
51385 int arg3 = (int) 0 ;
51386 int arg4 = (int) 0 ;
51387 wxGridSizer *result = 0 ;
51388 int val1 ;
51389 int ecode1 = 0 ;
51390 int val2 ;
51391 int ecode2 = 0 ;
51392 int val3 ;
51393 int ecode3 = 0 ;
51394 int val4 ;
51395 int ecode4 = 0 ;
51396 PyObject * obj0 = 0 ;
51397 PyObject * obj1 = 0 ;
51398 PyObject * obj2 = 0 ;
51399 PyObject * obj3 = 0 ;
51400 char * kwnames[] = {
51401 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51402 };
51403
51404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51405 if (obj0) {
51406 ecode1 = SWIG_AsVal_int(obj0, &val1);
51407 if (!SWIG_IsOK(ecode1)) {
51408 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
51409 }
51410 arg1 = static_cast< int >(val1);
51411 }
51412 if (obj1) {
51413 ecode2 = SWIG_AsVal_int(obj1, &val2);
51414 if (!SWIG_IsOK(ecode2)) {
51415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
51416 }
51417 arg2 = static_cast< int >(val2);
51418 }
51419 if (obj2) {
51420 ecode3 = SWIG_AsVal_int(obj2, &val3);
51421 if (!SWIG_IsOK(ecode3)) {
51422 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
51423 }
51424 arg3 = static_cast< int >(val3);
51425 }
51426 if (obj3) {
51427 ecode4 = SWIG_AsVal_int(obj3, &val4);
51428 if (!SWIG_IsOK(ecode4)) {
51429 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
51430 }
51431 arg4 = static_cast< int >(val4);
51432 }
51433 {
51434 PyThreadState* __tstate = wxPyBeginAllowThreads();
51435 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
51436 wxPyEndAllowThreads(__tstate);
51437 if (PyErr_Occurred()) SWIG_fail;
51438 }
51439 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
51440 return resultobj;
51441 fail:
51442 return NULL;
51443 }
51444
51445
51446 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51447 PyObject *resultobj = 0;
51448 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51449 int arg2 ;
51450 void *argp1 = 0 ;
51451 int res1 = 0 ;
51452 int val2 ;
51453 int ecode2 = 0 ;
51454 PyObject * obj0 = 0 ;
51455 PyObject * obj1 = 0 ;
51456 char * kwnames[] = {
51457 (char *) "self",(char *) "cols", NULL
51458 };
51459
51460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
51461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51462 if (!SWIG_IsOK(res1)) {
51463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51464 }
51465 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51466 ecode2 = SWIG_AsVal_int(obj1, &val2);
51467 if (!SWIG_IsOK(ecode2)) {
51468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
51469 }
51470 arg2 = static_cast< int >(val2);
51471 {
51472 PyThreadState* __tstate = wxPyBeginAllowThreads();
51473 (arg1)->SetCols(arg2);
51474 wxPyEndAllowThreads(__tstate);
51475 if (PyErr_Occurred()) SWIG_fail;
51476 }
51477 resultobj = SWIG_Py_Void();
51478 return resultobj;
51479 fail:
51480 return NULL;
51481 }
51482
51483
51484 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51485 PyObject *resultobj = 0;
51486 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51487 int arg2 ;
51488 void *argp1 = 0 ;
51489 int res1 = 0 ;
51490 int val2 ;
51491 int ecode2 = 0 ;
51492 PyObject * obj0 = 0 ;
51493 PyObject * obj1 = 0 ;
51494 char * kwnames[] = {
51495 (char *) "self",(char *) "rows", NULL
51496 };
51497
51498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
51499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51500 if (!SWIG_IsOK(res1)) {
51501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51502 }
51503 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51504 ecode2 = SWIG_AsVal_int(obj1, &val2);
51505 if (!SWIG_IsOK(ecode2)) {
51506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
51507 }
51508 arg2 = static_cast< int >(val2);
51509 {
51510 PyThreadState* __tstate = wxPyBeginAllowThreads();
51511 (arg1)->SetRows(arg2);
51512 wxPyEndAllowThreads(__tstate);
51513 if (PyErr_Occurred()) SWIG_fail;
51514 }
51515 resultobj = SWIG_Py_Void();
51516 return resultobj;
51517 fail:
51518 return NULL;
51519 }
51520
51521
51522 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51523 PyObject *resultobj = 0;
51524 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51525 int arg2 ;
51526 void *argp1 = 0 ;
51527 int res1 = 0 ;
51528 int val2 ;
51529 int ecode2 = 0 ;
51530 PyObject * obj0 = 0 ;
51531 PyObject * obj1 = 0 ;
51532 char * kwnames[] = {
51533 (char *) "self",(char *) "gap", NULL
51534 };
51535
51536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
51537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51538 if (!SWIG_IsOK(res1)) {
51539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51540 }
51541 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51542 ecode2 = SWIG_AsVal_int(obj1, &val2);
51543 if (!SWIG_IsOK(ecode2)) {
51544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
51545 }
51546 arg2 = static_cast< int >(val2);
51547 {
51548 PyThreadState* __tstate = wxPyBeginAllowThreads();
51549 (arg1)->SetVGap(arg2);
51550 wxPyEndAllowThreads(__tstate);
51551 if (PyErr_Occurred()) SWIG_fail;
51552 }
51553 resultobj = SWIG_Py_Void();
51554 return resultobj;
51555 fail:
51556 return NULL;
51557 }
51558
51559
51560 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51561 PyObject *resultobj = 0;
51562 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51563 int arg2 ;
51564 void *argp1 = 0 ;
51565 int res1 = 0 ;
51566 int val2 ;
51567 int ecode2 = 0 ;
51568 PyObject * obj0 = 0 ;
51569 PyObject * obj1 = 0 ;
51570 char * kwnames[] = {
51571 (char *) "self",(char *) "gap", NULL
51572 };
51573
51574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
51575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51576 if (!SWIG_IsOK(res1)) {
51577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51578 }
51579 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51580 ecode2 = SWIG_AsVal_int(obj1, &val2);
51581 if (!SWIG_IsOK(ecode2)) {
51582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
51583 }
51584 arg2 = static_cast< int >(val2);
51585 {
51586 PyThreadState* __tstate = wxPyBeginAllowThreads();
51587 (arg1)->SetHGap(arg2);
51588 wxPyEndAllowThreads(__tstate);
51589 if (PyErr_Occurred()) SWIG_fail;
51590 }
51591 resultobj = SWIG_Py_Void();
51592 return resultobj;
51593 fail:
51594 return NULL;
51595 }
51596
51597
51598 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51599 PyObject *resultobj = 0;
51600 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51601 int result;
51602 void *argp1 = 0 ;
51603 int res1 = 0 ;
51604 PyObject *swig_obj[1] ;
51605
51606 if (!args) SWIG_fail;
51607 swig_obj[0] = args;
51608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51609 if (!SWIG_IsOK(res1)) {
51610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51611 }
51612 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51613 {
51614 PyThreadState* __tstate = wxPyBeginAllowThreads();
51615 result = (int)(arg1)->GetCols();
51616 wxPyEndAllowThreads(__tstate);
51617 if (PyErr_Occurred()) SWIG_fail;
51618 }
51619 resultobj = SWIG_From_int(static_cast< int >(result));
51620 return resultobj;
51621 fail:
51622 return NULL;
51623 }
51624
51625
51626 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51627 PyObject *resultobj = 0;
51628 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51629 int result;
51630 void *argp1 = 0 ;
51631 int res1 = 0 ;
51632 PyObject *swig_obj[1] ;
51633
51634 if (!args) SWIG_fail;
51635 swig_obj[0] = args;
51636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51637 if (!SWIG_IsOK(res1)) {
51638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51639 }
51640 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51641 {
51642 PyThreadState* __tstate = wxPyBeginAllowThreads();
51643 result = (int)(arg1)->GetRows();
51644 wxPyEndAllowThreads(__tstate);
51645 if (PyErr_Occurred()) SWIG_fail;
51646 }
51647 resultobj = SWIG_From_int(static_cast< int >(result));
51648 return resultobj;
51649 fail:
51650 return NULL;
51651 }
51652
51653
51654 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51655 PyObject *resultobj = 0;
51656 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51657 int result;
51658 void *argp1 = 0 ;
51659 int res1 = 0 ;
51660 PyObject *swig_obj[1] ;
51661
51662 if (!args) SWIG_fail;
51663 swig_obj[0] = args;
51664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51665 if (!SWIG_IsOK(res1)) {
51666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51667 }
51668 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51669 {
51670 PyThreadState* __tstate = wxPyBeginAllowThreads();
51671 result = (int)(arg1)->GetVGap();
51672 wxPyEndAllowThreads(__tstate);
51673 if (PyErr_Occurred()) SWIG_fail;
51674 }
51675 resultobj = SWIG_From_int(static_cast< int >(result));
51676 return resultobj;
51677 fail:
51678 return NULL;
51679 }
51680
51681
51682 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51683 PyObject *resultobj = 0;
51684 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51685 int result;
51686 void *argp1 = 0 ;
51687 int res1 = 0 ;
51688 PyObject *swig_obj[1] ;
51689
51690 if (!args) SWIG_fail;
51691 swig_obj[0] = args;
51692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51693 if (!SWIG_IsOK(res1)) {
51694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51695 }
51696 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51697 {
51698 PyThreadState* __tstate = wxPyBeginAllowThreads();
51699 result = (int)(arg1)->GetHGap();
51700 wxPyEndAllowThreads(__tstate);
51701 if (PyErr_Occurred()) SWIG_fail;
51702 }
51703 resultobj = SWIG_From_int(static_cast< int >(result));
51704 return resultobj;
51705 fail:
51706 return NULL;
51707 }
51708
51709
51710 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51711 PyObject *obj;
51712 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51713 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
51714 return SWIG_Py_Void();
51715 }
51716
51717 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51718 return SWIG_Python_InitShadowInstance(args);
51719 }
51720
51721 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51722 PyObject *resultobj = 0;
51723 int arg1 = (int) 1 ;
51724 int arg2 = (int) 0 ;
51725 int arg3 = (int) 0 ;
51726 int arg4 = (int) 0 ;
51727 wxFlexGridSizer *result = 0 ;
51728 int val1 ;
51729 int ecode1 = 0 ;
51730 int val2 ;
51731 int ecode2 = 0 ;
51732 int val3 ;
51733 int ecode3 = 0 ;
51734 int val4 ;
51735 int ecode4 = 0 ;
51736 PyObject * obj0 = 0 ;
51737 PyObject * obj1 = 0 ;
51738 PyObject * obj2 = 0 ;
51739 PyObject * obj3 = 0 ;
51740 char * kwnames[] = {
51741 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51742 };
51743
51744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51745 if (obj0) {
51746 ecode1 = SWIG_AsVal_int(obj0, &val1);
51747 if (!SWIG_IsOK(ecode1)) {
51748 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
51749 }
51750 arg1 = static_cast< int >(val1);
51751 }
51752 if (obj1) {
51753 ecode2 = SWIG_AsVal_int(obj1, &val2);
51754 if (!SWIG_IsOK(ecode2)) {
51755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
51756 }
51757 arg2 = static_cast< int >(val2);
51758 }
51759 if (obj2) {
51760 ecode3 = SWIG_AsVal_int(obj2, &val3);
51761 if (!SWIG_IsOK(ecode3)) {
51762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
51763 }
51764 arg3 = static_cast< int >(val3);
51765 }
51766 if (obj3) {
51767 ecode4 = SWIG_AsVal_int(obj3, &val4);
51768 if (!SWIG_IsOK(ecode4)) {
51769 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
51770 }
51771 arg4 = static_cast< int >(val4);
51772 }
51773 {
51774 PyThreadState* __tstate = wxPyBeginAllowThreads();
51775 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
51776 wxPyEndAllowThreads(__tstate);
51777 if (PyErr_Occurred()) SWIG_fail;
51778 }
51779 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
51780 return resultobj;
51781 fail:
51782 return NULL;
51783 }
51784
51785
51786 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51787 PyObject *resultobj = 0;
51788 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51789 size_t arg2 ;
51790 int arg3 = (int) 0 ;
51791 void *argp1 = 0 ;
51792 int res1 = 0 ;
51793 size_t val2 ;
51794 int ecode2 = 0 ;
51795 int val3 ;
51796 int ecode3 = 0 ;
51797 PyObject * obj0 = 0 ;
51798 PyObject * obj1 = 0 ;
51799 PyObject * obj2 = 0 ;
51800 char * kwnames[] = {
51801 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51802 };
51803
51804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51806 if (!SWIG_IsOK(res1)) {
51807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51808 }
51809 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51810 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51811 if (!SWIG_IsOK(ecode2)) {
51812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51813 }
51814 arg2 = static_cast< size_t >(val2);
51815 if (obj2) {
51816 ecode3 = SWIG_AsVal_int(obj2, &val3);
51817 if (!SWIG_IsOK(ecode3)) {
51818 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
51819 }
51820 arg3 = static_cast< int >(val3);
51821 }
51822 {
51823 PyThreadState* __tstate = wxPyBeginAllowThreads();
51824 (arg1)->AddGrowableRow(arg2,arg3);
51825 wxPyEndAllowThreads(__tstate);
51826 if (PyErr_Occurred()) SWIG_fail;
51827 }
51828 resultobj = SWIG_Py_Void();
51829 return resultobj;
51830 fail:
51831 return NULL;
51832 }
51833
51834
51835 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51836 PyObject *resultobj = 0;
51837 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51838 size_t arg2 ;
51839 void *argp1 = 0 ;
51840 int res1 = 0 ;
51841 size_t val2 ;
51842 int ecode2 = 0 ;
51843 PyObject * obj0 = 0 ;
51844 PyObject * obj1 = 0 ;
51845 char * kwnames[] = {
51846 (char *) "self",(char *) "idx", NULL
51847 };
51848
51849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
51850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51851 if (!SWIG_IsOK(res1)) {
51852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51853 }
51854 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51855 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51856 if (!SWIG_IsOK(ecode2)) {
51857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51858 }
51859 arg2 = static_cast< size_t >(val2);
51860 {
51861 PyThreadState* __tstate = wxPyBeginAllowThreads();
51862 (arg1)->RemoveGrowableRow(arg2);
51863 wxPyEndAllowThreads(__tstate);
51864 if (PyErr_Occurred()) SWIG_fail;
51865 }
51866 resultobj = SWIG_Py_Void();
51867 return resultobj;
51868 fail:
51869 return NULL;
51870 }
51871
51872
51873 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51874 PyObject *resultobj = 0;
51875 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51876 size_t arg2 ;
51877 int arg3 = (int) 0 ;
51878 void *argp1 = 0 ;
51879 int res1 = 0 ;
51880 size_t val2 ;
51881 int ecode2 = 0 ;
51882 int val3 ;
51883 int ecode3 = 0 ;
51884 PyObject * obj0 = 0 ;
51885 PyObject * obj1 = 0 ;
51886 PyObject * obj2 = 0 ;
51887 char * kwnames[] = {
51888 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51889 };
51890
51891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51893 if (!SWIG_IsOK(res1)) {
51894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51895 }
51896 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51897 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51898 if (!SWIG_IsOK(ecode2)) {
51899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51900 }
51901 arg2 = static_cast< size_t >(val2);
51902 if (obj2) {
51903 ecode3 = SWIG_AsVal_int(obj2, &val3);
51904 if (!SWIG_IsOK(ecode3)) {
51905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
51906 }
51907 arg3 = static_cast< int >(val3);
51908 }
51909 {
51910 PyThreadState* __tstate = wxPyBeginAllowThreads();
51911 (arg1)->AddGrowableCol(arg2,arg3);
51912 wxPyEndAllowThreads(__tstate);
51913 if (PyErr_Occurred()) SWIG_fail;
51914 }
51915 resultobj = SWIG_Py_Void();
51916 return resultobj;
51917 fail:
51918 return NULL;
51919 }
51920
51921
51922 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51923 PyObject *resultobj = 0;
51924 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51925 size_t arg2 ;
51926 void *argp1 = 0 ;
51927 int res1 = 0 ;
51928 size_t val2 ;
51929 int ecode2 = 0 ;
51930 PyObject * obj0 = 0 ;
51931 PyObject * obj1 = 0 ;
51932 char * kwnames[] = {
51933 (char *) "self",(char *) "idx", NULL
51934 };
51935
51936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
51937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51938 if (!SWIG_IsOK(res1)) {
51939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51940 }
51941 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51942 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51943 if (!SWIG_IsOK(ecode2)) {
51944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51945 }
51946 arg2 = static_cast< size_t >(val2);
51947 {
51948 PyThreadState* __tstate = wxPyBeginAllowThreads();
51949 (arg1)->RemoveGrowableCol(arg2);
51950 wxPyEndAllowThreads(__tstate);
51951 if (PyErr_Occurred()) SWIG_fail;
51952 }
51953 resultobj = SWIG_Py_Void();
51954 return resultobj;
51955 fail:
51956 return NULL;
51957 }
51958
51959
51960 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51961 PyObject *resultobj = 0;
51962 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51963 int arg2 ;
51964 void *argp1 = 0 ;
51965 int res1 = 0 ;
51966 int val2 ;
51967 int ecode2 = 0 ;
51968 PyObject * obj0 = 0 ;
51969 PyObject * obj1 = 0 ;
51970 char * kwnames[] = {
51971 (char *) "self",(char *) "direction", NULL
51972 };
51973
51974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
51975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51976 if (!SWIG_IsOK(res1)) {
51977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51978 }
51979 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51980 ecode2 = SWIG_AsVal_int(obj1, &val2);
51981 if (!SWIG_IsOK(ecode2)) {
51982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
51983 }
51984 arg2 = static_cast< int >(val2);
51985 {
51986 PyThreadState* __tstate = wxPyBeginAllowThreads();
51987 (arg1)->SetFlexibleDirection(arg2);
51988 wxPyEndAllowThreads(__tstate);
51989 if (PyErr_Occurred()) SWIG_fail;
51990 }
51991 resultobj = SWIG_Py_Void();
51992 return resultobj;
51993 fail:
51994 return NULL;
51995 }
51996
51997
51998 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51999 PyObject *resultobj = 0;
52000 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52001 int result;
52002 void *argp1 = 0 ;
52003 int res1 = 0 ;
52004 PyObject *swig_obj[1] ;
52005
52006 if (!args) SWIG_fail;
52007 swig_obj[0] = args;
52008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52009 if (!SWIG_IsOK(res1)) {
52010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52011 }
52012 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52013 {
52014 PyThreadState* __tstate = wxPyBeginAllowThreads();
52015 result = (int)(arg1)->GetFlexibleDirection();
52016 wxPyEndAllowThreads(__tstate);
52017 if (PyErr_Occurred()) SWIG_fail;
52018 }
52019 resultobj = SWIG_From_int(static_cast< int >(result));
52020 return resultobj;
52021 fail:
52022 return NULL;
52023 }
52024
52025
52026 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52027 PyObject *resultobj = 0;
52028 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52029 wxFlexSizerGrowMode arg2 ;
52030 void *argp1 = 0 ;
52031 int res1 = 0 ;
52032 int val2 ;
52033 int ecode2 = 0 ;
52034 PyObject * obj0 = 0 ;
52035 PyObject * obj1 = 0 ;
52036 char * kwnames[] = {
52037 (char *) "self",(char *) "mode", NULL
52038 };
52039
52040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
52041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52042 if (!SWIG_IsOK(res1)) {
52043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52044 }
52045 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52046 ecode2 = SWIG_AsVal_int(obj1, &val2);
52047 if (!SWIG_IsOK(ecode2)) {
52048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
52049 }
52050 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
52051 {
52052 PyThreadState* __tstate = wxPyBeginAllowThreads();
52053 (arg1)->SetNonFlexibleGrowMode(arg2);
52054 wxPyEndAllowThreads(__tstate);
52055 if (PyErr_Occurred()) SWIG_fail;
52056 }
52057 resultobj = SWIG_Py_Void();
52058 return resultobj;
52059 fail:
52060 return NULL;
52061 }
52062
52063
52064 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52065 PyObject *resultobj = 0;
52066 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52067 wxFlexSizerGrowMode result;
52068 void *argp1 = 0 ;
52069 int res1 = 0 ;
52070 PyObject *swig_obj[1] ;
52071
52072 if (!args) SWIG_fail;
52073 swig_obj[0] = args;
52074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52075 if (!SWIG_IsOK(res1)) {
52076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52077 }
52078 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52079 {
52080 PyThreadState* __tstate = wxPyBeginAllowThreads();
52081 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
52082 wxPyEndAllowThreads(__tstate);
52083 if (PyErr_Occurred()) SWIG_fail;
52084 }
52085 resultobj = SWIG_From_int(static_cast< int >(result));
52086 return resultobj;
52087 fail:
52088 return NULL;
52089 }
52090
52091
52092 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52093 PyObject *resultobj = 0;
52094 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52095 wxArrayInt *result = 0 ;
52096 void *argp1 = 0 ;
52097 int res1 = 0 ;
52098 PyObject *swig_obj[1] ;
52099
52100 if (!args) SWIG_fail;
52101 swig_obj[0] = args;
52102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52103 if (!SWIG_IsOK(res1)) {
52104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52105 }
52106 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52107 {
52108 PyThreadState* __tstate = wxPyBeginAllowThreads();
52109 {
52110 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
52111 result = (wxArrayInt *) &_result_ref;
52112 }
52113 wxPyEndAllowThreads(__tstate);
52114 if (PyErr_Occurred()) SWIG_fail;
52115 }
52116 {
52117 resultobj = wxArrayInt2PyList_helper(*result);
52118 }
52119 return resultobj;
52120 fail:
52121 return NULL;
52122 }
52123
52124
52125 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52126 PyObject *resultobj = 0;
52127 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52128 wxArrayInt *result = 0 ;
52129 void *argp1 = 0 ;
52130 int res1 = 0 ;
52131 PyObject *swig_obj[1] ;
52132
52133 if (!args) SWIG_fail;
52134 swig_obj[0] = args;
52135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52136 if (!SWIG_IsOK(res1)) {
52137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52138 }
52139 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52140 {
52141 PyThreadState* __tstate = wxPyBeginAllowThreads();
52142 {
52143 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
52144 result = (wxArrayInt *) &_result_ref;
52145 }
52146 wxPyEndAllowThreads(__tstate);
52147 if (PyErr_Occurred()) SWIG_fail;
52148 }
52149 {
52150 resultobj = wxArrayInt2PyList_helper(*result);
52151 }
52152 return resultobj;
52153 fail:
52154 return NULL;
52155 }
52156
52157
52158 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52159 PyObject *obj;
52160 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52161 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
52162 return SWIG_Py_Void();
52163 }
52164
52165 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52166 return SWIG_Python_InitShadowInstance(args);
52167 }
52168
52169 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52170 PyObject *resultobj = 0;
52171 wxStdDialogButtonSizer *result = 0 ;
52172
52173 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
52174 {
52175 PyThreadState* __tstate = wxPyBeginAllowThreads();
52176 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
52177 wxPyEndAllowThreads(__tstate);
52178 if (PyErr_Occurred()) SWIG_fail;
52179 }
52180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
52181 return resultobj;
52182 fail:
52183 return NULL;
52184 }
52185
52186
52187 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52188 PyObject *resultobj = 0;
52189 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52190 wxButton *arg2 = (wxButton *) 0 ;
52191 void *argp1 = 0 ;
52192 int res1 = 0 ;
52193 void *argp2 = 0 ;
52194 int res2 = 0 ;
52195 PyObject * obj0 = 0 ;
52196 PyObject * obj1 = 0 ;
52197 char * kwnames[] = {
52198 (char *) "self",(char *) "button", NULL
52199 };
52200
52201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
52202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52203 if (!SWIG_IsOK(res1)) {
52204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52205 }
52206 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52207 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52208 if (!SWIG_IsOK(res2)) {
52209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
52210 }
52211 arg2 = reinterpret_cast< wxButton * >(argp2);
52212 {
52213 PyThreadState* __tstate = wxPyBeginAllowThreads();
52214 (arg1)->AddButton(arg2);
52215 wxPyEndAllowThreads(__tstate);
52216 if (PyErr_Occurred()) SWIG_fail;
52217 }
52218 resultobj = SWIG_Py_Void();
52219 return resultobj;
52220 fail:
52221 return NULL;
52222 }
52223
52224
52225 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52226 PyObject *resultobj = 0;
52227 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52228 void *argp1 = 0 ;
52229 int res1 = 0 ;
52230 PyObject *swig_obj[1] ;
52231
52232 if (!args) SWIG_fail;
52233 swig_obj[0] = args;
52234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52235 if (!SWIG_IsOK(res1)) {
52236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52237 }
52238 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52239 {
52240 PyThreadState* __tstate = wxPyBeginAllowThreads();
52241 (arg1)->Realize();
52242 wxPyEndAllowThreads(__tstate);
52243 if (PyErr_Occurred()) SWIG_fail;
52244 }
52245 resultobj = SWIG_Py_Void();
52246 return resultobj;
52247 fail:
52248 return NULL;
52249 }
52250
52251
52252 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52253 PyObject *resultobj = 0;
52254 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52255 wxButton *arg2 = (wxButton *) 0 ;
52256 void *argp1 = 0 ;
52257 int res1 = 0 ;
52258 void *argp2 = 0 ;
52259 int res2 = 0 ;
52260 PyObject * obj0 = 0 ;
52261 PyObject * obj1 = 0 ;
52262 char * kwnames[] = {
52263 (char *) "self",(char *) "button", NULL
52264 };
52265
52266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52268 if (!SWIG_IsOK(res1)) {
52269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52270 }
52271 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52272 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52273 if (!SWIG_IsOK(res2)) {
52274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52275 }
52276 arg2 = reinterpret_cast< wxButton * >(argp2);
52277 {
52278 PyThreadState* __tstate = wxPyBeginAllowThreads();
52279 (arg1)->SetAffirmativeButton(arg2);
52280 wxPyEndAllowThreads(__tstate);
52281 if (PyErr_Occurred()) SWIG_fail;
52282 }
52283 resultobj = SWIG_Py_Void();
52284 return resultobj;
52285 fail:
52286 return NULL;
52287 }
52288
52289
52290 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52291 PyObject *resultobj = 0;
52292 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52293 wxButton *arg2 = (wxButton *) 0 ;
52294 void *argp1 = 0 ;
52295 int res1 = 0 ;
52296 void *argp2 = 0 ;
52297 int res2 = 0 ;
52298 PyObject * obj0 = 0 ;
52299 PyObject * obj1 = 0 ;
52300 char * kwnames[] = {
52301 (char *) "self",(char *) "button", NULL
52302 };
52303
52304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52306 if (!SWIG_IsOK(res1)) {
52307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52308 }
52309 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52310 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52311 if (!SWIG_IsOK(res2)) {
52312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52313 }
52314 arg2 = reinterpret_cast< wxButton * >(argp2);
52315 {
52316 PyThreadState* __tstate = wxPyBeginAllowThreads();
52317 (arg1)->SetNegativeButton(arg2);
52318 wxPyEndAllowThreads(__tstate);
52319 if (PyErr_Occurred()) SWIG_fail;
52320 }
52321 resultobj = SWIG_Py_Void();
52322 return resultobj;
52323 fail:
52324 return NULL;
52325 }
52326
52327
52328 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52329 PyObject *resultobj = 0;
52330 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52331 wxButton *arg2 = (wxButton *) 0 ;
52332 void *argp1 = 0 ;
52333 int res1 = 0 ;
52334 void *argp2 = 0 ;
52335 int res2 = 0 ;
52336 PyObject * obj0 = 0 ;
52337 PyObject * obj1 = 0 ;
52338 char * kwnames[] = {
52339 (char *) "self",(char *) "button", NULL
52340 };
52341
52342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
52343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52344 if (!SWIG_IsOK(res1)) {
52345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52346 }
52347 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52348 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52349 if (!SWIG_IsOK(res2)) {
52350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
52351 }
52352 arg2 = reinterpret_cast< wxButton * >(argp2);
52353 {
52354 PyThreadState* __tstate = wxPyBeginAllowThreads();
52355 (arg1)->SetCancelButton(arg2);
52356 wxPyEndAllowThreads(__tstate);
52357 if (PyErr_Occurred()) SWIG_fail;
52358 }
52359 resultobj = SWIG_Py_Void();
52360 return resultobj;
52361 fail:
52362 return NULL;
52363 }
52364
52365
52366 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52367 PyObject *resultobj = 0;
52368 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52369 wxButton *result = 0 ;
52370 void *argp1 = 0 ;
52371 int res1 = 0 ;
52372 PyObject *swig_obj[1] ;
52373
52374 if (!args) SWIG_fail;
52375 swig_obj[0] = args;
52376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52377 if (!SWIG_IsOK(res1)) {
52378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52379 }
52380 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52381 {
52382 PyThreadState* __tstate = wxPyBeginAllowThreads();
52383 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
52384 wxPyEndAllowThreads(__tstate);
52385 if (PyErr_Occurred()) SWIG_fail;
52386 }
52387 {
52388 resultobj = wxPyMake_wxObject(result, (bool)0);
52389 }
52390 return resultobj;
52391 fail:
52392 return NULL;
52393 }
52394
52395
52396 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52397 PyObject *resultobj = 0;
52398 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52399 wxButton *result = 0 ;
52400 void *argp1 = 0 ;
52401 int res1 = 0 ;
52402 PyObject *swig_obj[1] ;
52403
52404 if (!args) SWIG_fail;
52405 swig_obj[0] = args;
52406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52407 if (!SWIG_IsOK(res1)) {
52408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52409 }
52410 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52411 {
52412 PyThreadState* __tstate = wxPyBeginAllowThreads();
52413 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
52414 wxPyEndAllowThreads(__tstate);
52415 if (PyErr_Occurred()) SWIG_fail;
52416 }
52417 {
52418 resultobj = wxPyMake_wxObject(result, (bool)0);
52419 }
52420 return resultobj;
52421 fail:
52422 return NULL;
52423 }
52424
52425
52426 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52427 PyObject *resultobj = 0;
52428 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52429 wxButton *result = 0 ;
52430 void *argp1 = 0 ;
52431 int res1 = 0 ;
52432 PyObject *swig_obj[1] ;
52433
52434 if (!args) SWIG_fail;
52435 swig_obj[0] = args;
52436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52437 if (!SWIG_IsOK(res1)) {
52438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52439 }
52440 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52441 {
52442 PyThreadState* __tstate = wxPyBeginAllowThreads();
52443 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
52444 wxPyEndAllowThreads(__tstate);
52445 if (PyErr_Occurred()) SWIG_fail;
52446 }
52447 {
52448 resultobj = wxPyMake_wxObject(result, (bool)0);
52449 }
52450 return resultobj;
52451 fail:
52452 return NULL;
52453 }
52454
52455
52456 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52457 PyObject *resultobj = 0;
52458 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52459 wxButton *result = 0 ;
52460 void *argp1 = 0 ;
52461 int res1 = 0 ;
52462 PyObject *swig_obj[1] ;
52463
52464 if (!args) SWIG_fail;
52465 swig_obj[0] = args;
52466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52467 if (!SWIG_IsOK(res1)) {
52468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52469 }
52470 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52471 {
52472 PyThreadState* __tstate = wxPyBeginAllowThreads();
52473 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
52474 wxPyEndAllowThreads(__tstate);
52475 if (PyErr_Occurred()) SWIG_fail;
52476 }
52477 {
52478 resultobj = wxPyMake_wxObject(result, (bool)0);
52479 }
52480 return resultobj;
52481 fail:
52482 return NULL;
52483 }
52484
52485
52486 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52487 PyObject *resultobj = 0;
52488 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52489 wxButton *result = 0 ;
52490 void *argp1 = 0 ;
52491 int res1 = 0 ;
52492 PyObject *swig_obj[1] ;
52493
52494 if (!args) SWIG_fail;
52495 swig_obj[0] = args;
52496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52497 if (!SWIG_IsOK(res1)) {
52498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52499 }
52500 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52501 {
52502 PyThreadState* __tstate = wxPyBeginAllowThreads();
52503 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
52504 wxPyEndAllowThreads(__tstate);
52505 if (PyErr_Occurred()) SWIG_fail;
52506 }
52507 {
52508 resultobj = wxPyMake_wxObject(result, (bool)0);
52509 }
52510 return resultobj;
52511 fail:
52512 return NULL;
52513 }
52514
52515
52516 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52517 PyObject *obj;
52518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52519 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
52520 return SWIG_Py_Void();
52521 }
52522
52523 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52524 return SWIG_Python_InitShadowInstance(args);
52525 }
52526
52527 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52528 PyObject *resultobj = 0;
52529 int arg1 = (int) 0 ;
52530 int arg2 = (int) 0 ;
52531 wxGBPosition *result = 0 ;
52532 int val1 ;
52533 int ecode1 = 0 ;
52534 int val2 ;
52535 int ecode2 = 0 ;
52536 PyObject * obj0 = 0 ;
52537 PyObject * obj1 = 0 ;
52538 char * kwnames[] = {
52539 (char *) "row",(char *) "col", NULL
52540 };
52541
52542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52543 if (obj0) {
52544 ecode1 = SWIG_AsVal_int(obj0, &val1);
52545 if (!SWIG_IsOK(ecode1)) {
52546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
52547 }
52548 arg1 = static_cast< int >(val1);
52549 }
52550 if (obj1) {
52551 ecode2 = SWIG_AsVal_int(obj1, &val2);
52552 if (!SWIG_IsOK(ecode2)) {
52553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
52554 }
52555 arg2 = static_cast< int >(val2);
52556 }
52557 {
52558 PyThreadState* __tstate = wxPyBeginAllowThreads();
52559 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
52560 wxPyEndAllowThreads(__tstate);
52561 if (PyErr_Occurred()) SWIG_fail;
52562 }
52563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
52564 return resultobj;
52565 fail:
52566 return NULL;
52567 }
52568
52569
52570 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52571 PyObject *resultobj = 0;
52572 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52573 void *argp1 = 0 ;
52574 int res1 = 0 ;
52575 PyObject *swig_obj[1] ;
52576
52577 if (!args) SWIG_fail;
52578 swig_obj[0] = args;
52579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
52580 if (!SWIG_IsOK(res1)) {
52581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52582 }
52583 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52584 {
52585 PyThreadState* __tstate = wxPyBeginAllowThreads();
52586 delete arg1;
52587
52588 wxPyEndAllowThreads(__tstate);
52589 if (PyErr_Occurred()) SWIG_fail;
52590 }
52591 resultobj = SWIG_Py_Void();
52592 return resultobj;
52593 fail:
52594 return NULL;
52595 }
52596
52597
52598 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52599 PyObject *resultobj = 0;
52600 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52601 int result;
52602 void *argp1 = 0 ;
52603 int res1 = 0 ;
52604 PyObject *swig_obj[1] ;
52605
52606 if (!args) SWIG_fail;
52607 swig_obj[0] = args;
52608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52609 if (!SWIG_IsOK(res1)) {
52610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52611 }
52612 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52613 {
52614 PyThreadState* __tstate = wxPyBeginAllowThreads();
52615 result = (int)((wxGBPosition const *)arg1)->GetRow();
52616 wxPyEndAllowThreads(__tstate);
52617 if (PyErr_Occurred()) SWIG_fail;
52618 }
52619 resultobj = SWIG_From_int(static_cast< int >(result));
52620 return resultobj;
52621 fail:
52622 return NULL;
52623 }
52624
52625
52626 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52627 PyObject *resultobj = 0;
52628 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52629 int result;
52630 void *argp1 = 0 ;
52631 int res1 = 0 ;
52632 PyObject *swig_obj[1] ;
52633
52634 if (!args) SWIG_fail;
52635 swig_obj[0] = args;
52636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52637 if (!SWIG_IsOK(res1)) {
52638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52639 }
52640 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52641 {
52642 PyThreadState* __tstate = wxPyBeginAllowThreads();
52643 result = (int)((wxGBPosition const *)arg1)->GetCol();
52644 wxPyEndAllowThreads(__tstate);
52645 if (PyErr_Occurred()) SWIG_fail;
52646 }
52647 resultobj = SWIG_From_int(static_cast< int >(result));
52648 return resultobj;
52649 fail:
52650 return NULL;
52651 }
52652
52653
52654 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52655 PyObject *resultobj = 0;
52656 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52657 int arg2 ;
52658 void *argp1 = 0 ;
52659 int res1 = 0 ;
52660 int val2 ;
52661 int ecode2 = 0 ;
52662 PyObject * obj0 = 0 ;
52663 PyObject * obj1 = 0 ;
52664 char * kwnames[] = {
52665 (char *) "self",(char *) "row", NULL
52666 };
52667
52668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
52669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52670 if (!SWIG_IsOK(res1)) {
52671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52672 }
52673 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52674 ecode2 = SWIG_AsVal_int(obj1, &val2);
52675 if (!SWIG_IsOK(ecode2)) {
52676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
52677 }
52678 arg2 = static_cast< int >(val2);
52679 {
52680 PyThreadState* __tstate = wxPyBeginAllowThreads();
52681 (arg1)->SetRow(arg2);
52682 wxPyEndAllowThreads(__tstate);
52683 if (PyErr_Occurred()) SWIG_fail;
52684 }
52685 resultobj = SWIG_Py_Void();
52686 return resultobj;
52687 fail:
52688 return NULL;
52689 }
52690
52691
52692 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52693 PyObject *resultobj = 0;
52694 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52695 int arg2 ;
52696 void *argp1 = 0 ;
52697 int res1 = 0 ;
52698 int val2 ;
52699 int ecode2 = 0 ;
52700 PyObject * obj0 = 0 ;
52701 PyObject * obj1 = 0 ;
52702 char * kwnames[] = {
52703 (char *) "self",(char *) "col", NULL
52704 };
52705
52706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
52707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52708 if (!SWIG_IsOK(res1)) {
52709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52710 }
52711 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52712 ecode2 = SWIG_AsVal_int(obj1, &val2);
52713 if (!SWIG_IsOK(ecode2)) {
52714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
52715 }
52716 arg2 = static_cast< int >(val2);
52717 {
52718 PyThreadState* __tstate = wxPyBeginAllowThreads();
52719 (arg1)->SetCol(arg2);
52720 wxPyEndAllowThreads(__tstate);
52721 if (PyErr_Occurred()) SWIG_fail;
52722 }
52723 resultobj = SWIG_Py_Void();
52724 return resultobj;
52725 fail:
52726 return NULL;
52727 }
52728
52729
52730 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52731 PyObject *resultobj = 0;
52732 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52733 PyObject *arg2 = (PyObject *) 0 ;
52734 bool result;
52735 void *argp1 = 0 ;
52736 int res1 = 0 ;
52737 PyObject * obj0 = 0 ;
52738 PyObject * obj1 = 0 ;
52739 char * kwnames[] = {
52740 (char *) "self",(char *) "other", NULL
52741 };
52742
52743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
52744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52745 if (!SWIG_IsOK(res1)) {
52746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52747 }
52748 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52749 arg2 = obj1;
52750 {
52751 result = (bool)wxGBPosition___eq__(arg1,arg2);
52752 if (PyErr_Occurred()) SWIG_fail;
52753 }
52754 {
52755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52756 }
52757 return resultobj;
52758 fail:
52759 return NULL;
52760 }
52761
52762
52763 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52764 PyObject *resultobj = 0;
52765 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52766 PyObject *arg2 = (PyObject *) 0 ;
52767 bool result;
52768 void *argp1 = 0 ;
52769 int res1 = 0 ;
52770 PyObject * obj0 = 0 ;
52771 PyObject * obj1 = 0 ;
52772 char * kwnames[] = {
52773 (char *) "self",(char *) "other", NULL
52774 };
52775
52776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
52777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52778 if (!SWIG_IsOK(res1)) {
52779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52780 }
52781 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52782 arg2 = obj1;
52783 {
52784 result = (bool)wxGBPosition___ne__(arg1,arg2);
52785 if (PyErr_Occurred()) SWIG_fail;
52786 }
52787 {
52788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52789 }
52790 return resultobj;
52791 fail:
52792 return NULL;
52793 }
52794
52795
52796 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52797 PyObject *resultobj = 0;
52798 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52799 int arg2 = (int) 0 ;
52800 int arg3 = (int) 0 ;
52801 void *argp1 = 0 ;
52802 int res1 = 0 ;
52803 int val2 ;
52804 int ecode2 = 0 ;
52805 int val3 ;
52806 int ecode3 = 0 ;
52807 PyObject * obj0 = 0 ;
52808 PyObject * obj1 = 0 ;
52809 PyObject * obj2 = 0 ;
52810 char * kwnames[] = {
52811 (char *) "self",(char *) "row",(char *) "col", NULL
52812 };
52813
52814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52816 if (!SWIG_IsOK(res1)) {
52817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52818 }
52819 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52820 if (obj1) {
52821 ecode2 = SWIG_AsVal_int(obj1, &val2);
52822 if (!SWIG_IsOK(ecode2)) {
52823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
52824 }
52825 arg2 = static_cast< int >(val2);
52826 }
52827 if (obj2) {
52828 ecode3 = SWIG_AsVal_int(obj2, &val3);
52829 if (!SWIG_IsOK(ecode3)) {
52830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
52831 }
52832 arg3 = static_cast< int >(val3);
52833 }
52834 {
52835 PyThreadState* __tstate = wxPyBeginAllowThreads();
52836 wxGBPosition_Set(arg1,arg2,arg3);
52837 wxPyEndAllowThreads(__tstate);
52838 if (PyErr_Occurred()) SWIG_fail;
52839 }
52840 resultobj = SWIG_Py_Void();
52841 return resultobj;
52842 fail:
52843 return NULL;
52844 }
52845
52846
52847 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52848 PyObject *resultobj = 0;
52849 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52850 PyObject *result = 0 ;
52851 void *argp1 = 0 ;
52852 int res1 = 0 ;
52853 PyObject *swig_obj[1] ;
52854
52855 if (!args) SWIG_fail;
52856 swig_obj[0] = args;
52857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52858 if (!SWIG_IsOK(res1)) {
52859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52860 }
52861 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52862 {
52863 PyThreadState* __tstate = wxPyBeginAllowThreads();
52864 result = (PyObject *)wxGBPosition_Get(arg1);
52865 wxPyEndAllowThreads(__tstate);
52866 if (PyErr_Occurred()) SWIG_fail;
52867 }
52868 resultobj = result;
52869 return resultobj;
52870 fail:
52871 return NULL;
52872 }
52873
52874
52875 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52876 PyObject *obj;
52877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52878 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
52879 return SWIG_Py_Void();
52880 }
52881
52882 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52883 return SWIG_Python_InitShadowInstance(args);
52884 }
52885
52886 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52887 PyObject *resultobj = 0;
52888 int arg1 = (int) 1 ;
52889 int arg2 = (int) 1 ;
52890 wxGBSpan *result = 0 ;
52891 int val1 ;
52892 int ecode1 = 0 ;
52893 int val2 ;
52894 int ecode2 = 0 ;
52895 PyObject * obj0 = 0 ;
52896 PyObject * obj1 = 0 ;
52897 char * kwnames[] = {
52898 (char *) "rowspan",(char *) "colspan", NULL
52899 };
52900
52901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
52902 if (obj0) {
52903 ecode1 = SWIG_AsVal_int(obj0, &val1);
52904 if (!SWIG_IsOK(ecode1)) {
52905 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
52906 }
52907 arg1 = static_cast< int >(val1);
52908 }
52909 if (obj1) {
52910 ecode2 = SWIG_AsVal_int(obj1, &val2);
52911 if (!SWIG_IsOK(ecode2)) {
52912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
52913 }
52914 arg2 = static_cast< int >(val2);
52915 }
52916 {
52917 PyThreadState* __tstate = wxPyBeginAllowThreads();
52918 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
52919 wxPyEndAllowThreads(__tstate);
52920 if (PyErr_Occurred()) SWIG_fail;
52921 }
52922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
52923 return resultobj;
52924 fail:
52925 return NULL;
52926 }
52927
52928
52929 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52930 PyObject *resultobj = 0;
52931 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52932 void *argp1 = 0 ;
52933 int res1 = 0 ;
52934 PyObject *swig_obj[1] ;
52935
52936 if (!args) SWIG_fail;
52937 swig_obj[0] = args;
52938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
52939 if (!SWIG_IsOK(res1)) {
52940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52941 }
52942 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52943 {
52944 PyThreadState* __tstate = wxPyBeginAllowThreads();
52945 delete arg1;
52946
52947 wxPyEndAllowThreads(__tstate);
52948 if (PyErr_Occurred()) SWIG_fail;
52949 }
52950 resultobj = SWIG_Py_Void();
52951 return resultobj;
52952 fail:
52953 return NULL;
52954 }
52955
52956
52957 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52958 PyObject *resultobj = 0;
52959 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52960 int result;
52961 void *argp1 = 0 ;
52962 int res1 = 0 ;
52963 PyObject *swig_obj[1] ;
52964
52965 if (!args) SWIG_fail;
52966 swig_obj[0] = args;
52967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52968 if (!SWIG_IsOK(res1)) {
52969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
52970 }
52971 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52972 {
52973 PyThreadState* __tstate = wxPyBeginAllowThreads();
52974 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
52975 wxPyEndAllowThreads(__tstate);
52976 if (PyErr_Occurred()) SWIG_fail;
52977 }
52978 resultobj = SWIG_From_int(static_cast< int >(result));
52979 return resultobj;
52980 fail:
52981 return NULL;
52982 }
52983
52984
52985 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52986 PyObject *resultobj = 0;
52987 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52988 int result;
52989 void *argp1 = 0 ;
52990 int res1 = 0 ;
52991 PyObject *swig_obj[1] ;
52992
52993 if (!args) SWIG_fail;
52994 swig_obj[0] = args;
52995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52996 if (!SWIG_IsOK(res1)) {
52997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
52998 }
52999 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53000 {
53001 PyThreadState* __tstate = wxPyBeginAllowThreads();
53002 result = (int)((wxGBSpan const *)arg1)->GetColspan();
53003 wxPyEndAllowThreads(__tstate);
53004 if (PyErr_Occurred()) SWIG_fail;
53005 }
53006 resultobj = SWIG_From_int(static_cast< int >(result));
53007 return resultobj;
53008 fail:
53009 return NULL;
53010 }
53011
53012
53013 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53014 PyObject *resultobj = 0;
53015 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53016 int arg2 ;
53017 void *argp1 = 0 ;
53018 int res1 = 0 ;
53019 int val2 ;
53020 int ecode2 = 0 ;
53021 PyObject * obj0 = 0 ;
53022 PyObject * obj1 = 0 ;
53023 char * kwnames[] = {
53024 (char *) "self",(char *) "rowspan", NULL
53025 };
53026
53027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
53028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53029 if (!SWIG_IsOK(res1)) {
53030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53031 }
53032 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53033 ecode2 = SWIG_AsVal_int(obj1, &val2);
53034 if (!SWIG_IsOK(ecode2)) {
53035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
53036 }
53037 arg2 = static_cast< int >(val2);
53038 {
53039 PyThreadState* __tstate = wxPyBeginAllowThreads();
53040 (arg1)->SetRowspan(arg2);
53041 wxPyEndAllowThreads(__tstate);
53042 if (PyErr_Occurred()) SWIG_fail;
53043 }
53044 resultobj = SWIG_Py_Void();
53045 return resultobj;
53046 fail:
53047 return NULL;
53048 }
53049
53050
53051 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53052 PyObject *resultobj = 0;
53053 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53054 int arg2 ;
53055 void *argp1 = 0 ;
53056 int res1 = 0 ;
53057 int val2 ;
53058 int ecode2 = 0 ;
53059 PyObject * obj0 = 0 ;
53060 PyObject * obj1 = 0 ;
53061 char * kwnames[] = {
53062 (char *) "self",(char *) "colspan", NULL
53063 };
53064
53065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
53066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53067 if (!SWIG_IsOK(res1)) {
53068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53069 }
53070 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53071 ecode2 = SWIG_AsVal_int(obj1, &val2);
53072 if (!SWIG_IsOK(ecode2)) {
53073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
53074 }
53075 arg2 = static_cast< int >(val2);
53076 {
53077 PyThreadState* __tstate = wxPyBeginAllowThreads();
53078 (arg1)->SetColspan(arg2);
53079 wxPyEndAllowThreads(__tstate);
53080 if (PyErr_Occurred()) SWIG_fail;
53081 }
53082 resultobj = SWIG_Py_Void();
53083 return resultobj;
53084 fail:
53085 return NULL;
53086 }
53087
53088
53089 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53090 PyObject *resultobj = 0;
53091 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53092 PyObject *arg2 = (PyObject *) 0 ;
53093 bool result;
53094 void *argp1 = 0 ;
53095 int res1 = 0 ;
53096 PyObject * obj0 = 0 ;
53097 PyObject * obj1 = 0 ;
53098 char * kwnames[] = {
53099 (char *) "self",(char *) "other", NULL
53100 };
53101
53102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
53103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53104 if (!SWIG_IsOK(res1)) {
53105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53106 }
53107 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53108 arg2 = obj1;
53109 {
53110 result = (bool)wxGBSpan___eq__(arg1,arg2);
53111 if (PyErr_Occurred()) SWIG_fail;
53112 }
53113 {
53114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53115 }
53116 return resultobj;
53117 fail:
53118 return NULL;
53119 }
53120
53121
53122 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53123 PyObject *resultobj = 0;
53124 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53125 PyObject *arg2 = (PyObject *) 0 ;
53126 bool result;
53127 void *argp1 = 0 ;
53128 int res1 = 0 ;
53129 PyObject * obj0 = 0 ;
53130 PyObject * obj1 = 0 ;
53131 char * kwnames[] = {
53132 (char *) "self",(char *) "other", NULL
53133 };
53134
53135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
53136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53137 if (!SWIG_IsOK(res1)) {
53138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53139 }
53140 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53141 arg2 = obj1;
53142 {
53143 result = (bool)wxGBSpan___ne__(arg1,arg2);
53144 if (PyErr_Occurred()) SWIG_fail;
53145 }
53146 {
53147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53148 }
53149 return resultobj;
53150 fail:
53151 return NULL;
53152 }
53153
53154
53155 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53156 PyObject *resultobj = 0;
53157 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53158 int arg2 = (int) 1 ;
53159 int arg3 = (int) 1 ;
53160 void *argp1 = 0 ;
53161 int res1 = 0 ;
53162 int val2 ;
53163 int ecode2 = 0 ;
53164 int val3 ;
53165 int ecode3 = 0 ;
53166 PyObject * obj0 = 0 ;
53167 PyObject * obj1 = 0 ;
53168 PyObject * obj2 = 0 ;
53169 char * kwnames[] = {
53170 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
53171 };
53172
53173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53175 if (!SWIG_IsOK(res1)) {
53176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53177 }
53178 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53179 if (obj1) {
53180 ecode2 = SWIG_AsVal_int(obj1, &val2);
53181 if (!SWIG_IsOK(ecode2)) {
53182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
53183 }
53184 arg2 = static_cast< int >(val2);
53185 }
53186 if (obj2) {
53187 ecode3 = SWIG_AsVal_int(obj2, &val3);
53188 if (!SWIG_IsOK(ecode3)) {
53189 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
53190 }
53191 arg3 = static_cast< int >(val3);
53192 }
53193 {
53194 PyThreadState* __tstate = wxPyBeginAllowThreads();
53195 wxGBSpan_Set(arg1,arg2,arg3);
53196 wxPyEndAllowThreads(__tstate);
53197 if (PyErr_Occurred()) SWIG_fail;
53198 }
53199 resultobj = SWIG_Py_Void();
53200 return resultobj;
53201 fail:
53202 return NULL;
53203 }
53204
53205
53206 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53207 PyObject *resultobj = 0;
53208 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53209 PyObject *result = 0 ;
53210 void *argp1 = 0 ;
53211 int res1 = 0 ;
53212 PyObject *swig_obj[1] ;
53213
53214 if (!args) SWIG_fail;
53215 swig_obj[0] = args;
53216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53217 if (!SWIG_IsOK(res1)) {
53218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53219 }
53220 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53221 {
53222 PyThreadState* __tstate = wxPyBeginAllowThreads();
53223 result = (PyObject *)wxGBSpan_Get(arg1);
53224 wxPyEndAllowThreads(__tstate);
53225 if (PyErr_Occurred()) SWIG_fail;
53226 }
53227 resultobj = result;
53228 return resultobj;
53229 fail:
53230 return NULL;
53231 }
53232
53233
53234 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53235 PyObject *obj;
53236 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53237 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
53238 return SWIG_Py_Void();
53239 }
53240
53241 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53242 return SWIG_Python_InitShadowInstance(args);
53243 }
53244
53245 SWIGINTERN int DefaultSpan_set(PyObject *) {
53246 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
53247 return 1;
53248 }
53249
53250
53251 SWIGINTERN PyObject *DefaultSpan_get(void) {
53252 PyObject *pyobj = 0;
53253
53254 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
53255 return pyobj;
53256 }
53257
53258
53259 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53260 PyObject *resultobj = 0;
53261 wxGBSizerItem *result = 0 ;
53262
53263 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
53264 {
53265 PyThreadState* __tstate = wxPyBeginAllowThreads();
53266 result = (wxGBSizerItem *)new wxGBSizerItem();
53267 wxPyEndAllowThreads(__tstate);
53268 if (PyErr_Occurred()) SWIG_fail;
53269 }
53270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
53271 return resultobj;
53272 fail:
53273 return NULL;
53274 }
53275
53276
53277 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53278 PyObject *resultobj = 0;
53279 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53280 void *argp1 = 0 ;
53281 int res1 = 0 ;
53282 PyObject *swig_obj[1] ;
53283
53284 if (!args) SWIG_fail;
53285 swig_obj[0] = args;
53286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53287 if (!SWIG_IsOK(res1)) {
53288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53289 }
53290 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53291 {
53292 PyThreadState* __tstate = wxPyBeginAllowThreads();
53293 delete arg1;
53294
53295 wxPyEndAllowThreads(__tstate);
53296 if (PyErr_Occurred()) SWIG_fail;
53297 }
53298 resultobj = SWIG_Py_Void();
53299 return resultobj;
53300 fail:
53301 return NULL;
53302 }
53303
53304
53305 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53306 PyObject *resultobj = 0;
53307 wxWindow *arg1 = (wxWindow *) 0 ;
53308 wxGBPosition *arg2 = 0 ;
53309 wxGBSpan *arg3 = 0 ;
53310 int arg4 ;
53311 int arg5 ;
53312 PyObject *arg6 = (PyObject *) NULL ;
53313 wxGBSizerItem *result = 0 ;
53314 void *argp1 = 0 ;
53315 int res1 = 0 ;
53316 wxGBPosition temp2 ;
53317 wxGBSpan temp3 ;
53318 int val4 ;
53319 int ecode4 = 0 ;
53320 int val5 ;
53321 int ecode5 = 0 ;
53322 PyObject * obj0 = 0 ;
53323 PyObject * obj1 = 0 ;
53324 PyObject * obj2 = 0 ;
53325 PyObject * obj3 = 0 ;
53326 PyObject * obj4 = 0 ;
53327 PyObject * obj5 = 0 ;
53328 char * kwnames[] = {
53329 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53330 };
53331
53332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
53334 if (!SWIG_IsOK(res1)) {
53335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
53336 }
53337 arg1 = reinterpret_cast< wxWindow * >(argp1);
53338 {
53339 arg2 = &temp2;
53340 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53341 }
53342 {
53343 arg3 = &temp3;
53344 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53345 }
53346 ecode4 = SWIG_AsVal_int(obj3, &val4);
53347 if (!SWIG_IsOK(ecode4)) {
53348 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
53349 }
53350 arg4 = static_cast< int >(val4);
53351 ecode5 = SWIG_AsVal_int(obj4, &val5);
53352 if (!SWIG_IsOK(ecode5)) {
53353 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
53354 }
53355 arg5 = static_cast< int >(val5);
53356 if (obj5) {
53357 arg6 = obj5;
53358 }
53359 {
53360 PyThreadState* __tstate = wxPyBeginAllowThreads();
53361 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53362 wxPyEndAllowThreads(__tstate);
53363 if (PyErr_Occurred()) SWIG_fail;
53364 }
53365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53366 return resultobj;
53367 fail:
53368 return NULL;
53369 }
53370
53371
53372 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53373 PyObject *resultobj = 0;
53374 wxSizer *arg1 = (wxSizer *) 0 ;
53375 wxGBPosition *arg2 = 0 ;
53376 wxGBSpan *arg3 = 0 ;
53377 int arg4 ;
53378 int arg5 ;
53379 PyObject *arg6 = (PyObject *) NULL ;
53380 wxGBSizerItem *result = 0 ;
53381 int res1 = 0 ;
53382 wxGBPosition temp2 ;
53383 wxGBSpan temp3 ;
53384 int val4 ;
53385 int ecode4 = 0 ;
53386 int val5 ;
53387 int ecode5 = 0 ;
53388 PyObject * obj0 = 0 ;
53389 PyObject * obj1 = 0 ;
53390 PyObject * obj2 = 0 ;
53391 PyObject * obj3 = 0 ;
53392 PyObject * obj4 = 0 ;
53393 PyObject * obj5 = 0 ;
53394 char * kwnames[] = {
53395 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53396 };
53397
53398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53399 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
53400 if (!SWIG_IsOK(res1)) {
53401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
53402 }
53403 {
53404 arg2 = &temp2;
53405 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53406 }
53407 {
53408 arg3 = &temp3;
53409 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53410 }
53411 ecode4 = SWIG_AsVal_int(obj3, &val4);
53412 if (!SWIG_IsOK(ecode4)) {
53413 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
53414 }
53415 arg4 = static_cast< int >(val4);
53416 ecode5 = SWIG_AsVal_int(obj4, &val5);
53417 if (!SWIG_IsOK(ecode5)) {
53418 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
53419 }
53420 arg5 = static_cast< int >(val5);
53421 if (obj5) {
53422 arg6 = obj5;
53423 }
53424 {
53425 PyThreadState* __tstate = wxPyBeginAllowThreads();
53426 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53427 wxPyEndAllowThreads(__tstate);
53428 if (PyErr_Occurred()) SWIG_fail;
53429 }
53430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53431 return resultobj;
53432 fail:
53433 return NULL;
53434 }
53435
53436
53437 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53438 PyObject *resultobj = 0;
53439 int arg1 ;
53440 int arg2 ;
53441 wxGBPosition *arg3 = 0 ;
53442 wxGBSpan *arg4 = 0 ;
53443 int arg5 ;
53444 int arg6 ;
53445 PyObject *arg7 = (PyObject *) NULL ;
53446 wxGBSizerItem *result = 0 ;
53447 int val1 ;
53448 int ecode1 = 0 ;
53449 int val2 ;
53450 int ecode2 = 0 ;
53451 wxGBPosition temp3 ;
53452 wxGBSpan temp4 ;
53453 int val5 ;
53454 int ecode5 = 0 ;
53455 int val6 ;
53456 int ecode6 = 0 ;
53457 PyObject * obj0 = 0 ;
53458 PyObject * obj1 = 0 ;
53459 PyObject * obj2 = 0 ;
53460 PyObject * obj3 = 0 ;
53461 PyObject * obj4 = 0 ;
53462 PyObject * obj5 = 0 ;
53463 PyObject * obj6 = 0 ;
53464 char * kwnames[] = {
53465 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53466 };
53467
53468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53469 ecode1 = SWIG_AsVal_int(obj0, &val1);
53470 if (!SWIG_IsOK(ecode1)) {
53471 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
53472 }
53473 arg1 = static_cast< int >(val1);
53474 ecode2 = SWIG_AsVal_int(obj1, &val2);
53475 if (!SWIG_IsOK(ecode2)) {
53476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
53477 }
53478 arg2 = static_cast< int >(val2);
53479 {
53480 arg3 = &temp3;
53481 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53482 }
53483 {
53484 arg4 = &temp4;
53485 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53486 }
53487 ecode5 = SWIG_AsVal_int(obj4, &val5);
53488 if (!SWIG_IsOK(ecode5)) {
53489 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
53490 }
53491 arg5 = static_cast< int >(val5);
53492 ecode6 = SWIG_AsVal_int(obj5, &val6);
53493 if (!SWIG_IsOK(ecode6)) {
53494 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
53495 }
53496 arg6 = static_cast< int >(val6);
53497 if (obj6) {
53498 arg7 = obj6;
53499 }
53500 {
53501 PyThreadState* __tstate = wxPyBeginAllowThreads();
53502 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53503 wxPyEndAllowThreads(__tstate);
53504 if (PyErr_Occurred()) SWIG_fail;
53505 }
53506 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53507 return resultobj;
53508 fail:
53509 return NULL;
53510 }
53511
53512
53513 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53514 PyObject *resultobj = 0;
53515 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53516 wxGBPosition result;
53517 void *argp1 = 0 ;
53518 int res1 = 0 ;
53519 PyObject *swig_obj[1] ;
53520
53521 if (!args) SWIG_fail;
53522 swig_obj[0] = args;
53523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53524 if (!SWIG_IsOK(res1)) {
53525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53526 }
53527 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53528 {
53529 PyThreadState* __tstate = wxPyBeginAllowThreads();
53530 result = ((wxGBSizerItem const *)arg1)->GetPos();
53531 wxPyEndAllowThreads(__tstate);
53532 if (PyErr_Occurred()) SWIG_fail;
53533 }
53534 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53535 return resultobj;
53536 fail:
53537 return NULL;
53538 }
53539
53540
53541 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53542 PyObject *resultobj = 0;
53543 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53544 wxGBSpan result;
53545 void *argp1 = 0 ;
53546 int res1 = 0 ;
53547 PyObject *swig_obj[1] ;
53548
53549 if (!args) SWIG_fail;
53550 swig_obj[0] = args;
53551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53552 if (!SWIG_IsOK(res1)) {
53553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53554 }
53555 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53556 {
53557 PyThreadState* __tstate = wxPyBeginAllowThreads();
53558 result = ((wxGBSizerItem const *)arg1)->GetSpan();
53559 wxPyEndAllowThreads(__tstate);
53560 if (PyErr_Occurred()) SWIG_fail;
53561 }
53562 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
53563 return resultobj;
53564 fail:
53565 return NULL;
53566 }
53567
53568
53569 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53570 PyObject *resultobj = 0;
53571 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53572 wxGBPosition *arg2 = 0 ;
53573 bool result;
53574 void *argp1 = 0 ;
53575 int res1 = 0 ;
53576 wxGBPosition temp2 ;
53577 PyObject * obj0 = 0 ;
53578 PyObject * obj1 = 0 ;
53579 char * kwnames[] = {
53580 (char *) "self",(char *) "pos", NULL
53581 };
53582
53583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
53584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53585 if (!SWIG_IsOK(res1)) {
53586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53587 }
53588 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53589 {
53590 arg2 = &temp2;
53591 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53592 }
53593 {
53594 PyThreadState* __tstate = wxPyBeginAllowThreads();
53595 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
53596 wxPyEndAllowThreads(__tstate);
53597 if (PyErr_Occurred()) SWIG_fail;
53598 }
53599 {
53600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53601 }
53602 return resultobj;
53603 fail:
53604 return NULL;
53605 }
53606
53607
53608 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53609 PyObject *resultobj = 0;
53610 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53611 wxGBSpan *arg2 = 0 ;
53612 bool result;
53613 void *argp1 = 0 ;
53614 int res1 = 0 ;
53615 wxGBSpan temp2 ;
53616 PyObject * obj0 = 0 ;
53617 PyObject * obj1 = 0 ;
53618 char * kwnames[] = {
53619 (char *) "self",(char *) "span", NULL
53620 };
53621
53622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53624 if (!SWIG_IsOK(res1)) {
53625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53626 }
53627 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53628 {
53629 arg2 = &temp2;
53630 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
53631 }
53632 {
53633 PyThreadState* __tstate = wxPyBeginAllowThreads();
53634 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
53635 wxPyEndAllowThreads(__tstate);
53636 if (PyErr_Occurred()) SWIG_fail;
53637 }
53638 {
53639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53640 }
53641 return resultobj;
53642 fail:
53643 return NULL;
53644 }
53645
53646
53647 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53648 PyObject *resultobj = 0;
53649 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53650 wxGBSizerItem *arg2 = 0 ;
53651 bool result;
53652 void *argp1 = 0 ;
53653 int res1 = 0 ;
53654 void *argp2 = 0 ;
53655 int res2 = 0 ;
53656 PyObject * obj0 = 0 ;
53657 PyObject * obj1 = 0 ;
53658 char * kwnames[] = {
53659 (char *) "self",(char *) "other", NULL
53660 };
53661
53662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
53663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53664 if (!SWIG_IsOK(res1)) {
53665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53666 }
53667 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53668 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
53669 if (!SWIG_IsOK(res2)) {
53670 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53671 }
53672 if (!argp2) {
53673 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53674 }
53675 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
53676 {
53677 PyThreadState* __tstate = wxPyBeginAllowThreads();
53678 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
53679 wxPyEndAllowThreads(__tstate);
53680 if (PyErr_Occurred()) SWIG_fail;
53681 }
53682 {
53683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53684 }
53685 return resultobj;
53686 fail:
53687 return NULL;
53688 }
53689
53690
53691 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53692 PyObject *resultobj = 0;
53693 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53694 wxGBPosition *arg2 = 0 ;
53695 wxGBSpan *arg3 = 0 ;
53696 bool result;
53697 void *argp1 = 0 ;
53698 int res1 = 0 ;
53699 wxGBPosition temp2 ;
53700 wxGBSpan temp3 ;
53701 PyObject * obj0 = 0 ;
53702 PyObject * obj1 = 0 ;
53703 PyObject * obj2 = 0 ;
53704 char * kwnames[] = {
53705 (char *) "self",(char *) "pos",(char *) "span", NULL
53706 };
53707
53708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53710 if (!SWIG_IsOK(res1)) {
53711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53712 }
53713 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53714 {
53715 arg2 = &temp2;
53716 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53717 }
53718 {
53719 arg3 = &temp3;
53720 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53721 }
53722 {
53723 PyThreadState* __tstate = wxPyBeginAllowThreads();
53724 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
53725 wxPyEndAllowThreads(__tstate);
53726 if (PyErr_Occurred()) SWIG_fail;
53727 }
53728 {
53729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53730 }
53731 return resultobj;
53732 fail:
53733 return NULL;
53734 }
53735
53736
53737 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53738 PyObject *resultobj = 0;
53739 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53740 wxGBPosition result;
53741 void *argp1 = 0 ;
53742 int res1 = 0 ;
53743 PyObject *swig_obj[1] ;
53744
53745 if (!args) SWIG_fail;
53746 swig_obj[0] = args;
53747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53748 if (!SWIG_IsOK(res1)) {
53749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53750 }
53751 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53752 {
53753 PyThreadState* __tstate = wxPyBeginAllowThreads();
53754 result = wxGBSizerItem_GetEndPos(arg1);
53755 wxPyEndAllowThreads(__tstate);
53756 if (PyErr_Occurred()) SWIG_fail;
53757 }
53758 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53759 return resultobj;
53760 fail:
53761 return NULL;
53762 }
53763
53764
53765 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53766 PyObject *resultobj = 0;
53767 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53768 wxGridBagSizer *result = 0 ;
53769 void *argp1 = 0 ;
53770 int res1 = 0 ;
53771 PyObject *swig_obj[1] ;
53772
53773 if (!args) SWIG_fail;
53774 swig_obj[0] = args;
53775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53776 if (!SWIG_IsOK(res1)) {
53777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53778 }
53779 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53780 {
53781 PyThreadState* __tstate = wxPyBeginAllowThreads();
53782 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
53783 wxPyEndAllowThreads(__tstate);
53784 if (PyErr_Occurred()) SWIG_fail;
53785 }
53786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53787 return resultobj;
53788 fail:
53789 return NULL;
53790 }
53791
53792
53793 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53794 PyObject *resultobj = 0;
53795 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53796 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
53797 void *argp1 = 0 ;
53798 int res1 = 0 ;
53799 void *argp2 = 0 ;
53800 int res2 = 0 ;
53801 PyObject * obj0 = 0 ;
53802 PyObject * obj1 = 0 ;
53803 char * kwnames[] = {
53804 (char *) "self",(char *) "sizer", NULL
53805 };
53806
53807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53809 if (!SWIG_IsOK(res1)) {
53810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53811 }
53812 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53813 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53814 if (!SWIG_IsOK(res2)) {
53815 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
53816 }
53817 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
53818 {
53819 PyThreadState* __tstate = wxPyBeginAllowThreads();
53820 (arg1)->SetGBSizer(arg2);
53821 wxPyEndAllowThreads(__tstate);
53822 if (PyErr_Occurred()) SWIG_fail;
53823 }
53824 resultobj = SWIG_Py_Void();
53825 return resultobj;
53826 fail:
53827 return NULL;
53828 }
53829
53830
53831 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53832 PyObject *obj;
53833 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53834 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
53835 return SWIG_Py_Void();
53836 }
53837
53838 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53839 return SWIG_Python_InitShadowInstance(args);
53840 }
53841
53842 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53843 PyObject *resultobj = 0;
53844 int arg1 = (int) 0 ;
53845 int arg2 = (int) 0 ;
53846 wxGridBagSizer *result = 0 ;
53847 int val1 ;
53848 int ecode1 = 0 ;
53849 int val2 ;
53850 int ecode2 = 0 ;
53851 PyObject * obj0 = 0 ;
53852 PyObject * obj1 = 0 ;
53853 char * kwnames[] = {
53854 (char *) "vgap",(char *) "hgap", NULL
53855 };
53856
53857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53858 if (obj0) {
53859 ecode1 = SWIG_AsVal_int(obj0, &val1);
53860 if (!SWIG_IsOK(ecode1)) {
53861 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
53862 }
53863 arg1 = static_cast< int >(val1);
53864 }
53865 if (obj1) {
53866 ecode2 = SWIG_AsVal_int(obj1, &val2);
53867 if (!SWIG_IsOK(ecode2)) {
53868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
53869 }
53870 arg2 = static_cast< int >(val2);
53871 }
53872 {
53873 PyThreadState* __tstate = wxPyBeginAllowThreads();
53874 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
53875 wxPyEndAllowThreads(__tstate);
53876 if (PyErr_Occurred()) SWIG_fail;
53877 }
53878 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
53879 return resultobj;
53880 fail:
53881 return NULL;
53882 }
53883
53884
53885 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53886 PyObject *resultobj = 0;
53887 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53888 PyObject *arg2 = (PyObject *) 0 ;
53889 wxGBPosition *arg3 = 0 ;
53890 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
53891 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
53892 int arg5 = (int) 0 ;
53893 int arg6 = (int) 0 ;
53894 PyObject *arg7 = (PyObject *) NULL ;
53895 wxGBSizerItem *result = 0 ;
53896 void *argp1 = 0 ;
53897 int res1 = 0 ;
53898 wxGBPosition temp3 ;
53899 wxGBSpan temp4 ;
53900 int val5 ;
53901 int ecode5 = 0 ;
53902 int val6 ;
53903 int ecode6 = 0 ;
53904 PyObject * obj0 = 0 ;
53905 PyObject * obj1 = 0 ;
53906 PyObject * obj2 = 0 ;
53907 PyObject * obj3 = 0 ;
53908 PyObject * obj4 = 0 ;
53909 PyObject * obj5 = 0 ;
53910 PyObject * obj6 = 0 ;
53911 char * kwnames[] = {
53912 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53913 };
53914
53915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53917 if (!SWIG_IsOK(res1)) {
53918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53919 }
53920 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53921 arg2 = obj1;
53922 {
53923 arg3 = &temp3;
53924 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53925 }
53926 if (obj3) {
53927 {
53928 arg4 = &temp4;
53929 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53930 }
53931 }
53932 if (obj4) {
53933 ecode5 = SWIG_AsVal_int(obj4, &val5);
53934 if (!SWIG_IsOK(ecode5)) {
53935 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
53936 }
53937 arg5 = static_cast< int >(val5);
53938 }
53939 if (obj5) {
53940 ecode6 = SWIG_AsVal_int(obj5, &val6);
53941 if (!SWIG_IsOK(ecode6)) {
53942 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
53943 }
53944 arg6 = static_cast< int >(val6);
53945 }
53946 if (obj6) {
53947 arg7 = obj6;
53948 }
53949 {
53950 PyThreadState* __tstate = wxPyBeginAllowThreads();
53951 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53952 wxPyEndAllowThreads(__tstate);
53953 if (PyErr_Occurred()) SWIG_fail;
53954 }
53955 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53956 return resultobj;
53957 fail:
53958 return NULL;
53959 }
53960
53961
53962 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53963 PyObject *resultobj = 0;
53964 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53965 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
53966 wxGBSizerItem *result = 0 ;
53967 void *argp1 = 0 ;
53968 int res1 = 0 ;
53969 int res2 = 0 ;
53970 PyObject * obj0 = 0 ;
53971 PyObject * obj1 = 0 ;
53972 char * kwnames[] = {
53973 (char *) "self",(char *) "item", NULL
53974 };
53975
53976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
53977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53978 if (!SWIG_IsOK(res1)) {
53979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53980 }
53981 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53982 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53983 if (!SWIG_IsOK(res2)) {
53984 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
53985 }
53986 {
53987 PyThreadState* __tstate = wxPyBeginAllowThreads();
53988 result = (wxGBSizerItem *)(arg1)->Add(arg2);
53989 wxPyEndAllowThreads(__tstate);
53990 if (PyErr_Occurred()) SWIG_fail;
53991 }
53992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53993 return resultobj;
53994 fail:
53995 return NULL;
53996 }
53997
53998
53999 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54000 PyObject *resultobj = 0;
54001 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54002 int arg2 ;
54003 int arg3 ;
54004 wxSize result;
54005 void *argp1 = 0 ;
54006 int res1 = 0 ;
54007 int val2 ;
54008 int ecode2 = 0 ;
54009 int val3 ;
54010 int ecode3 = 0 ;
54011 PyObject * obj0 = 0 ;
54012 PyObject * obj1 = 0 ;
54013 PyObject * obj2 = 0 ;
54014 char * kwnames[] = {
54015 (char *) "self",(char *) "row",(char *) "col", NULL
54016 };
54017
54018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54020 if (!SWIG_IsOK(res1)) {
54021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54022 }
54023 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54024 ecode2 = SWIG_AsVal_int(obj1, &val2);
54025 if (!SWIG_IsOK(ecode2)) {
54026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
54027 }
54028 arg2 = static_cast< int >(val2);
54029 ecode3 = SWIG_AsVal_int(obj2, &val3);
54030 if (!SWIG_IsOK(ecode3)) {
54031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
54032 }
54033 arg3 = static_cast< int >(val3);
54034 {
54035 PyThreadState* __tstate = wxPyBeginAllowThreads();
54036 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
54037 wxPyEndAllowThreads(__tstate);
54038 if (PyErr_Occurred()) SWIG_fail;
54039 }
54040 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54041 return resultobj;
54042 fail:
54043 return NULL;
54044 }
54045
54046
54047 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54048 PyObject *resultobj = 0;
54049 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54050 wxSize result;
54051 void *argp1 = 0 ;
54052 int res1 = 0 ;
54053 PyObject *swig_obj[1] ;
54054
54055 if (!args) SWIG_fail;
54056 swig_obj[0] = args;
54057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54058 if (!SWIG_IsOK(res1)) {
54059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54060 }
54061 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54062 {
54063 PyThreadState* __tstate = wxPyBeginAllowThreads();
54064 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
54065 wxPyEndAllowThreads(__tstate);
54066 if (PyErr_Occurred()) SWIG_fail;
54067 }
54068 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54069 return resultobj;
54070 fail:
54071 return NULL;
54072 }
54073
54074
54075 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54076 PyObject *resultobj = 0;
54077 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54078 wxSize *arg2 = 0 ;
54079 void *argp1 = 0 ;
54080 int res1 = 0 ;
54081 wxSize temp2 ;
54082 PyObject * obj0 = 0 ;
54083 PyObject * obj1 = 0 ;
54084 char * kwnames[] = {
54085 (char *) "self",(char *) "sz", NULL
54086 };
54087
54088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
54089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54090 if (!SWIG_IsOK(res1)) {
54091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54092 }
54093 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54094 {
54095 arg2 = &temp2;
54096 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
54097 }
54098 {
54099 PyThreadState* __tstate = wxPyBeginAllowThreads();
54100 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
54101 wxPyEndAllowThreads(__tstate);
54102 if (PyErr_Occurred()) SWIG_fail;
54103 }
54104 resultobj = SWIG_Py_Void();
54105 return resultobj;
54106 fail:
54107 return NULL;
54108 }
54109
54110
54111 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54112 PyObject *resultobj = 0;
54113 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54114 wxWindow *arg2 = (wxWindow *) 0 ;
54115 wxGBPosition result;
54116 void *argp1 = 0 ;
54117 int res1 = 0 ;
54118 void *argp2 = 0 ;
54119 int res2 = 0 ;
54120
54121 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54123 if (!SWIG_IsOK(res1)) {
54124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54125 }
54126 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54127 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54128 if (!SWIG_IsOK(res2)) {
54129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54130 }
54131 arg2 = reinterpret_cast< wxWindow * >(argp2);
54132 {
54133 PyThreadState* __tstate = wxPyBeginAllowThreads();
54134 result = (arg1)->GetItemPosition(arg2);
54135 wxPyEndAllowThreads(__tstate);
54136 if (PyErr_Occurred()) SWIG_fail;
54137 }
54138 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54139 return resultobj;
54140 fail:
54141 return NULL;
54142 }
54143
54144
54145 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54146 PyObject *resultobj = 0;
54147 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54148 wxSizer *arg2 = (wxSizer *) 0 ;
54149 wxGBPosition result;
54150 void *argp1 = 0 ;
54151 int res1 = 0 ;
54152 void *argp2 = 0 ;
54153 int res2 = 0 ;
54154
54155 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54157 if (!SWIG_IsOK(res1)) {
54158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54159 }
54160 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54161 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54162 if (!SWIG_IsOK(res2)) {
54163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54164 }
54165 arg2 = reinterpret_cast< wxSizer * >(argp2);
54166 {
54167 PyThreadState* __tstate = wxPyBeginAllowThreads();
54168 result = (arg1)->GetItemPosition(arg2);
54169 wxPyEndAllowThreads(__tstate);
54170 if (PyErr_Occurred()) SWIG_fail;
54171 }
54172 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54173 return resultobj;
54174 fail:
54175 return NULL;
54176 }
54177
54178
54179 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54180 PyObject *resultobj = 0;
54181 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54182 size_t arg2 ;
54183 wxGBPosition result;
54184 void *argp1 = 0 ;
54185 int res1 = 0 ;
54186 size_t val2 ;
54187 int ecode2 = 0 ;
54188
54189 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54191 if (!SWIG_IsOK(res1)) {
54192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54193 }
54194 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54195 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54196 if (!SWIG_IsOK(ecode2)) {
54197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54198 }
54199 arg2 = static_cast< size_t >(val2);
54200 {
54201 PyThreadState* __tstate = wxPyBeginAllowThreads();
54202 result = (arg1)->GetItemPosition(arg2);
54203 wxPyEndAllowThreads(__tstate);
54204 if (PyErr_Occurred()) SWIG_fail;
54205 }
54206 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54207 return resultobj;
54208 fail:
54209 return NULL;
54210 }
54211
54212
54213 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
54214 int argc;
54215 PyObject *argv[3];
54216
54217 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
54218 --argc;
54219 if (argc == 2) {
54220 int _v = 0;
54221 {
54222 void *vptr = 0;
54223 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54224 _v = SWIG_CheckState(res);
54225 }
54226 if (!_v) goto check_1;
54227 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
54228 }
54229 check_1:
54230
54231 if (argc == 2) {
54232 int _v = 0;
54233 {
54234 void *vptr = 0;
54235 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54236 _v = SWIG_CheckState(res);
54237 }
54238 if (!_v) goto check_2;
54239 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
54240 }
54241 check_2:
54242
54243 if (argc == 2) {
54244 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
54245 }
54246
54247 fail:
54248 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
54249 return NULL;
54250 }
54251
54252
54253 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54254 PyObject *resultobj = 0;
54255 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54256 wxWindow *arg2 = (wxWindow *) 0 ;
54257 wxGBPosition *arg3 = 0 ;
54258 bool result;
54259 void *argp1 = 0 ;
54260 int res1 = 0 ;
54261 void *argp2 = 0 ;
54262 int res2 = 0 ;
54263 wxGBPosition temp3 ;
54264
54265 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54267 if (!SWIG_IsOK(res1)) {
54268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54269 }
54270 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54271 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54272 if (!SWIG_IsOK(res2)) {
54273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54274 }
54275 arg2 = reinterpret_cast< wxWindow * >(argp2);
54276 {
54277 arg3 = &temp3;
54278 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54279 }
54280 {
54281 PyThreadState* __tstate = wxPyBeginAllowThreads();
54282 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54283 wxPyEndAllowThreads(__tstate);
54284 if (PyErr_Occurred()) SWIG_fail;
54285 }
54286 {
54287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54288 }
54289 return resultobj;
54290 fail:
54291 return NULL;
54292 }
54293
54294
54295 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54296 PyObject *resultobj = 0;
54297 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54298 wxSizer *arg2 = (wxSizer *) 0 ;
54299 wxGBPosition *arg3 = 0 ;
54300 bool result;
54301 void *argp1 = 0 ;
54302 int res1 = 0 ;
54303 void *argp2 = 0 ;
54304 int res2 = 0 ;
54305 wxGBPosition temp3 ;
54306
54307 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54309 if (!SWIG_IsOK(res1)) {
54310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54311 }
54312 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54313 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54314 if (!SWIG_IsOK(res2)) {
54315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54316 }
54317 arg2 = reinterpret_cast< wxSizer * >(argp2);
54318 {
54319 arg3 = &temp3;
54320 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54321 }
54322 {
54323 PyThreadState* __tstate = wxPyBeginAllowThreads();
54324 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54325 wxPyEndAllowThreads(__tstate);
54326 if (PyErr_Occurred()) SWIG_fail;
54327 }
54328 {
54329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54330 }
54331 return resultobj;
54332 fail:
54333 return NULL;
54334 }
54335
54336
54337 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54338 PyObject *resultobj = 0;
54339 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54340 size_t arg2 ;
54341 wxGBPosition *arg3 = 0 ;
54342 bool result;
54343 void *argp1 = 0 ;
54344 int res1 = 0 ;
54345 size_t val2 ;
54346 int ecode2 = 0 ;
54347 wxGBPosition temp3 ;
54348
54349 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54351 if (!SWIG_IsOK(res1)) {
54352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54353 }
54354 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54355 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54356 if (!SWIG_IsOK(ecode2)) {
54357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54358 }
54359 arg2 = static_cast< size_t >(val2);
54360 {
54361 arg3 = &temp3;
54362 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54363 }
54364 {
54365 PyThreadState* __tstate = wxPyBeginAllowThreads();
54366 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54367 wxPyEndAllowThreads(__tstate);
54368 if (PyErr_Occurred()) SWIG_fail;
54369 }
54370 {
54371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54372 }
54373 return resultobj;
54374 fail:
54375 return NULL;
54376 }
54377
54378
54379 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
54380 int argc;
54381 PyObject *argv[4];
54382
54383 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
54384 --argc;
54385 if (argc == 3) {
54386 int _v = 0;
54387 {
54388 void *vptr = 0;
54389 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54390 _v = SWIG_CheckState(res);
54391 }
54392 if (!_v) goto check_1;
54393 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
54394 }
54395 check_1:
54396
54397 if (argc == 3) {
54398 int _v = 0;
54399 {
54400 void *vptr = 0;
54401 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54402 _v = SWIG_CheckState(res);
54403 }
54404 if (!_v) goto check_2;
54405 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
54406 }
54407 check_2:
54408
54409 if (argc == 3) {
54410 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
54411 }
54412
54413 fail:
54414 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
54415 return NULL;
54416 }
54417
54418
54419 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54420 PyObject *resultobj = 0;
54421 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54422 wxWindow *arg2 = (wxWindow *) 0 ;
54423 wxGBSpan result;
54424 void *argp1 = 0 ;
54425 int res1 = 0 ;
54426 void *argp2 = 0 ;
54427 int res2 = 0 ;
54428
54429 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54431 if (!SWIG_IsOK(res1)) {
54432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54433 }
54434 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54435 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54436 if (!SWIG_IsOK(res2)) {
54437 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54438 }
54439 arg2 = reinterpret_cast< wxWindow * >(argp2);
54440 {
54441 PyThreadState* __tstate = wxPyBeginAllowThreads();
54442 result = (arg1)->GetItemSpan(arg2);
54443 wxPyEndAllowThreads(__tstate);
54444 if (PyErr_Occurred()) SWIG_fail;
54445 }
54446 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54447 return resultobj;
54448 fail:
54449 return NULL;
54450 }
54451
54452
54453 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54454 PyObject *resultobj = 0;
54455 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54456 wxSizer *arg2 = (wxSizer *) 0 ;
54457 wxGBSpan result;
54458 void *argp1 = 0 ;
54459 int res1 = 0 ;
54460 void *argp2 = 0 ;
54461 int res2 = 0 ;
54462
54463 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54465 if (!SWIG_IsOK(res1)) {
54466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54467 }
54468 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54469 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54470 if (!SWIG_IsOK(res2)) {
54471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54472 }
54473 arg2 = reinterpret_cast< wxSizer * >(argp2);
54474 {
54475 PyThreadState* __tstate = wxPyBeginAllowThreads();
54476 result = (arg1)->GetItemSpan(arg2);
54477 wxPyEndAllowThreads(__tstate);
54478 if (PyErr_Occurred()) SWIG_fail;
54479 }
54480 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54481 return resultobj;
54482 fail:
54483 return NULL;
54484 }
54485
54486
54487 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54488 PyObject *resultobj = 0;
54489 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54490 size_t arg2 ;
54491 wxGBSpan result;
54492 void *argp1 = 0 ;
54493 int res1 = 0 ;
54494 size_t val2 ;
54495 int ecode2 = 0 ;
54496
54497 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54499 if (!SWIG_IsOK(res1)) {
54500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54501 }
54502 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54503 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54504 if (!SWIG_IsOK(ecode2)) {
54505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54506 }
54507 arg2 = static_cast< size_t >(val2);
54508 {
54509 PyThreadState* __tstate = wxPyBeginAllowThreads();
54510 result = (arg1)->GetItemSpan(arg2);
54511 wxPyEndAllowThreads(__tstate);
54512 if (PyErr_Occurred()) SWIG_fail;
54513 }
54514 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54515 return resultobj;
54516 fail:
54517 return NULL;
54518 }
54519
54520
54521 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
54522 int argc;
54523 PyObject *argv[3];
54524
54525 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
54526 --argc;
54527 if (argc == 2) {
54528 int _v = 0;
54529 {
54530 void *vptr = 0;
54531 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54532 _v = SWIG_CheckState(res);
54533 }
54534 if (!_v) goto check_1;
54535 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
54536 }
54537 check_1:
54538
54539 if (argc == 2) {
54540 int _v = 0;
54541 {
54542 void *vptr = 0;
54543 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54544 _v = SWIG_CheckState(res);
54545 }
54546 if (!_v) goto check_2;
54547 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
54548 }
54549 check_2:
54550
54551 if (argc == 2) {
54552 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
54553 }
54554
54555 fail:
54556 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
54557 return NULL;
54558 }
54559
54560
54561 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54562 PyObject *resultobj = 0;
54563 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54564 wxWindow *arg2 = (wxWindow *) 0 ;
54565 wxGBSpan *arg3 = 0 ;
54566 bool result;
54567 void *argp1 = 0 ;
54568 int res1 = 0 ;
54569 void *argp2 = 0 ;
54570 int res2 = 0 ;
54571 wxGBSpan temp3 ;
54572
54573 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54575 if (!SWIG_IsOK(res1)) {
54576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54577 }
54578 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54579 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54580 if (!SWIG_IsOK(res2)) {
54581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54582 }
54583 arg2 = reinterpret_cast< wxWindow * >(argp2);
54584 {
54585 arg3 = &temp3;
54586 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54587 }
54588 {
54589 PyThreadState* __tstate = wxPyBeginAllowThreads();
54590 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54591 wxPyEndAllowThreads(__tstate);
54592 if (PyErr_Occurred()) SWIG_fail;
54593 }
54594 {
54595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54596 }
54597 return resultobj;
54598 fail:
54599 return NULL;
54600 }
54601
54602
54603 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54604 PyObject *resultobj = 0;
54605 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54606 wxSizer *arg2 = (wxSizer *) 0 ;
54607 wxGBSpan *arg3 = 0 ;
54608 bool result;
54609 void *argp1 = 0 ;
54610 int res1 = 0 ;
54611 void *argp2 = 0 ;
54612 int res2 = 0 ;
54613 wxGBSpan temp3 ;
54614
54615 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54617 if (!SWIG_IsOK(res1)) {
54618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54619 }
54620 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54621 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54622 if (!SWIG_IsOK(res2)) {
54623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54624 }
54625 arg2 = reinterpret_cast< wxSizer * >(argp2);
54626 {
54627 arg3 = &temp3;
54628 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54629 }
54630 {
54631 PyThreadState* __tstate = wxPyBeginAllowThreads();
54632 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54633 wxPyEndAllowThreads(__tstate);
54634 if (PyErr_Occurred()) SWIG_fail;
54635 }
54636 {
54637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54638 }
54639 return resultobj;
54640 fail:
54641 return NULL;
54642 }
54643
54644
54645 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54646 PyObject *resultobj = 0;
54647 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54648 size_t arg2 ;
54649 wxGBSpan *arg3 = 0 ;
54650 bool result;
54651 void *argp1 = 0 ;
54652 int res1 = 0 ;
54653 size_t val2 ;
54654 int ecode2 = 0 ;
54655 wxGBSpan temp3 ;
54656
54657 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54659 if (!SWIG_IsOK(res1)) {
54660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54661 }
54662 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54663 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54664 if (!SWIG_IsOK(ecode2)) {
54665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54666 }
54667 arg2 = static_cast< size_t >(val2);
54668 {
54669 arg3 = &temp3;
54670 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54671 }
54672 {
54673 PyThreadState* __tstate = wxPyBeginAllowThreads();
54674 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54675 wxPyEndAllowThreads(__tstate);
54676 if (PyErr_Occurred()) SWIG_fail;
54677 }
54678 {
54679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54680 }
54681 return resultobj;
54682 fail:
54683 return NULL;
54684 }
54685
54686
54687 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
54688 int argc;
54689 PyObject *argv[4];
54690
54691 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
54692 --argc;
54693 if (argc == 3) {
54694 int _v = 0;
54695 {
54696 void *vptr = 0;
54697 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54698 _v = SWIG_CheckState(res);
54699 }
54700 if (!_v) goto check_1;
54701 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
54702 }
54703 check_1:
54704
54705 if (argc == 3) {
54706 int _v = 0;
54707 {
54708 void *vptr = 0;
54709 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54710 _v = SWIG_CheckState(res);
54711 }
54712 if (!_v) goto check_2;
54713 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
54714 }
54715 check_2:
54716
54717 if (argc == 3) {
54718 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
54719 }
54720
54721 fail:
54722 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
54723 return NULL;
54724 }
54725
54726
54727 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54728 PyObject *resultobj = 0;
54729 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54730 wxWindow *arg2 = (wxWindow *) 0 ;
54731 wxGBSizerItem *result = 0 ;
54732 void *argp1 = 0 ;
54733 int res1 = 0 ;
54734 void *argp2 = 0 ;
54735 int res2 = 0 ;
54736
54737 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54739 if (!SWIG_IsOK(res1)) {
54740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54741 }
54742 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54743 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54744 if (!SWIG_IsOK(res2)) {
54745 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
54746 }
54747 arg2 = reinterpret_cast< wxWindow * >(argp2);
54748 {
54749 PyThreadState* __tstate = wxPyBeginAllowThreads();
54750 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54751 wxPyEndAllowThreads(__tstate);
54752 if (PyErr_Occurred()) SWIG_fail;
54753 }
54754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54755 return resultobj;
54756 fail:
54757 return NULL;
54758 }
54759
54760
54761 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54762 PyObject *resultobj = 0;
54763 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54764 wxSizer *arg2 = (wxSizer *) 0 ;
54765 wxGBSizerItem *result = 0 ;
54766 void *argp1 = 0 ;
54767 int res1 = 0 ;
54768 void *argp2 = 0 ;
54769 int res2 = 0 ;
54770
54771 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54773 if (!SWIG_IsOK(res1)) {
54774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54775 }
54776 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54777 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54778 if (!SWIG_IsOK(res2)) {
54779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
54780 }
54781 arg2 = reinterpret_cast< wxSizer * >(argp2);
54782 {
54783 PyThreadState* __tstate = wxPyBeginAllowThreads();
54784 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54785 wxPyEndAllowThreads(__tstate);
54786 if (PyErr_Occurred()) SWIG_fail;
54787 }
54788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54789 return resultobj;
54790 fail:
54791 return NULL;
54792 }
54793
54794
54795 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
54796 int argc;
54797 PyObject *argv[3];
54798
54799 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
54800 --argc;
54801 if (argc == 2) {
54802 int _v = 0;
54803 {
54804 void *vptr = 0;
54805 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54806 _v = SWIG_CheckState(res);
54807 }
54808 if (!_v) goto check_1;
54809 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
54810 }
54811 check_1:
54812
54813 if (argc == 2) {
54814 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
54815 }
54816
54817 fail:
54818 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
54819 return NULL;
54820 }
54821
54822
54823 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54824 PyObject *resultobj = 0;
54825 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54826 wxGBPosition *arg2 = 0 ;
54827 wxGBSizerItem *result = 0 ;
54828 void *argp1 = 0 ;
54829 int res1 = 0 ;
54830 wxGBPosition temp2 ;
54831 PyObject * obj0 = 0 ;
54832 PyObject * obj1 = 0 ;
54833 char * kwnames[] = {
54834 (char *) "self",(char *) "pos", NULL
54835 };
54836
54837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54839 if (!SWIG_IsOK(res1)) {
54840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54841 }
54842 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54843 {
54844 arg2 = &temp2;
54845 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54846 }
54847 {
54848 PyThreadState* __tstate = wxPyBeginAllowThreads();
54849 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
54850 wxPyEndAllowThreads(__tstate);
54851 if (PyErr_Occurred()) SWIG_fail;
54852 }
54853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54854 return resultobj;
54855 fail:
54856 return NULL;
54857 }
54858
54859
54860 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54861 PyObject *resultobj = 0;
54862 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54863 wxPoint *arg2 = 0 ;
54864 wxGBSizerItem *result = 0 ;
54865 void *argp1 = 0 ;
54866 int res1 = 0 ;
54867 wxPoint temp2 ;
54868 PyObject * obj0 = 0 ;
54869 PyObject * obj1 = 0 ;
54870 char * kwnames[] = {
54871 (char *) "self",(char *) "pt", NULL
54872 };
54873
54874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
54875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54876 if (!SWIG_IsOK(res1)) {
54877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54878 }
54879 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54880 {
54881 arg2 = &temp2;
54882 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
54883 }
54884 {
54885 PyThreadState* __tstate = wxPyBeginAllowThreads();
54886 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
54887 wxPyEndAllowThreads(__tstate);
54888 if (PyErr_Occurred()) SWIG_fail;
54889 }
54890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54891 return resultobj;
54892 fail:
54893 return NULL;
54894 }
54895
54896
54897 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54898 PyObject *resultobj = 0;
54899 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54900 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54901 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
54902 bool result;
54903 void *argp1 = 0 ;
54904 int res1 = 0 ;
54905 void *argp2 = 0 ;
54906 int res2 = 0 ;
54907 void *argp3 = 0 ;
54908 int res3 = 0 ;
54909 PyObject * obj0 = 0 ;
54910 PyObject * obj1 = 0 ;
54911 PyObject * obj2 = 0 ;
54912 char * kwnames[] = {
54913 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
54914 };
54915
54916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54918 if (!SWIG_IsOK(res1)) {
54919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54920 }
54921 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54922 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54923 if (!SWIG_IsOK(res2)) {
54924 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54925 }
54926 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
54927 if (obj2) {
54928 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54929 if (!SWIG_IsOK(res3)) {
54930 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
54931 }
54932 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
54933 }
54934 {
54935 PyThreadState* __tstate = wxPyBeginAllowThreads();
54936 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
54937 wxPyEndAllowThreads(__tstate);
54938 if (PyErr_Occurred()) SWIG_fail;
54939 }
54940 {
54941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54942 }
54943 return resultobj;
54944 fail:
54945 return NULL;
54946 }
54947
54948
54949 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54950 PyObject *resultobj = 0;
54951 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54952 wxGBPosition *arg2 = 0 ;
54953 wxGBSpan *arg3 = 0 ;
54954 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
54955 bool result;
54956 void *argp1 = 0 ;
54957 int res1 = 0 ;
54958 wxGBPosition temp2 ;
54959 wxGBSpan temp3 ;
54960 void *argp4 = 0 ;
54961 int res4 = 0 ;
54962 PyObject * obj0 = 0 ;
54963 PyObject * obj1 = 0 ;
54964 PyObject * obj2 = 0 ;
54965 PyObject * obj3 = 0 ;
54966 char * kwnames[] = {
54967 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
54968 };
54969
54970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
54971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54972 if (!SWIG_IsOK(res1)) {
54973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54974 }
54975 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54976 {
54977 arg2 = &temp2;
54978 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54979 }
54980 {
54981 arg3 = &temp3;
54982 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54983 }
54984 if (obj3) {
54985 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54986 if (!SWIG_IsOK(res4)) {
54987 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
54988 }
54989 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
54990 }
54991 {
54992 PyThreadState* __tstate = wxPyBeginAllowThreads();
54993 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
54994 wxPyEndAllowThreads(__tstate);
54995 if (PyErr_Occurred()) SWIG_fail;
54996 }
54997 {
54998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54999 }
55000 return resultobj;
55001 fail:
55002 return NULL;
55003 }
55004
55005
55006 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55007 PyObject *obj;
55008 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55009 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
55010 return SWIG_Py_Void();
55011 }
55012
55013 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55014 return SWIG_Python_InitShadowInstance(args);
55015 }
55016
55017 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55018 PyObject *resultobj = 0;
55019 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55020 wxRelationship arg2 ;
55021 wxWindow *arg3 = (wxWindow *) 0 ;
55022 wxEdge arg4 ;
55023 int arg5 = (int) 0 ;
55024 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
55025 void *argp1 = 0 ;
55026 int res1 = 0 ;
55027 int val2 ;
55028 int ecode2 = 0 ;
55029 void *argp3 = 0 ;
55030 int res3 = 0 ;
55031 int val4 ;
55032 int ecode4 = 0 ;
55033 int val5 ;
55034 int ecode5 = 0 ;
55035 int val6 ;
55036 int ecode6 = 0 ;
55037 PyObject * obj0 = 0 ;
55038 PyObject * obj1 = 0 ;
55039 PyObject * obj2 = 0 ;
55040 PyObject * obj3 = 0 ;
55041 PyObject * obj4 = 0 ;
55042 PyObject * obj5 = 0 ;
55043 char * kwnames[] = {
55044 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
55045 };
55046
55047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55049 if (!SWIG_IsOK(res1)) {
55050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55051 }
55052 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55053 ecode2 = SWIG_AsVal_int(obj1, &val2);
55054 if (!SWIG_IsOK(ecode2)) {
55055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
55056 }
55057 arg2 = static_cast< wxRelationship >(val2);
55058 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55059 if (!SWIG_IsOK(res3)) {
55060 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
55061 }
55062 arg3 = reinterpret_cast< wxWindow * >(argp3);
55063 ecode4 = SWIG_AsVal_int(obj3, &val4);
55064 if (!SWIG_IsOK(ecode4)) {
55065 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
55066 }
55067 arg4 = static_cast< wxEdge >(val4);
55068 if (obj4) {
55069 ecode5 = SWIG_AsVal_int(obj4, &val5);
55070 if (!SWIG_IsOK(ecode5)) {
55071 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
55072 }
55073 arg5 = static_cast< int >(val5);
55074 }
55075 if (obj5) {
55076 ecode6 = SWIG_AsVal_int(obj5, &val6);
55077 if (!SWIG_IsOK(ecode6)) {
55078 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
55079 }
55080 arg6 = static_cast< int >(val6);
55081 }
55082 {
55083 PyThreadState* __tstate = wxPyBeginAllowThreads();
55084 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
55085 wxPyEndAllowThreads(__tstate);
55086 if (PyErr_Occurred()) SWIG_fail;
55087 }
55088 resultobj = SWIG_Py_Void();
55089 return resultobj;
55090 fail:
55091 return NULL;
55092 }
55093
55094
55095 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55096 PyObject *resultobj = 0;
55097 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55098 wxWindow *arg2 = (wxWindow *) 0 ;
55099 int arg3 = (int) 0 ;
55100 void *argp1 = 0 ;
55101 int res1 = 0 ;
55102 void *argp2 = 0 ;
55103 int res2 = 0 ;
55104 int val3 ;
55105 int ecode3 = 0 ;
55106 PyObject * obj0 = 0 ;
55107 PyObject * obj1 = 0 ;
55108 PyObject * obj2 = 0 ;
55109 char * kwnames[] = {
55110 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55111 };
55112
55113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55115 if (!SWIG_IsOK(res1)) {
55116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55117 }
55118 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55119 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55120 if (!SWIG_IsOK(res2)) {
55121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55122 }
55123 arg2 = reinterpret_cast< wxWindow * >(argp2);
55124 if (obj2) {
55125 ecode3 = SWIG_AsVal_int(obj2, &val3);
55126 if (!SWIG_IsOK(ecode3)) {
55127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
55128 }
55129 arg3 = static_cast< int >(val3);
55130 }
55131 {
55132 PyThreadState* __tstate = wxPyBeginAllowThreads();
55133 (arg1)->LeftOf(arg2,arg3);
55134 wxPyEndAllowThreads(__tstate);
55135 if (PyErr_Occurred()) SWIG_fail;
55136 }
55137 resultobj = SWIG_Py_Void();
55138 return resultobj;
55139 fail:
55140 return NULL;
55141 }
55142
55143
55144 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55145 PyObject *resultobj = 0;
55146 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55147 wxWindow *arg2 = (wxWindow *) 0 ;
55148 int arg3 = (int) 0 ;
55149 void *argp1 = 0 ;
55150 int res1 = 0 ;
55151 void *argp2 = 0 ;
55152 int res2 = 0 ;
55153 int val3 ;
55154 int ecode3 = 0 ;
55155 PyObject * obj0 = 0 ;
55156 PyObject * obj1 = 0 ;
55157 PyObject * obj2 = 0 ;
55158 char * kwnames[] = {
55159 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55160 };
55161
55162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55164 if (!SWIG_IsOK(res1)) {
55165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55166 }
55167 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55168 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55169 if (!SWIG_IsOK(res2)) {
55170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55171 }
55172 arg2 = reinterpret_cast< wxWindow * >(argp2);
55173 if (obj2) {
55174 ecode3 = SWIG_AsVal_int(obj2, &val3);
55175 if (!SWIG_IsOK(ecode3)) {
55176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
55177 }
55178 arg3 = static_cast< int >(val3);
55179 }
55180 {
55181 PyThreadState* __tstate = wxPyBeginAllowThreads();
55182 (arg1)->RightOf(arg2,arg3);
55183 wxPyEndAllowThreads(__tstate);
55184 if (PyErr_Occurred()) SWIG_fail;
55185 }
55186 resultobj = SWIG_Py_Void();
55187 return resultobj;
55188 fail:
55189 return NULL;
55190 }
55191
55192
55193 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55194 PyObject *resultobj = 0;
55195 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55196 wxWindow *arg2 = (wxWindow *) 0 ;
55197 int arg3 = (int) 0 ;
55198 void *argp1 = 0 ;
55199 int res1 = 0 ;
55200 void *argp2 = 0 ;
55201 int res2 = 0 ;
55202 int val3 ;
55203 int ecode3 = 0 ;
55204 PyObject * obj0 = 0 ;
55205 PyObject * obj1 = 0 ;
55206 PyObject * obj2 = 0 ;
55207 char * kwnames[] = {
55208 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55209 };
55210
55211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55213 if (!SWIG_IsOK(res1)) {
55214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55215 }
55216 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55217 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55218 if (!SWIG_IsOK(res2)) {
55219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
55220 }
55221 arg2 = reinterpret_cast< wxWindow * >(argp2);
55222 if (obj2) {
55223 ecode3 = SWIG_AsVal_int(obj2, &val3);
55224 if (!SWIG_IsOK(ecode3)) {
55225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
55226 }
55227 arg3 = static_cast< int >(val3);
55228 }
55229 {
55230 PyThreadState* __tstate = wxPyBeginAllowThreads();
55231 (arg1)->Above(arg2,arg3);
55232 wxPyEndAllowThreads(__tstate);
55233 if (PyErr_Occurred()) SWIG_fail;
55234 }
55235 resultobj = SWIG_Py_Void();
55236 return resultobj;
55237 fail:
55238 return NULL;
55239 }
55240
55241
55242 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55243 PyObject *resultobj = 0;
55244 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55245 wxWindow *arg2 = (wxWindow *) 0 ;
55246 int arg3 = (int) 0 ;
55247 void *argp1 = 0 ;
55248 int res1 = 0 ;
55249 void *argp2 = 0 ;
55250 int res2 = 0 ;
55251 int val3 ;
55252 int ecode3 = 0 ;
55253 PyObject * obj0 = 0 ;
55254 PyObject * obj1 = 0 ;
55255 PyObject * obj2 = 0 ;
55256 char * kwnames[] = {
55257 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55258 };
55259
55260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55262 if (!SWIG_IsOK(res1)) {
55263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55264 }
55265 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55266 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55267 if (!SWIG_IsOK(res2)) {
55268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
55269 }
55270 arg2 = reinterpret_cast< wxWindow * >(argp2);
55271 if (obj2) {
55272 ecode3 = SWIG_AsVal_int(obj2, &val3);
55273 if (!SWIG_IsOK(ecode3)) {
55274 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
55275 }
55276 arg3 = static_cast< int >(val3);
55277 }
55278 {
55279 PyThreadState* __tstate = wxPyBeginAllowThreads();
55280 (arg1)->Below(arg2,arg3);
55281 wxPyEndAllowThreads(__tstate);
55282 if (PyErr_Occurred()) SWIG_fail;
55283 }
55284 resultobj = SWIG_Py_Void();
55285 return resultobj;
55286 fail:
55287 return NULL;
55288 }
55289
55290
55291 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55292 PyObject *resultobj = 0;
55293 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55294 wxWindow *arg2 = (wxWindow *) 0 ;
55295 wxEdge arg3 ;
55296 int arg4 = (int) 0 ;
55297 void *argp1 = 0 ;
55298 int res1 = 0 ;
55299 void *argp2 = 0 ;
55300 int res2 = 0 ;
55301 int val3 ;
55302 int ecode3 = 0 ;
55303 int val4 ;
55304 int ecode4 = 0 ;
55305 PyObject * obj0 = 0 ;
55306 PyObject * obj1 = 0 ;
55307 PyObject * obj2 = 0 ;
55308 PyObject * obj3 = 0 ;
55309 char * kwnames[] = {
55310 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
55311 };
55312
55313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55315 if (!SWIG_IsOK(res1)) {
55316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55317 }
55318 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55319 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55320 if (!SWIG_IsOK(res2)) {
55321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
55322 }
55323 arg2 = reinterpret_cast< wxWindow * >(argp2);
55324 ecode3 = SWIG_AsVal_int(obj2, &val3);
55325 if (!SWIG_IsOK(ecode3)) {
55326 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
55327 }
55328 arg3 = static_cast< wxEdge >(val3);
55329 if (obj3) {
55330 ecode4 = SWIG_AsVal_int(obj3, &val4);
55331 if (!SWIG_IsOK(ecode4)) {
55332 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
55333 }
55334 arg4 = static_cast< int >(val4);
55335 }
55336 {
55337 PyThreadState* __tstate = wxPyBeginAllowThreads();
55338 (arg1)->SameAs(arg2,arg3,arg4);
55339 wxPyEndAllowThreads(__tstate);
55340 if (PyErr_Occurred()) SWIG_fail;
55341 }
55342 resultobj = SWIG_Py_Void();
55343 return resultobj;
55344 fail:
55345 return NULL;
55346 }
55347
55348
55349 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55350 PyObject *resultobj = 0;
55351 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55352 wxWindow *arg2 = (wxWindow *) 0 ;
55353 wxEdge arg3 ;
55354 int arg4 ;
55355 void *argp1 = 0 ;
55356 int res1 = 0 ;
55357 void *argp2 = 0 ;
55358 int res2 = 0 ;
55359 int val3 ;
55360 int ecode3 = 0 ;
55361 int val4 ;
55362 int ecode4 = 0 ;
55363 PyObject * obj0 = 0 ;
55364 PyObject * obj1 = 0 ;
55365 PyObject * obj2 = 0 ;
55366 PyObject * obj3 = 0 ;
55367 char * kwnames[] = {
55368 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
55369 };
55370
55371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55373 if (!SWIG_IsOK(res1)) {
55374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55375 }
55376 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55377 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55378 if (!SWIG_IsOK(res2)) {
55379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55380 }
55381 arg2 = reinterpret_cast< wxWindow * >(argp2);
55382 ecode3 = SWIG_AsVal_int(obj2, &val3);
55383 if (!SWIG_IsOK(ecode3)) {
55384 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
55385 }
55386 arg3 = static_cast< wxEdge >(val3);
55387 ecode4 = SWIG_AsVal_int(obj3, &val4);
55388 if (!SWIG_IsOK(ecode4)) {
55389 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
55390 }
55391 arg4 = static_cast< int >(val4);
55392 {
55393 PyThreadState* __tstate = wxPyBeginAllowThreads();
55394 (arg1)->PercentOf(arg2,arg3,arg4);
55395 wxPyEndAllowThreads(__tstate);
55396 if (PyErr_Occurred()) SWIG_fail;
55397 }
55398 resultobj = SWIG_Py_Void();
55399 return resultobj;
55400 fail:
55401 return NULL;
55402 }
55403
55404
55405 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55406 PyObject *resultobj = 0;
55407 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55408 int arg2 ;
55409 void *argp1 = 0 ;
55410 int res1 = 0 ;
55411 int val2 ;
55412 int ecode2 = 0 ;
55413 PyObject * obj0 = 0 ;
55414 PyObject * obj1 = 0 ;
55415 char * kwnames[] = {
55416 (char *) "self",(char *) "val", NULL
55417 };
55418
55419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) 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_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55423 }
55424 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55425 ecode2 = SWIG_AsVal_int(obj1, &val2);
55426 if (!SWIG_IsOK(ecode2)) {
55427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
55428 }
55429 arg2 = static_cast< int >(val2);
55430 {
55431 PyThreadState* __tstate = wxPyBeginAllowThreads();
55432 (arg1)->Absolute(arg2);
55433 wxPyEndAllowThreads(__tstate);
55434 if (PyErr_Occurred()) SWIG_fail;
55435 }
55436 resultobj = SWIG_Py_Void();
55437 return resultobj;
55438 fail:
55439 return NULL;
55440 }
55441
55442
55443 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55444 PyObject *resultobj = 0;
55445 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55446 void *argp1 = 0 ;
55447 int res1 = 0 ;
55448 PyObject *swig_obj[1] ;
55449
55450 if (!args) SWIG_fail;
55451 swig_obj[0] = args;
55452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55453 if (!SWIG_IsOK(res1)) {
55454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55455 }
55456 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55457 {
55458 PyThreadState* __tstate = wxPyBeginAllowThreads();
55459 (arg1)->Unconstrained();
55460 wxPyEndAllowThreads(__tstate);
55461 if (PyErr_Occurred()) SWIG_fail;
55462 }
55463 resultobj = SWIG_Py_Void();
55464 return resultobj;
55465 fail:
55466 return NULL;
55467 }
55468
55469
55470 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55471 PyObject *resultobj = 0;
55472 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55473 void *argp1 = 0 ;
55474 int res1 = 0 ;
55475 PyObject *swig_obj[1] ;
55476
55477 if (!args) SWIG_fail;
55478 swig_obj[0] = args;
55479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55480 if (!SWIG_IsOK(res1)) {
55481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55482 }
55483 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55484 {
55485 PyThreadState* __tstate = wxPyBeginAllowThreads();
55486 (arg1)->AsIs();
55487 wxPyEndAllowThreads(__tstate);
55488 if (PyErr_Occurred()) SWIG_fail;
55489 }
55490 resultobj = SWIG_Py_Void();
55491 return resultobj;
55492 fail:
55493 return NULL;
55494 }
55495
55496
55497 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55498 PyObject *resultobj = 0;
55499 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55500 wxWindow *result = 0 ;
55501 void *argp1 = 0 ;
55502 int res1 = 0 ;
55503 PyObject *swig_obj[1] ;
55504
55505 if (!args) SWIG_fail;
55506 swig_obj[0] = args;
55507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55508 if (!SWIG_IsOK(res1)) {
55509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55510 }
55511 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55512 {
55513 PyThreadState* __tstate = wxPyBeginAllowThreads();
55514 result = (wxWindow *)(arg1)->GetOtherWindow();
55515 wxPyEndAllowThreads(__tstate);
55516 if (PyErr_Occurred()) SWIG_fail;
55517 }
55518 {
55519 resultobj = wxPyMake_wxObject(result, 0);
55520 }
55521 return resultobj;
55522 fail:
55523 return NULL;
55524 }
55525
55526
55527 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55528 PyObject *resultobj = 0;
55529 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55530 wxEdge result;
55531 void *argp1 = 0 ;
55532 int res1 = 0 ;
55533 PyObject *swig_obj[1] ;
55534
55535 if (!args) SWIG_fail;
55536 swig_obj[0] = args;
55537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55538 if (!SWIG_IsOK(res1)) {
55539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55540 }
55541 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55542 {
55543 PyThreadState* __tstate = wxPyBeginAllowThreads();
55544 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
55545 wxPyEndAllowThreads(__tstate);
55546 if (PyErr_Occurred()) SWIG_fail;
55547 }
55548 resultobj = SWIG_From_int(static_cast< int >(result));
55549 return resultobj;
55550 fail:
55551 return NULL;
55552 }
55553
55554
55555 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55556 PyObject *resultobj = 0;
55557 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55558 wxEdge arg2 ;
55559 void *argp1 = 0 ;
55560 int res1 = 0 ;
55561 int val2 ;
55562 int ecode2 = 0 ;
55563 PyObject * obj0 = 0 ;
55564 PyObject * obj1 = 0 ;
55565 char * kwnames[] = {
55566 (char *) "self",(char *) "which", NULL
55567 };
55568
55569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
55570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55571 if (!SWIG_IsOK(res1)) {
55572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55573 }
55574 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55575 ecode2 = SWIG_AsVal_int(obj1, &val2);
55576 if (!SWIG_IsOK(ecode2)) {
55577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55578 }
55579 arg2 = static_cast< wxEdge >(val2);
55580 {
55581 PyThreadState* __tstate = wxPyBeginAllowThreads();
55582 (arg1)->SetEdge(arg2);
55583 wxPyEndAllowThreads(__tstate);
55584 if (PyErr_Occurred()) SWIG_fail;
55585 }
55586 resultobj = SWIG_Py_Void();
55587 return resultobj;
55588 fail:
55589 return NULL;
55590 }
55591
55592
55593 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55594 PyObject *resultobj = 0;
55595 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55596 int arg2 ;
55597 void *argp1 = 0 ;
55598 int res1 = 0 ;
55599 int val2 ;
55600 int ecode2 = 0 ;
55601 PyObject * obj0 = 0 ;
55602 PyObject * obj1 = 0 ;
55603 char * kwnames[] = {
55604 (char *) "self",(char *) "v", NULL
55605 };
55606
55607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
55608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55609 if (!SWIG_IsOK(res1)) {
55610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55611 }
55612 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55613 ecode2 = SWIG_AsVal_int(obj1, &val2);
55614 if (!SWIG_IsOK(ecode2)) {
55615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
55616 }
55617 arg2 = static_cast< int >(val2);
55618 {
55619 PyThreadState* __tstate = wxPyBeginAllowThreads();
55620 (arg1)->SetValue(arg2);
55621 wxPyEndAllowThreads(__tstate);
55622 if (PyErr_Occurred()) SWIG_fail;
55623 }
55624 resultobj = SWIG_Py_Void();
55625 return resultobj;
55626 fail:
55627 return NULL;
55628 }
55629
55630
55631 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55632 PyObject *resultobj = 0;
55633 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55634 int result;
55635 void *argp1 = 0 ;
55636 int res1 = 0 ;
55637 PyObject *swig_obj[1] ;
55638
55639 if (!args) SWIG_fail;
55640 swig_obj[0] = args;
55641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55642 if (!SWIG_IsOK(res1)) {
55643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55644 }
55645 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55646 {
55647 PyThreadState* __tstate = wxPyBeginAllowThreads();
55648 result = (int)(arg1)->GetMargin();
55649 wxPyEndAllowThreads(__tstate);
55650 if (PyErr_Occurred()) SWIG_fail;
55651 }
55652 resultobj = SWIG_From_int(static_cast< int >(result));
55653 return resultobj;
55654 fail:
55655 return NULL;
55656 }
55657
55658
55659 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55660 PyObject *resultobj = 0;
55661 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55662 int arg2 ;
55663 void *argp1 = 0 ;
55664 int res1 = 0 ;
55665 int val2 ;
55666 int ecode2 = 0 ;
55667 PyObject * obj0 = 0 ;
55668 PyObject * obj1 = 0 ;
55669 char * kwnames[] = {
55670 (char *) "self",(char *) "m", NULL
55671 };
55672
55673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
55674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55675 if (!SWIG_IsOK(res1)) {
55676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55677 }
55678 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55679 ecode2 = SWIG_AsVal_int(obj1, &val2);
55680 if (!SWIG_IsOK(ecode2)) {
55681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
55682 }
55683 arg2 = static_cast< int >(val2);
55684 {
55685 PyThreadState* __tstate = wxPyBeginAllowThreads();
55686 (arg1)->SetMargin(arg2);
55687 wxPyEndAllowThreads(__tstate);
55688 if (PyErr_Occurred()) SWIG_fail;
55689 }
55690 resultobj = SWIG_Py_Void();
55691 return resultobj;
55692 fail:
55693 return NULL;
55694 }
55695
55696
55697 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55698 PyObject *resultobj = 0;
55699 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55700 int result;
55701 void *argp1 = 0 ;
55702 int res1 = 0 ;
55703 PyObject *swig_obj[1] ;
55704
55705 if (!args) SWIG_fail;
55706 swig_obj[0] = args;
55707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55708 if (!SWIG_IsOK(res1)) {
55709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55710 }
55711 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55712 {
55713 PyThreadState* __tstate = wxPyBeginAllowThreads();
55714 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
55715 wxPyEndAllowThreads(__tstate);
55716 if (PyErr_Occurred()) SWIG_fail;
55717 }
55718 resultobj = SWIG_From_int(static_cast< int >(result));
55719 return resultobj;
55720 fail:
55721 return NULL;
55722 }
55723
55724
55725 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55726 PyObject *resultobj = 0;
55727 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55728 int result;
55729 void *argp1 = 0 ;
55730 int res1 = 0 ;
55731 PyObject *swig_obj[1] ;
55732
55733 if (!args) SWIG_fail;
55734 swig_obj[0] = args;
55735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55736 if (!SWIG_IsOK(res1)) {
55737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55738 }
55739 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55740 {
55741 PyThreadState* __tstate = wxPyBeginAllowThreads();
55742 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
55743 wxPyEndAllowThreads(__tstate);
55744 if (PyErr_Occurred()) SWIG_fail;
55745 }
55746 resultobj = SWIG_From_int(static_cast< int >(result));
55747 return resultobj;
55748 fail:
55749 return NULL;
55750 }
55751
55752
55753 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55754 PyObject *resultobj = 0;
55755 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55756 int result;
55757 void *argp1 = 0 ;
55758 int res1 = 0 ;
55759 PyObject *swig_obj[1] ;
55760
55761 if (!args) SWIG_fail;
55762 swig_obj[0] = args;
55763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55764 if (!SWIG_IsOK(res1)) {
55765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55766 }
55767 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55768 {
55769 PyThreadState* __tstate = wxPyBeginAllowThreads();
55770 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
55771 wxPyEndAllowThreads(__tstate);
55772 if (PyErr_Occurred()) SWIG_fail;
55773 }
55774 resultobj = SWIG_From_int(static_cast< int >(result));
55775 return resultobj;
55776 fail:
55777 return NULL;
55778 }
55779
55780
55781 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55782 PyObject *resultobj = 0;
55783 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55784 bool result;
55785 void *argp1 = 0 ;
55786 int res1 = 0 ;
55787 PyObject *swig_obj[1] ;
55788
55789 if (!args) SWIG_fail;
55790 swig_obj[0] = args;
55791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55792 if (!SWIG_IsOK(res1)) {
55793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55794 }
55795 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55796 {
55797 PyThreadState* __tstate = wxPyBeginAllowThreads();
55798 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
55799 wxPyEndAllowThreads(__tstate);
55800 if (PyErr_Occurred()) SWIG_fail;
55801 }
55802 {
55803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55804 }
55805 return resultobj;
55806 fail:
55807 return NULL;
55808 }
55809
55810
55811 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55812 PyObject *resultobj = 0;
55813 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55814 bool arg2 ;
55815 void *argp1 = 0 ;
55816 int res1 = 0 ;
55817 bool val2 ;
55818 int ecode2 = 0 ;
55819 PyObject * obj0 = 0 ;
55820 PyObject * obj1 = 0 ;
55821 char * kwnames[] = {
55822 (char *) "self",(char *) "d", NULL
55823 };
55824
55825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
55826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55827 if (!SWIG_IsOK(res1)) {
55828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55829 }
55830 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55831 ecode2 = SWIG_AsVal_bool(obj1, &val2);
55832 if (!SWIG_IsOK(ecode2)) {
55833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
55834 }
55835 arg2 = static_cast< bool >(val2);
55836 {
55837 PyThreadState* __tstate = wxPyBeginAllowThreads();
55838 (arg1)->SetDone(arg2);
55839 wxPyEndAllowThreads(__tstate);
55840 if (PyErr_Occurred()) SWIG_fail;
55841 }
55842 resultobj = SWIG_Py_Void();
55843 return resultobj;
55844 fail:
55845 return NULL;
55846 }
55847
55848
55849 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55850 PyObject *resultobj = 0;
55851 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55852 wxRelationship result;
55853 void *argp1 = 0 ;
55854 int res1 = 0 ;
55855 PyObject *swig_obj[1] ;
55856
55857 if (!args) SWIG_fail;
55858 swig_obj[0] = args;
55859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55860 if (!SWIG_IsOK(res1)) {
55861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55862 }
55863 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55864 {
55865 PyThreadState* __tstate = wxPyBeginAllowThreads();
55866 result = (wxRelationship)(arg1)->GetRelationship();
55867 wxPyEndAllowThreads(__tstate);
55868 if (PyErr_Occurred()) SWIG_fail;
55869 }
55870 resultobj = SWIG_From_int(static_cast< int >(result));
55871 return resultobj;
55872 fail:
55873 return NULL;
55874 }
55875
55876
55877 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55878 PyObject *resultobj = 0;
55879 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55880 wxRelationship arg2 ;
55881 void *argp1 = 0 ;
55882 int res1 = 0 ;
55883 int val2 ;
55884 int ecode2 = 0 ;
55885 PyObject * obj0 = 0 ;
55886 PyObject * obj1 = 0 ;
55887 char * kwnames[] = {
55888 (char *) "self",(char *) "r", NULL
55889 };
55890
55891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
55892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55893 if (!SWIG_IsOK(res1)) {
55894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55895 }
55896 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55897 ecode2 = SWIG_AsVal_int(obj1, &val2);
55898 if (!SWIG_IsOK(ecode2)) {
55899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
55900 }
55901 arg2 = static_cast< wxRelationship >(val2);
55902 {
55903 PyThreadState* __tstate = wxPyBeginAllowThreads();
55904 (arg1)->SetRelationship(arg2);
55905 wxPyEndAllowThreads(__tstate);
55906 if (PyErr_Occurred()) SWIG_fail;
55907 }
55908 resultobj = SWIG_Py_Void();
55909 return resultobj;
55910 fail:
55911 return NULL;
55912 }
55913
55914
55915 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55916 PyObject *resultobj = 0;
55917 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55918 wxWindow *arg2 = (wxWindow *) 0 ;
55919 bool result;
55920 void *argp1 = 0 ;
55921 int res1 = 0 ;
55922 void *argp2 = 0 ;
55923 int res2 = 0 ;
55924 PyObject * obj0 = 0 ;
55925 PyObject * obj1 = 0 ;
55926 char * kwnames[] = {
55927 (char *) "self",(char *) "otherW", NULL
55928 };
55929
55930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
55931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55932 if (!SWIG_IsOK(res1)) {
55933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55934 }
55935 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55936 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55937 if (!SWIG_IsOK(res2)) {
55938 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
55939 }
55940 arg2 = reinterpret_cast< wxWindow * >(argp2);
55941 {
55942 PyThreadState* __tstate = wxPyBeginAllowThreads();
55943 result = (bool)(arg1)->ResetIfWin(arg2);
55944 wxPyEndAllowThreads(__tstate);
55945 if (PyErr_Occurred()) SWIG_fail;
55946 }
55947 {
55948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55949 }
55950 return resultobj;
55951 fail:
55952 return NULL;
55953 }
55954
55955
55956 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55957 PyObject *resultobj = 0;
55958 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55959 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
55960 wxWindow *arg3 = (wxWindow *) 0 ;
55961 bool result;
55962 void *argp1 = 0 ;
55963 int res1 = 0 ;
55964 void *argp2 = 0 ;
55965 int res2 = 0 ;
55966 void *argp3 = 0 ;
55967 int res3 = 0 ;
55968 PyObject * obj0 = 0 ;
55969 PyObject * obj1 = 0 ;
55970 PyObject * obj2 = 0 ;
55971 char * kwnames[] = {
55972 (char *) "self",(char *) "constraints",(char *) "win", NULL
55973 };
55974
55975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55977 if (!SWIG_IsOK(res1)) {
55978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55979 }
55980 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55981 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
55982 if (!SWIG_IsOK(res2)) {
55983 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
55984 }
55985 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
55986 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55987 if (!SWIG_IsOK(res3)) {
55988 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
55989 }
55990 arg3 = reinterpret_cast< wxWindow * >(argp3);
55991 {
55992 PyThreadState* __tstate = wxPyBeginAllowThreads();
55993 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
55994 wxPyEndAllowThreads(__tstate);
55995 if (PyErr_Occurred()) SWIG_fail;
55996 }
55997 {
55998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55999 }
56000 return resultobj;
56001 fail:
56002 return NULL;
56003 }
56004
56005
56006 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56007 PyObject *resultobj = 0;
56008 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56009 wxEdge arg2 ;
56010 wxWindow *arg3 = (wxWindow *) 0 ;
56011 wxWindow *arg4 = (wxWindow *) 0 ;
56012 int result;
56013 void *argp1 = 0 ;
56014 int res1 = 0 ;
56015 int val2 ;
56016 int ecode2 = 0 ;
56017 void *argp3 = 0 ;
56018 int res3 = 0 ;
56019 void *argp4 = 0 ;
56020 int res4 = 0 ;
56021 PyObject * obj0 = 0 ;
56022 PyObject * obj1 = 0 ;
56023 PyObject * obj2 = 0 ;
56024 PyObject * obj3 = 0 ;
56025 char * kwnames[] = {
56026 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
56027 };
56028
56029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56031 if (!SWIG_IsOK(res1)) {
56032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56033 }
56034 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56035 ecode2 = SWIG_AsVal_int(obj1, &val2);
56036 if (!SWIG_IsOK(ecode2)) {
56037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
56038 }
56039 arg2 = static_cast< wxEdge >(val2);
56040 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56041 if (!SWIG_IsOK(res3)) {
56042 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
56043 }
56044 arg3 = reinterpret_cast< wxWindow * >(argp3);
56045 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
56046 if (!SWIG_IsOK(res4)) {
56047 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
56048 }
56049 arg4 = reinterpret_cast< wxWindow * >(argp4);
56050 {
56051 PyThreadState* __tstate = wxPyBeginAllowThreads();
56052 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
56053 wxPyEndAllowThreads(__tstate);
56054 if (PyErr_Occurred()) SWIG_fail;
56055 }
56056 resultobj = SWIG_From_int(static_cast< int >(result));
56057 return resultobj;
56058 fail:
56059 return NULL;
56060 }
56061
56062
56063 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56064 PyObject *obj;
56065 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56066 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
56067 return SWIG_Py_Void();
56068 }
56069
56070 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56071 PyObject *resultobj = 0;
56072 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56073 wxIndividualLayoutConstraint *result = 0 ;
56074 void *argp1 = 0 ;
56075 int res1 = 0 ;
56076 PyObject *swig_obj[1] ;
56077
56078 if (!args) SWIG_fail;
56079 swig_obj[0] = args;
56080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56081 if (!SWIG_IsOK(res1)) {
56082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56083 }
56084 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56085 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
56086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56087 return resultobj;
56088 fail:
56089 return NULL;
56090 }
56091
56092
56093 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56094 PyObject *resultobj = 0;
56095 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56096 wxIndividualLayoutConstraint *result = 0 ;
56097 void *argp1 = 0 ;
56098 int res1 = 0 ;
56099 PyObject *swig_obj[1] ;
56100
56101 if (!args) SWIG_fail;
56102 swig_obj[0] = args;
56103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56104 if (!SWIG_IsOK(res1)) {
56105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56106 }
56107 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56108 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
56109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56110 return resultobj;
56111 fail:
56112 return NULL;
56113 }
56114
56115
56116 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56117 PyObject *resultobj = 0;
56118 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56119 wxIndividualLayoutConstraint *result = 0 ;
56120 void *argp1 = 0 ;
56121 int res1 = 0 ;
56122 PyObject *swig_obj[1] ;
56123
56124 if (!args) SWIG_fail;
56125 swig_obj[0] = args;
56126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56127 if (!SWIG_IsOK(res1)) {
56128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56129 }
56130 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56131 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
56132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56133 return resultobj;
56134 fail:
56135 return NULL;
56136 }
56137
56138
56139 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56140 PyObject *resultobj = 0;
56141 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56142 wxIndividualLayoutConstraint *result = 0 ;
56143 void *argp1 = 0 ;
56144 int res1 = 0 ;
56145 PyObject *swig_obj[1] ;
56146
56147 if (!args) SWIG_fail;
56148 swig_obj[0] = args;
56149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56150 if (!SWIG_IsOK(res1)) {
56151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56152 }
56153 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56154 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
56155 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56156 return resultobj;
56157 fail:
56158 return NULL;
56159 }
56160
56161
56162 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56163 PyObject *resultobj = 0;
56164 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56165 wxIndividualLayoutConstraint *result = 0 ;
56166 void *argp1 = 0 ;
56167 int res1 = 0 ;
56168 PyObject *swig_obj[1] ;
56169
56170 if (!args) SWIG_fail;
56171 swig_obj[0] = args;
56172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56173 if (!SWIG_IsOK(res1)) {
56174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56175 }
56176 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56177 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
56178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56179 return resultobj;
56180 fail:
56181 return NULL;
56182 }
56183
56184
56185 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56186 PyObject *resultobj = 0;
56187 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56188 wxIndividualLayoutConstraint *result = 0 ;
56189 void *argp1 = 0 ;
56190 int res1 = 0 ;
56191 PyObject *swig_obj[1] ;
56192
56193 if (!args) SWIG_fail;
56194 swig_obj[0] = args;
56195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56196 if (!SWIG_IsOK(res1)) {
56197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56198 }
56199 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56200 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
56201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56202 return resultobj;
56203 fail:
56204 return NULL;
56205 }
56206
56207
56208 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56209 PyObject *resultobj = 0;
56210 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56211 wxIndividualLayoutConstraint *result = 0 ;
56212 void *argp1 = 0 ;
56213 int res1 = 0 ;
56214 PyObject *swig_obj[1] ;
56215
56216 if (!args) SWIG_fail;
56217 swig_obj[0] = args;
56218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56219 if (!SWIG_IsOK(res1)) {
56220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56221 }
56222 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56223 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
56224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56225 return resultobj;
56226 fail:
56227 return NULL;
56228 }
56229
56230
56231 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56232 PyObject *resultobj = 0;
56233 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56234 wxIndividualLayoutConstraint *result = 0 ;
56235 void *argp1 = 0 ;
56236 int res1 = 0 ;
56237 PyObject *swig_obj[1] ;
56238
56239 if (!args) SWIG_fail;
56240 swig_obj[0] = args;
56241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56242 if (!SWIG_IsOK(res1)) {
56243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56244 }
56245 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56246 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
56247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56248 return resultobj;
56249 fail:
56250 return NULL;
56251 }
56252
56253
56254 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56255 PyObject *resultobj = 0;
56256 wxLayoutConstraints *result = 0 ;
56257
56258 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
56259 {
56260 PyThreadState* __tstate = wxPyBeginAllowThreads();
56261 result = (wxLayoutConstraints *)new wxLayoutConstraints();
56262 wxPyEndAllowThreads(__tstate);
56263 if (PyErr_Occurred()) SWIG_fail;
56264 }
56265 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
56266 return resultobj;
56267 fail:
56268 return NULL;
56269 }
56270
56271
56272 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56273 PyObject *resultobj = 0;
56274 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56275 void *argp1 = 0 ;
56276 int res1 = 0 ;
56277 PyObject *swig_obj[1] ;
56278
56279 if (!args) SWIG_fail;
56280 swig_obj[0] = args;
56281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
56282 if (!SWIG_IsOK(res1)) {
56283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56284 }
56285 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56286 {
56287 PyThreadState* __tstate = wxPyBeginAllowThreads();
56288 delete arg1;
56289
56290 wxPyEndAllowThreads(__tstate);
56291 if (PyErr_Occurred()) SWIG_fail;
56292 }
56293 resultobj = SWIG_Py_Void();
56294 return resultobj;
56295 fail:
56296 return NULL;
56297 }
56298
56299
56300 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56301 PyObject *resultobj = 0;
56302 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56303 wxWindow *arg2 = (wxWindow *) 0 ;
56304 int *arg3 = (int *) 0 ;
56305 bool result;
56306 void *argp1 = 0 ;
56307 int res1 = 0 ;
56308 void *argp2 = 0 ;
56309 int res2 = 0 ;
56310 int temp3 ;
56311 int res3 = SWIG_TMPOBJ ;
56312 PyObject * obj0 = 0 ;
56313 PyObject * obj1 = 0 ;
56314 char * kwnames[] = {
56315 (char *) "self",(char *) "win", NULL
56316 };
56317
56318 arg3 = &temp3;
56319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
56320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56321 if (!SWIG_IsOK(res1)) {
56322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56323 }
56324 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56325 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56326 if (!SWIG_IsOK(res2)) {
56327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
56328 }
56329 arg2 = reinterpret_cast< wxWindow * >(argp2);
56330 {
56331 PyThreadState* __tstate = wxPyBeginAllowThreads();
56332 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
56333 wxPyEndAllowThreads(__tstate);
56334 if (PyErr_Occurred()) SWIG_fail;
56335 }
56336 {
56337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56338 }
56339 if (SWIG_IsTmpObj(res3)) {
56340 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
56341 } else {
56342 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
56343 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
56344 }
56345 return resultobj;
56346 fail:
56347 return NULL;
56348 }
56349
56350
56351 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56352 PyObject *resultobj = 0;
56353 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56354 bool result;
56355 void *argp1 = 0 ;
56356 int res1 = 0 ;
56357 PyObject *swig_obj[1] ;
56358
56359 if (!args) SWIG_fail;
56360 swig_obj[0] = args;
56361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56362 if (!SWIG_IsOK(res1)) {
56363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
56364 }
56365 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56366 {
56367 PyThreadState* __tstate = wxPyBeginAllowThreads();
56368 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
56369 wxPyEndAllowThreads(__tstate);
56370 if (PyErr_Occurred()) SWIG_fail;
56371 }
56372 {
56373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56374 }
56375 return resultobj;
56376 fail:
56377 return NULL;
56378 }
56379
56380
56381 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56382 PyObject *obj;
56383 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56384 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
56385 return SWIG_Py_Void();
56386 }
56387
56388 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56389 return SWIG_Python_InitShadowInstance(args);
56390 }
56391
56392 static PyMethodDef SwigMethods[] = {
56393 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
56394 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
56395 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
56396 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
56397 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
56398 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
56399 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
56400 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
56401 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56402 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
56403 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56404 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56405 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56406 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56407 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
56408 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
56409 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
56410 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
56411 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56412 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56413 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56414 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56415 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
56416 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
56417 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
56418 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
56419 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
56420 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
56421 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
56422 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
56423 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
56424 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
56425 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
56426 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56427 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
56428 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56429 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56430 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56431 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56432 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56433 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
56434 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
56435 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
56436 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
56437 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
56438 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
56439 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
56440 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
56441 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
56442 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56443 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56444 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56445 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56446 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56447 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56448 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56449 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
56450 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
56451 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
56452 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
56453 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
56454 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
56455 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
56456 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
56457 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
56458 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
56459 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
56460 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
56461 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
56462 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56463 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
56464 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56465 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
56466 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56467 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
56468 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
56469 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
56470 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
56471 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56472 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
56473 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
56474 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
56475 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
56476 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
56477 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56478 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
56479 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
56480 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
56481 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
56482 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56483 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56484 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56485 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56486 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
56487 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
56488 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
56489 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56490 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56491 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56492 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56493 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56494 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56495 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56496 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
56497 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56498 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56499 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56500 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
56501 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
56502 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
56503 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
56504 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
56505 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
56506 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
56507 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
56508 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
56509 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56510 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
56511 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
56512 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
56513 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
56514 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
56515 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
56516 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56517 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
56518 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
56519 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
56520 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
56521 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
56522 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
56523 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
56524 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
56525 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
56526 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56527 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56528 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
56529 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56530 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56531 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
56532 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
56533 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56534 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56535 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
56536 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
56537 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
56538 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
56539 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56540 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
56541 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
56542 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
56543 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
56544 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
56545 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
56546 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
56547 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
56548 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56549 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
56550 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
56551 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56552 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56553 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
56554 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56555 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56556 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
56557 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56558 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
56559 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
56560 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
56561 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56562 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
56563 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56564 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56565 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
56566 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
56567 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56568 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
56569 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56570 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56571 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
56572 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
56573 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
56574 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
56575 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56576 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56577 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
56578 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
56579 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
56580 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56581 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
56582 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
56583 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56584 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
56585 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56586 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56587 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
56588 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
56589 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56590 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56591 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
56592 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
56593 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
56594 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
56595 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
56596 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
56597 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
56598 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
56599 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56600 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
56601 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
56602 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
56603 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
56604 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
56605 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
56606 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
56607 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
56608 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
56609 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
56610 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
56611 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
56612 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
56613 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
56614 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
56615 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
56616 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
56617 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
56618 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
56619 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
56620 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
56621 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
56622 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
56623 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
56624 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
56625 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
56626 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
56627 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
56628 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
56629 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
56630 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
56631 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
56632 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
56633 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
56634 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
56635 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
56636 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
56637 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
56638 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
56639 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56640 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56641 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56642 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56643 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
56644 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
56645 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56646 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
56647 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56648 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
56649 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
56650 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
56651 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
56652 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
56653 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
56654 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
56655 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56656 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56657 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
56658 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56659 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56660 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
56661 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
56662 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
56663 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
56664 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
56665 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
56666 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56667 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56668 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
56669 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
56670 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
56671 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56672 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56673 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56674 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
56675 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
56676 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
56677 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
56678 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56679 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
56680 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
56681 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56682 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56683 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56684 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56685 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
56686 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
56687 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
56688 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
56689 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
56690 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
56691 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
56692 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56693 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56694 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
56695 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
56696 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
56697 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
56698 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
56699 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
56700 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
56701 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
56702 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
56703 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
56704 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56705 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56706 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
56707 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56708 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
56709 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
56710 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
56711 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
56712 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
56713 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
56714 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
56715 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
56716 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
56717 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
56718 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
56719 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
56720 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
56721 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
56722 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
56723 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
56724 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
56725 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
56726 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
56727 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
56728 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
56729 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
56730 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
56731 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
56732 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
56733 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
56734 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
56735 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56736 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
56737 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56738 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
56739 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
56740 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56741 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
56742 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
56743 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
56744 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
56745 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
56746 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
56747 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
56748 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
56749 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56750 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
56751 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
56752 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
56753 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
56754 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56755 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56756 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
56757 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
56758 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
56759 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56760 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
56761 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56762 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
56763 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56764 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
56765 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
56766 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56767 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56768 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56769 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56770 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56771 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
56772 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
56773 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
56774 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
56775 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
56776 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
56777 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56778 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
56779 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
56780 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
56781 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
56782 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
56783 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56784 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
56785 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
56786 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
56787 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56788 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
56789 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
56790 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
56791 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
56792 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
56793 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
56794 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
56795 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
56796 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
56797 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
56798 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
56799 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
56800 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
56801 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56802 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56803 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56804 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56805 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
56806 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
56807 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
56808 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56809 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56810 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56811 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
56812 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
56813 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56814 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56815 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
56816 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
56817 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56818 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
56819 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
56820 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56821 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
56822 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
56823 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
56824 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
56825 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
56826 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
56827 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
56828 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
56829 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
56830 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
56831 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
56832 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
56833 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
56834 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
56835 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
56836 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
56837 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
56838 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
56839 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
56840 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
56841 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
56842 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
56843 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
56844 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
56845 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
56846 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
56847 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
56848 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
56849 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
56850 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
56851 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
56852 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
56853 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
56854 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
56855 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
56856 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
56857 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
56858 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
56859 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56860 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56861 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
56862 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
56863 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56864 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56865 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
56866 { (char *)"EvtHandler_AllowReentrance", (PyCFunction) _wrap_EvtHandler_AllowReentrance, METH_VARARGS | METH_KEYWORDS, NULL},
56867 { (char *)"EvtHandler_IsReentranceAllowed", (PyCFunction)_wrap_EvtHandler_IsReentranceAllowed, METH_O, NULL},
56868 { (char *)"EvtHandler_IsEventHandlingInProgress", (PyCFunction)_wrap_EvtHandler_IsEventHandlingInProgress, METH_O, NULL},
56869 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
56870 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
56871 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56872 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
56873 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
56874 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
56875 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
56876 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
56877 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
56878 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
56879 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
56880 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
56881 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
56882 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
56883 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
56884 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
56885 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
56886 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
56887 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
56888 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
56889 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
56890 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
56891 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
56892 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
56893 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
56894 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
56895 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
56896 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
56897 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
56898 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
56899 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
56900 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56901 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
56902 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
56903 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
56904 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
56905 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
56906 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
56907 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
56908 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
56909 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
56910 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
56911 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
56912 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
56913 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
56914 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
56915 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56916 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
56917 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
56918 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
56919 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
56920 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
56921 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56922 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
56923 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
56924 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56925 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56926 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
56927 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
56928 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56929 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
56930 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
56931 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56932 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56933 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
56934 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
56935 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56936 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
56937 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
56938 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
56939 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
56940 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
56941 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
56942 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
56943 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
56944 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
56945 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
56946 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
56947 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
56948 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
56949 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
56950 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
56951 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
56952 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
56953 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
56954 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
56955 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
56956 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
56957 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
56958 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
56959 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
56960 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
56961 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
56962 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
56963 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
56964 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
56965 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
56966 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56967 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
56968 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
56969 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
56970 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
56971 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
56972 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
56973 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
56974 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
56975 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
56976 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
56977 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
56978 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
56979 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
56980 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
56981 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
56982 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
56983 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
56984 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
56985 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
56986 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
56987 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
56988 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
56989 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
56990 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
56991 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
56992 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
56993 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
56994 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
56995 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
56996 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
56997 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
56998 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
56999 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57000 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
57001 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
57002 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57003 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
57004 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
57005 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
57006 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
57007 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57008 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
57009 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
57010 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
57011 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
57012 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
57013 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
57014 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
57015 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
57016 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
57017 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
57018 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
57019 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
57020 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
57021 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
57022 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
57023 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
57024 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
57025 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
57026 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
57027 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
57028 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
57029 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
57030 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
57031 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
57032 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
57033 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
57034 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
57035 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
57036 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
57037 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
57038 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
57039 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
57040 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
57041 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
57042 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
57043 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
57044 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
57045 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
57046 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57047 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
57048 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
57049 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57050 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57051 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
57052 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
57053 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
57054 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
57055 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
57056 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
57057 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57058 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
57059 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
57060 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57061 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57062 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
57063 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
57064 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57065 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
57066 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
57067 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57068 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
57069 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
57070 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57071 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
57072 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
57073 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
57074 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57075 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
57076 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57077 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
57078 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
57079 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57080 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
57081 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
57082 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
57083 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57084 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
57085 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
57086 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
57087 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57088 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
57089 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
57090 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57091 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
57092 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
57093 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
57094 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
57095 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
57096 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57097 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
57098 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
57099 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
57100 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
57101 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
57102 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
57103 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
57104 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
57105 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57106 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
57107 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
57108 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
57109 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
57110 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57111 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
57112 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
57113 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
57114 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57115 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
57116 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
57117 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
57118 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
57119 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
57120 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
57121 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57122 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
57123 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
57124 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
57125 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
57126 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
57127 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
57128 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
57129 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
57130 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57131 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57132 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57133 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57134 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
57135 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
57136 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
57137 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
57138 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57139 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
57140 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
57141 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
57142 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
57143 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
57144 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
57145 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57146 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
57147 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
57148 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
57149 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57150 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
57151 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
57152 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
57153 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
57154 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
57155 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57156 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57157 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
57158 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
57159 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
57160 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57161 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
57162 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
57163 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
57164 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
57165 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
57166 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
57167 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57168 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
57169 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
57170 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
57171 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
57172 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
57173 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
57174 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
57175 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
57176 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
57177 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57178 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
57179 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
57180 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
57181 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57182 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
57183 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
57184 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
57185 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57186 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
57187 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57188 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
57189 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
57190 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
57191 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
57192 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
57193 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57194 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
57195 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
57196 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
57197 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
57198 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57199 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
57200 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
57201 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57202 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
57203 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57204 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
57205 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
57206 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
57207 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57208 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
57209 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57210 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
57211 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
57212 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
57213 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57214 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
57215 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
57216 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
57217 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
57218 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
57219 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
57220 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57221 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
57222 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
57223 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
57224 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
57225 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
57226 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
57227 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
57228 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
57229 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
57230 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
57231 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
57232 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
57233 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
57234 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
57235 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
57236 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
57237 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
57238 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
57239 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
57240 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
57241 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57242 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
57243 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
57244 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
57245 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
57246 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
57247 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
57248 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
57249 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
57250 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
57251 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
57252 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
57253 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
57254 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
57255 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
57256 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
57257 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57258 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57259 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57260 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
57261 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
57262 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
57263 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
57264 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
57265 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
57266 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
57267 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
57268 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
57269 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
57270 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
57271 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57272 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
57273 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
57274 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
57275 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
57276 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
57277 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
57278 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
57279 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
57280 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
57281 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
57282 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
57283 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
57284 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
57285 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
57286 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
57287 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
57288 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
57289 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
57290 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
57291 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
57292 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
57293 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57294 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57295 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
57296 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
57297 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
57298 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
57299 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
57300 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
57301 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
57302 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
57303 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57304 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
57305 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
57306 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
57307 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
57308 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
57309 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
57310 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
57311 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
57312 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
57313 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
57314 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
57315 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
57316 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
57317 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
57318 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
57319 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
57320 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
57321 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57322 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
57323 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
57324 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
57325 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
57326 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57327 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
57328 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57329 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
57330 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
57331 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
57332 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57333 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
57334 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
57335 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57336 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57337 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
57338 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57339 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57340 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57341 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
57342 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57343 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57344 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
57345 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
57346 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
57347 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
57348 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
57349 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
57350 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57351 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
57352 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
57353 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
57354 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
57355 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
57356 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
57357 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
57358 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
57359 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
57360 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
57361 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
57362 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
57363 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
57364 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
57365 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
57366 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
57367 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
57368 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
57369 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
57370 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
57371 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
57372 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
57373 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
57374 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57375 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57376 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57377 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57378 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
57379 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
57380 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57381 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
57382 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
57383 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
57384 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
57385 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
57386 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57387 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57388 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
57389 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
57390 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
57391 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57392 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
57393 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57394 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
57395 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
57396 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
57397 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
57398 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57399 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
57400 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57401 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
57402 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57403 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
57404 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
57405 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57406 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
57407 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
57408 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
57409 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
57410 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
57411 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
57412 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
57413 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57414 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57415 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
57416 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
57417 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
57418 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
57419 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
57420 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
57421 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
57422 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
57423 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57424 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57425 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
57426 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57427 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57428 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57429 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57430 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
57431 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
57432 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
57433 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
57434 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
57435 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
57436 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57437 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
57438 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57439 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57440 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57441 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57442 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
57443 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
57444 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57445 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57446 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
57447 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
57448 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
57449 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
57450 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
57451 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
57452 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
57453 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
57454 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
57455 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
57456 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
57457 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
57458 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
57459 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
57460 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
57461 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
57462 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
57463 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57464 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
57465 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
57466 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57467 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57468 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57469 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57470 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57471 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
57472 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
57473 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
57474 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
57475 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57476 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
57477 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
57478 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57479 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
57480 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57481 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
57482 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
57483 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
57484 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
57485 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
57486 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
57487 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57488 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57489 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
57490 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
57491 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
57492 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
57493 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
57494 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
57495 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
57496 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
57497 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
57498 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57499 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
57500 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
57501 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
57502 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
57503 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57504 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57505 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57506 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57507 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
57508 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
57509 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57510 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
57511 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
57512 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
57513 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
57514 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
57515 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
57516 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
57517 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
57518 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57519 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
57520 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
57521 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
57522 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
57523 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
57524 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
57525 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
57526 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57527 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
57528 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
57529 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
57530 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
57531 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57532 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
57533 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
57534 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57535 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
57536 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
57537 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
57538 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
57539 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
57540 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
57541 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
57542 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57543 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57544 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57545 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
57546 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
57547 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
57548 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
57549 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
57550 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
57551 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
57552 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
57553 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57554 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
57555 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
57556 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
57557 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
57558 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
57559 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57560 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
57561 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
57562 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
57563 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57564 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
57565 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57566 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57567 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57568 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57569 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
57570 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57571 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57572 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
57573 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57574 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
57575 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57576 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57577 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57578 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57579 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
57580 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57581 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57582 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57583 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57584 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
57585 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57586 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
57587 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
57588 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
57589 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
57590 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
57591 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
57592 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
57593 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57594 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57595 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57596 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57597 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57598 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57599 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57600 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57601 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57602 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57603 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
57604 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
57605 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57606 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
57607 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57608 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
57609 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
57610 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
57611 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
57612 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57613 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
57614 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
57615 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
57616 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
57617 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
57618 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
57619 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
57620 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57621 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57622 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
57623 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57624 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57625 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57626 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
57627 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
57628 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57629 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57630 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57631 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57632 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57633 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57634 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57635 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57636 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57637 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57638 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57639 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57640 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57641 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
57642 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
57643 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57644 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
57645 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
57646 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57647 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
57648 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
57649 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
57650 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57651 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
57652 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
57653 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57654 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57655 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
57656 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
57657 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57658 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
57659 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
57660 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
57661 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
57662 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
57663 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
57664 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
57665 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
57666 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57667 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
57668 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57669 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
57670 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57671 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
57672 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
57673 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
57674 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
57675 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
57676 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
57677 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57678 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
57679 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57680 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
57681 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
57682 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
57683 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57684 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
57685 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
57686 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57687 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
57688 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57689 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
57690 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
57691 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
57692 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
57693 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
57694 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
57695 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
57696 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
57697 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
57698 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57699 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
57700 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
57701 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
57702 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57703 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
57704 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
57705 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57706 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
57707 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57708 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
57709 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57710 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57711 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57712 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
57713 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
57714 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
57715 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
57716 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57717 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
57718 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57719 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
57720 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57721 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
57722 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
57723 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
57724 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
57725 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
57726 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
57727 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57728 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57729 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57730 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
57731 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
57732 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
57733 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
57734 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57735 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
57736 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
57737 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
57738 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
57739 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
57740 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
57741 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
57742 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
57743 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
57744 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
57745 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
57746 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
57747 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
57748 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57749 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
57750 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
57751 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
57752 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
57753 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57754 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
57755 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57756 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
57757 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57758 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57759 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
57760 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
57761 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
57762 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
57763 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
57764 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
57765 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
57766 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57767 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57768 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57769 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57770 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57771 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
57772 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
57773 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57774 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
57775 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57776 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
57777 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57778 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
57779 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57780 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57781 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57782 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57783 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57784 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
57785 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
57786 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
57787 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
57788 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
57789 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
57790 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
57791 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
57792 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57793 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57794 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
57795 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
57796 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
57797 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57798 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
57799 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
57800 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
57801 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
57802 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57803 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
57804 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
57805 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57806 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
57807 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57808 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
57809 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
57810 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57811 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
57812 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
57813 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
57814 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57815 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
57816 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
57817 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
57818 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
57819 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
57820 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
57821 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
57822 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
57823 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
57824 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
57825 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57826 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57827 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57828 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57829 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57830 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57831 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
57832 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
57833 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
57834 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
57835 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
57836 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
57837 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
57838 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
57839 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
57840 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
57841 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57842 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57843 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
57844 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
57845 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
57846 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
57847 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
57848 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
57849 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
57850 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
57851 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57852 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
57853 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
57854 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
57855 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
57856 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
57857 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57858 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57859 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57860 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
57861 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
57862 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
57863 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57864 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
57865 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
57866 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
57867 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
57868 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
57869 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57870 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57871 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57872 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
57873 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
57874 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
57875 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
57876 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
57877 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57878 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57879 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57880 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
57881 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
57882 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
57883 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57884 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57885 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
57886 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
57887 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
57888 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57889 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
57890 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
57891 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57892 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57893 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57894 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57895 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
57896 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57897 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
57898 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
57899 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
57900 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
57901 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
57902 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57903 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57904 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
57905 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
57906 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
57907 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
57908 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57909 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
57910 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
57911 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
57912 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
57913 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57914 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
57915 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
57916 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
57917 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
57918 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
57919 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
57920 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57921 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
57922 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
57923 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
57924 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
57925 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
57926 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
57927 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
57928 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
57929 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
57930 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
57931 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
57932 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
57933 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57934 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
57935 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
57936 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
57937 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
57938 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
57939 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
57940 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
57941 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
57942 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
57943 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
57944 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
57945 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57946 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
57947 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
57948 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
57949 { NULL, NULL, 0, NULL }
57950 };
57951
57952
57953 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
57954
57955 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
57956 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
57957 }
57958 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
57959 return (void *)((wxSizer *) ((wxBoxSizer *) x));
57960 }
57961 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
57962 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
57963 }
57964 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
57965 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
57966 }
57967 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
57968 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
57969 }
57970 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
57971 return (void *)((wxSizer *) ((wxGridSizer *) x));
57972 }
57973 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
57974 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
57975 }
57976 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
57977 return (void *)((wxSizer *) ((wxPySizer *) x));
57978 }
57979 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
57980 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
57981 }
57982 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
57983 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
57984 }
57985 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
57986 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
57987 }
57988 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
57989 return (void *)((wxEvent *) ((wxMenuEvent *) x));
57990 }
57991 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
57992 return (void *)((wxEvent *) ((wxCloseEvent *) x));
57993 }
57994 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
57995 return (void *)((wxEvent *) ((wxMouseEvent *) x));
57996 }
57997 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
57998 return (void *)((wxEvent *) ((wxEraseEvent *) x));
57999 }
58000 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
58001 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
58002 }
58003 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
58004 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
58005 }
58006 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
58007 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
58008 }
58009 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
58010 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
58011 }
58012 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
58013 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
58014 }
58015 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
58016 return (void *)((wxEvent *) ((wxPyEvent *) x));
58017 }
58018 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
58019 return (void *)((wxEvent *) ((wxIdleEvent *) x));
58020 }
58021 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
58022 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
58023 }
58024 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
58025 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
58026 }
58027 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
58028 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
58029 }
58030 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
58031 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
58032 }
58033 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
58034 return (void *)((wxEvent *) ((wxActivateEvent *) x));
58035 }
58036 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
58037 return (void *)((wxEvent *) ((wxSizeEvent *) x));
58038 }
58039 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
58040 return (void *)((wxEvent *) ((wxMoveEvent *) x));
58041 }
58042 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
58043 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
58044 }
58045 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
58046 return (void *)((wxEvent *) ((wxPaintEvent *) x));
58047 }
58048 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
58049 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
58050 }
58051 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
58052 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
58053 }
58054 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
58055 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
58056 }
58057 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
58058 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
58059 }
58060 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
58061 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
58062 }
58063 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
58064 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58065 }
58066 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
58067 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
58068 }
58069 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
58070 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
58071 }
58072 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
58073 return (void *)((wxEvent *) ((wxFocusEvent *) x));
58074 }
58075 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
58076 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
58077 }
58078 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
58079 return (void *)((wxEvent *) ((wxShowEvent *) x));
58080 }
58081 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
58082 return (void *)((wxEvent *) ((wxCommandEvent *) x));
58083 }
58084 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
58085 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
58086 }
58087 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
58088 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58089 }
58090 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
58091 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
58092 }
58093 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
58094 return (void *)((wxEvent *) ((wxKeyEvent *) x));
58095 }
58096 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
58097 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
58098 }
58099 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
58100 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
58101 }
58102 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
58103 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
58104 }
58105 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
58106 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
58107 }
58108 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
58109 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
58110 }
58111 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
58112 return (void *)((wxControl *) ((wxControlWithItems *) x));
58113 }
58114 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
58115 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
58116 }
58117 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
58118 return (void *)((wxEvtHandler *) ((wxWindow *) x));
58119 }
58120 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
58121 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58122 }
58123 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
58124 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
58125 }
58126 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
58127 return (void *)((wxEvtHandler *) ((wxValidator *) x));
58128 }
58129 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
58130 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
58131 }
58132 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
58133 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
58134 }
58135 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
58136 return (void *)((wxEvtHandler *) ((wxMenu *) x));
58137 }
58138 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
58139 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
58140 }
58141 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
58142 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
58143 }
58144 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
58145 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
58146 }
58147 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
58148 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
58149 }
58150 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
58151 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
58152 }
58153 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
58154 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58155 }
58156 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
58157 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
58158 }
58159 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
58160 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
58161 }
58162 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
58163 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
58164 }
58165 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
58166 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58167 }
58168 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
58169 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58170 }
58171 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
58172 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
58173 }
58174 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
58175 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
58176 }
58177 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
58178 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
58179 }
58180 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
58181 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
58182 }
58183 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
58184 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
58185 }
58186 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
58187 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
58188 }
58189 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
58190 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
58191 }
58192 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
58193 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
58194 }
58195 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
58196 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
58197 }
58198 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
58199 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
58200 }
58201 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
58202 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
58203 }
58204 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
58205 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
58206 }
58207 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
58208 return (void *)((wxObject *) ((wxSizerItem *) x));
58209 }
58210 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
58211 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
58212 }
58213 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
58214 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
58215 }
58216 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
58217 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
58218 }
58219 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
58220 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
58221 }
58222 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
58223 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
58224 }
58225 static void *_p_wxSizerTo_p_wxObject(void *x) {
58226 return (void *)((wxObject *) ((wxSizer *) x));
58227 }
58228 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
58229 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58230 }
58231 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
58232 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
58233 }
58234 static void *_p_wxEventTo_p_wxObject(void *x) {
58235 return (void *)((wxObject *) ((wxEvent *) x));
58236 }
58237 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
58238 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
58239 }
58240 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
58241 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
58242 }
58243 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
58244 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
58245 }
58246 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
58247 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
58248 }
58249 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
58250 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
58251 }
58252 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
58253 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
58254 }
58255 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
58256 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
58257 }
58258 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
58259 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
58260 }
58261 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
58262 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58263 }
58264 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
58265 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
58266 }
58267 static void *_p_wxControlTo_p_wxObject(void *x) {
58268 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
58269 }
58270 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
58271 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
58272 }
58273 static void *_p_wxFSFileTo_p_wxObject(void *x) {
58274 return (void *)((wxObject *) ((wxFSFile *) x));
58275 }
58276 static void *_p_wxPySizerTo_p_wxObject(void *x) {
58277 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
58278 }
58279 static void *_p_wxPyEventTo_p_wxObject(void *x) {
58280 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
58281 }
58282 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
58283 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
58284 }
58285 static void *_p_wxShowEventTo_p_wxObject(void *x) {
58286 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
58287 }
58288 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
58289 return (void *)((wxObject *) ((wxMenuItem *) x));
58290 }
58291 static void *_p_wxDateEventTo_p_wxObject(void *x) {
58292 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
58293 }
58294 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
58295 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
58296 }
58297 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
58298 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
58299 }
58300 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
58301 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
58302 }
58303 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
58304 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
58305 }
58306 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
58307 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
58308 }
58309 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
58310 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
58311 }
58312 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
58313 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
58314 }
58315 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
58316 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
58317 }
58318 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
58319 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
58320 }
58321 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
58322 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
58323 }
58324 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
58325 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
58326 }
58327 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
58328 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
58329 }
58330 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
58331 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
58332 }
58333 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
58334 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58335 }
58336 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
58337 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58338 }
58339 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
58340 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
58341 }
58342 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
58343 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
58344 }
58345 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
58346 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
58347 }
58348 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
58349 return (void *)((wxObject *) ((wxImageHandler *) x));
58350 }
58351 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
58352 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
58353 }
58354 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
58355 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
58356 }
58357 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
58358 return (void *)((wxObject *) ((wxEvtHandler *) x));
58359 }
58360 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
58361 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
58362 }
58363 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
58364 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58365 }
58366 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
58367 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
58368 }
58369 static void *_p_wxImageTo_p_wxObject(void *x) {
58370 return (void *)((wxObject *) ((wxImage *) x));
58371 }
58372 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
58373 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
58374 }
58375 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
58376 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58377 }
58378 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
58379 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
58380 }
58381 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
58382 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
58383 }
58384 static void *_p_wxWindowTo_p_wxObject(void *x) {
58385 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
58386 }
58387 static void *_p_wxMenuTo_p_wxObject(void *x) {
58388 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
58389 }
58390 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
58391 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
58392 }
58393 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
58394 return (void *)((wxObject *) ((wxFileSystem *) x));
58395 }
58396 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
58397 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
58398 }
58399 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
58400 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
58401 }
58402 static void *_p_wxPyAppTo_p_wxObject(void *x) {
58403 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
58404 }
58405 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
58406 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
58407 }
58408 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
58409 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
58410 }
58411 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
58412 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
58413 }
58414 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
58415 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
58416 }
58417 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
58418 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
58419 }
58420 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
58421 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
58422 }
58423 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
58424 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
58425 }
58426 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
58427 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
58428 }
58429 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
58430 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58431 }
58432 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
58433 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
58434 }
58435 static void *_p_wxValidatorTo_p_wxObject(void *x) {
58436 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
58437 }
58438 static void *_p_wxControlTo_p_wxWindow(void *x) {
58439 return (void *)((wxWindow *) ((wxControl *) x));
58440 }
58441 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
58442 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
58443 }
58444 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
58445 return (void *)((wxWindow *) ((wxMenuBar *) x));
58446 }
58447 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
58448 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
58449 }
58450 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
58451 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
58452 }
58453 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
58454 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
58455 }
58456 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
58457 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
58458 }
58459 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
58460 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
58461 }
58462 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
58463 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
58464 }
58465 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
58466 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58467 }
58468 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
58469 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
58470 }
58471 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
58472 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
58473 }
58474 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
58475 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
58476 }
58477 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
58478 return (void *)((wxValidator *) ((wxPyValidator *) x));
58479 }
58480 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
58481 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
58482 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};
58483 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
58484 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
58485 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
58486 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
58487 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
58488 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
58489 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
58490 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
58491 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
58492 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
58493 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
58494 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
58495 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
58496 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
58497 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
58498 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
58499 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
58500 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
58501 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
58502 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
58503 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
58504 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
58505 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
58506 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
58507 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
58508 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
58509 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
58510 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
58511 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
58512 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
58513 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
58514 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
58515 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
58516 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
58517 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
58518 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
58519 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
58520 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
58521 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
58522 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
58523 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
58524 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
58525 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
58526 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
58527 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
58528 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
58529 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
58530 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
58531 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
58532 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
58533 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
58534 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
58535 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
58536 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
58537 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
58538 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
58539 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
58540 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
58541 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
58542 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
58543 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
58544 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
58545 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
58546 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
58547 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
58548 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
58549 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
58550 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
58551 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
58552 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
58553 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
58554 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
58555 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
58556 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
58557 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
58558 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
58559 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
58560 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
58561 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
58562 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
58563 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
58564 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
58565 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
58566 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
58567 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
58568 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
58569 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
58570 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
58571 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
58572 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
58573 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
58574 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
58575 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
58576 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
58577 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
58578 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
58579 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
58580 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
58581 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
58582 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
58583 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
58584 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
58585 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
58586 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
58587 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
58588 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
58589 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
58590 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
58591 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
58592 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
58593 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
58594 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
58595 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
58596 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
58597 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
58598 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
58599 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
58600 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
58601 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
58602 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
58603 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
58604 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
58605 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
58606 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
58607 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
58608 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
58609 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
58610 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
58611 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
58612 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
58613 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
58614
58615 static swig_type_info *swig_type_initial[] = {
58616 &_swigt__p_buffer,
58617 &_swigt__p_char,
58618 &_swigt__p_form_ops_t,
58619 &_swigt__p_int,
58620 &_swigt__p_long,
58621 &_swigt__p_unsigned_char,
58622 &_swigt__p_unsigned_int,
58623 &_swigt__p_unsigned_long,
58624 &_swigt__p_wxANIHandler,
58625 &_swigt__p_wxAcceleratorEntry,
58626 &_swigt__p_wxAcceleratorTable,
58627 &_swigt__p_wxActivateEvent,
58628 &_swigt__p_wxAppTraits,
58629 &_swigt__p_wxArrayString,
58630 &_swigt__p_wxBMPHandler,
58631 &_swigt__p_wxBitmap,
58632 &_swigt__p_wxBoxSizer,
58633 &_swigt__p_wxButton,
58634 &_swigt__p_wxCURHandler,
58635 &_swigt__p_wxCaret,
58636 &_swigt__p_wxChildFocusEvent,
58637 &_swigt__p_wxClipboardTextEvent,
58638 &_swigt__p_wxCloseEvent,
58639 &_swigt__p_wxColour,
58640 &_swigt__p_wxCommandEvent,
58641 &_swigt__p_wxContextMenuEvent,
58642 &_swigt__p_wxControl,
58643 &_swigt__p_wxControlWithItems,
58644 &_swigt__p_wxCursor,
58645 &_swigt__p_wxDC,
58646 &_swigt__p_wxDateEvent,
58647 &_swigt__p_wxDateTime,
58648 &_swigt__p_wxDisplayChangedEvent,
58649 &_swigt__p_wxDouble,
58650 &_swigt__p_wxDropFilesEvent,
58651 &_swigt__p_wxDuplexMode,
58652 &_swigt__p_wxEraseEvent,
58653 &_swigt__p_wxEvent,
58654 &_swigt__p_wxEventLoop,
58655 &_swigt__p_wxEventLoopActivator,
58656 &_swigt__p_wxEvtHandler,
58657 &_swigt__p_wxFSFile,
58658 &_swigt__p_wxFileSystem,
58659 &_swigt__p_wxFileSystemHandler,
58660 &_swigt__p_wxFlexGridSizer,
58661 &_swigt__p_wxFocusEvent,
58662 &_swigt__p_wxFont,
58663 &_swigt__p_wxFrame,
58664 &_swigt__p_wxGBPosition,
58665 &_swigt__p_wxGBSizerItem,
58666 &_swigt__p_wxGBSpan,
58667 &_swigt__p_wxGIFHandler,
58668 &_swigt__p_wxGridBagSizer,
58669 &_swigt__p_wxGridSizer,
58670 &_swigt__p_wxHelpEvent__Origin,
58671 &_swigt__p_wxICOHandler,
58672 &_swigt__p_wxIconizeEvent,
58673 &_swigt__p_wxIdleEvent,
58674 &_swigt__p_wxImage,
58675 &_swigt__p_wxImageHandler,
58676 &_swigt__p_wxImageHistogram,
58677 &_swigt__p_wxImage_HSVValue,
58678 &_swigt__p_wxImage_RGBValue,
58679 &_swigt__p_wxIndividualLayoutConstraint,
58680 &_swigt__p_wxInitDialogEvent,
58681 &_swigt__p_wxInputStream,
58682 &_swigt__p_wxInternetFSHandler,
58683 &_swigt__p_wxItemContainer,
58684 &_swigt__p_wxJPEGHandler,
58685 &_swigt__p_wxKeyEvent,
58686 &_swigt__p_wxLayoutConstraints,
58687 &_swigt__p_wxMaximizeEvent,
58688 &_swigt__p_wxMemoryFSHandler,
58689 &_swigt__p_wxMenu,
58690 &_swigt__p_wxMenuBar,
58691 &_swigt__p_wxMenuBarBase,
58692 &_swigt__p_wxMenuEvent,
58693 &_swigt__p_wxMenuItem,
58694 &_swigt__p_wxMouseCaptureChangedEvent,
58695 &_swigt__p_wxMouseCaptureLostEvent,
58696 &_swigt__p_wxMouseEvent,
58697 &_swigt__p_wxMoveEvent,
58698 &_swigt__p_wxNavigationKeyEvent,
58699 &_swigt__p_wxNcPaintEvent,
58700 &_swigt__p_wxNotifyEvent,
58701 &_swigt__p_wxObject,
58702 &_swigt__p_wxOutputStream,
58703 &_swigt__p_wxPCXHandler,
58704 &_swigt__p_wxPNGHandler,
58705 &_swigt__p_wxPNMHandler,
58706 &_swigt__p_wxPaintEvent,
58707 &_swigt__p_wxPaletteChangedEvent,
58708 &_swigt__p_wxPaperSize,
58709 &_swigt__p_wxPoint,
58710 &_swigt__p_wxPoint2D,
58711 &_swigt__p_wxPropagateOnce,
58712 &_swigt__p_wxPropagationDisabler,
58713 &_swigt__p_wxPyApp,
58714 &_swigt__p_wxPyCommandEvent,
58715 &_swigt__p_wxPyDropTarget,
58716 &_swigt__p_wxPyEvent,
58717 &_swigt__p_wxPyFileSystemHandler,
58718 &_swigt__p_wxPyImageHandler,
58719 &_swigt__p_wxPyInputStream,
58720 &_swigt__p_wxPySizer,
58721 &_swigt__p_wxPyValidator,
58722 &_swigt__p_wxQuantize,
58723 &_swigt__p_wxQueryNewPaletteEvent,
58724 &_swigt__p_wxRealPoint,
58725 &_swigt__p_wxRect,
58726 &_swigt__p_wxRect2D,
58727 &_swigt__p_wxRegion,
58728 &_swigt__p_wxScrollEvent,
58729 &_swigt__p_wxScrollWinEvent,
58730 &_swigt__p_wxSetCursorEvent,
58731 &_swigt__p_wxShowEvent,
58732 &_swigt__p_wxSize,
58733 &_swigt__p_wxSizeEvent,
58734 &_swigt__p_wxSizer,
58735 &_swigt__p_wxSizerItem,
58736 &_swigt__p_wxStaticBox,
58737 &_swigt__p_wxStaticBoxSizer,
58738 &_swigt__p_wxStdDialogButtonSizer,
58739 &_swigt__p_wxSysColourChangedEvent,
58740 &_swigt__p_wxTIFFHandler,
58741 &_swigt__p_wxToolTip,
58742 &_swigt__p_wxUpdateUIEvent,
58743 &_swigt__p_wxValidator,
58744 &_swigt__p_wxVisualAttributes,
58745 &_swigt__p_wxWindow,
58746 &_swigt__p_wxWindowCreateEvent,
58747 &_swigt__p_wxWindowDestroyEvent,
58748 &_swigt__p_wxXPMHandler,
58749 &_swigt__p_wxZipFSHandler,
58750 };
58751
58752 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
58753 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
58754 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
58755 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
58756 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
58757 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
58758 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
58759 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
58760 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
58761 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
58762 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
58763 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
58764 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
58765 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
58766 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}};
58767 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
58768 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}};
58769 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
58770 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}};
58771 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
58772 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58773 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
58774 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
58775 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
58776 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}};
58777 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58778 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}};
58779 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
58780 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
58781 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
58782 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
58783 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
58784 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58785 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
58786 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
58787 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
58788 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
58789 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}};
58790 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
58791 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
58792 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}};
58793 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
58794 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
58795 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}};
58796 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}};
58797 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58798 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
58799 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
58800 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
58801 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
58802 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
58803 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
58804 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
58805 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}};
58806 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
58807 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}};
58808 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58809 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
58810 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
58811 static swig_cast_info _swigc__p_wxImageHandler[] = { {&_swigt__p_wxImageHandler, 0, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxImageHandler, 0, 0},{0, 0, 0, 0}};
58812 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
58813 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
58814 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
58815 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
58816 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
58817 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
58818 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58819 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}};
58820 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
58821 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58822 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
58823 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58824 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58825 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
58826 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
58827 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
58828 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58829 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
58830 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58831 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
58832 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
58833 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
58834 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58835 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58836 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
58837 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
58838 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
58839 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
58840 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
58841 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
58842 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58843 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58844 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
58845 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
58846 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
58847 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
58848 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
58849 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
58850 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
58851 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
58852 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
58853 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
58854 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58855 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
58856 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
58857 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
58858 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
58859 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
58860 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
58861 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
58862 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
58863 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
58864 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
58865 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
58866 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
58867 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
58868 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
58869 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58870 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}};
58871 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}};
58872 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
58873 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
58874 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
58875 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58876 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
58877 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
58878 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
58879 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}};
58880 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
58881 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}};
58882 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
58883 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
58884 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
58885 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58886
58887 static swig_cast_info *swig_cast_initial[] = {
58888 _swigc__p_buffer,
58889 _swigc__p_char,
58890 _swigc__p_form_ops_t,
58891 _swigc__p_int,
58892 _swigc__p_long,
58893 _swigc__p_unsigned_char,
58894 _swigc__p_unsigned_int,
58895 _swigc__p_unsigned_long,
58896 _swigc__p_wxANIHandler,
58897 _swigc__p_wxAcceleratorEntry,
58898 _swigc__p_wxAcceleratorTable,
58899 _swigc__p_wxActivateEvent,
58900 _swigc__p_wxAppTraits,
58901 _swigc__p_wxArrayString,
58902 _swigc__p_wxBMPHandler,
58903 _swigc__p_wxBitmap,
58904 _swigc__p_wxBoxSizer,
58905 _swigc__p_wxButton,
58906 _swigc__p_wxCURHandler,
58907 _swigc__p_wxCaret,
58908 _swigc__p_wxChildFocusEvent,
58909 _swigc__p_wxClipboardTextEvent,
58910 _swigc__p_wxCloseEvent,
58911 _swigc__p_wxColour,
58912 _swigc__p_wxCommandEvent,
58913 _swigc__p_wxContextMenuEvent,
58914 _swigc__p_wxControl,
58915 _swigc__p_wxControlWithItems,
58916 _swigc__p_wxCursor,
58917 _swigc__p_wxDC,
58918 _swigc__p_wxDateEvent,
58919 _swigc__p_wxDateTime,
58920 _swigc__p_wxDisplayChangedEvent,
58921 _swigc__p_wxDouble,
58922 _swigc__p_wxDropFilesEvent,
58923 _swigc__p_wxDuplexMode,
58924 _swigc__p_wxEraseEvent,
58925 _swigc__p_wxEvent,
58926 _swigc__p_wxEventLoop,
58927 _swigc__p_wxEventLoopActivator,
58928 _swigc__p_wxEvtHandler,
58929 _swigc__p_wxFSFile,
58930 _swigc__p_wxFileSystem,
58931 _swigc__p_wxFileSystemHandler,
58932 _swigc__p_wxFlexGridSizer,
58933 _swigc__p_wxFocusEvent,
58934 _swigc__p_wxFont,
58935 _swigc__p_wxFrame,
58936 _swigc__p_wxGBPosition,
58937 _swigc__p_wxGBSizerItem,
58938 _swigc__p_wxGBSpan,
58939 _swigc__p_wxGIFHandler,
58940 _swigc__p_wxGridBagSizer,
58941 _swigc__p_wxGridSizer,
58942 _swigc__p_wxHelpEvent__Origin,
58943 _swigc__p_wxICOHandler,
58944 _swigc__p_wxIconizeEvent,
58945 _swigc__p_wxIdleEvent,
58946 _swigc__p_wxImage,
58947 _swigc__p_wxImageHandler,
58948 _swigc__p_wxImageHistogram,
58949 _swigc__p_wxImage_HSVValue,
58950 _swigc__p_wxImage_RGBValue,
58951 _swigc__p_wxIndividualLayoutConstraint,
58952 _swigc__p_wxInitDialogEvent,
58953 _swigc__p_wxInputStream,
58954 _swigc__p_wxInternetFSHandler,
58955 _swigc__p_wxItemContainer,
58956 _swigc__p_wxJPEGHandler,
58957 _swigc__p_wxKeyEvent,
58958 _swigc__p_wxLayoutConstraints,
58959 _swigc__p_wxMaximizeEvent,
58960 _swigc__p_wxMemoryFSHandler,
58961 _swigc__p_wxMenu,
58962 _swigc__p_wxMenuBar,
58963 _swigc__p_wxMenuBarBase,
58964 _swigc__p_wxMenuEvent,
58965 _swigc__p_wxMenuItem,
58966 _swigc__p_wxMouseCaptureChangedEvent,
58967 _swigc__p_wxMouseCaptureLostEvent,
58968 _swigc__p_wxMouseEvent,
58969 _swigc__p_wxMoveEvent,
58970 _swigc__p_wxNavigationKeyEvent,
58971 _swigc__p_wxNcPaintEvent,
58972 _swigc__p_wxNotifyEvent,
58973 _swigc__p_wxObject,
58974 _swigc__p_wxOutputStream,
58975 _swigc__p_wxPCXHandler,
58976 _swigc__p_wxPNGHandler,
58977 _swigc__p_wxPNMHandler,
58978 _swigc__p_wxPaintEvent,
58979 _swigc__p_wxPaletteChangedEvent,
58980 _swigc__p_wxPaperSize,
58981 _swigc__p_wxPoint,
58982 _swigc__p_wxPoint2D,
58983 _swigc__p_wxPropagateOnce,
58984 _swigc__p_wxPropagationDisabler,
58985 _swigc__p_wxPyApp,
58986 _swigc__p_wxPyCommandEvent,
58987 _swigc__p_wxPyDropTarget,
58988 _swigc__p_wxPyEvent,
58989 _swigc__p_wxPyFileSystemHandler,
58990 _swigc__p_wxPyImageHandler,
58991 _swigc__p_wxPyInputStream,
58992 _swigc__p_wxPySizer,
58993 _swigc__p_wxPyValidator,
58994 _swigc__p_wxQuantize,
58995 _swigc__p_wxQueryNewPaletteEvent,
58996 _swigc__p_wxRealPoint,
58997 _swigc__p_wxRect,
58998 _swigc__p_wxRect2D,
58999 _swigc__p_wxRegion,
59000 _swigc__p_wxScrollEvent,
59001 _swigc__p_wxScrollWinEvent,
59002 _swigc__p_wxSetCursorEvent,
59003 _swigc__p_wxShowEvent,
59004 _swigc__p_wxSize,
59005 _swigc__p_wxSizeEvent,
59006 _swigc__p_wxSizer,
59007 _swigc__p_wxSizerItem,
59008 _swigc__p_wxStaticBox,
59009 _swigc__p_wxStaticBoxSizer,
59010 _swigc__p_wxStdDialogButtonSizer,
59011 _swigc__p_wxSysColourChangedEvent,
59012 _swigc__p_wxTIFFHandler,
59013 _swigc__p_wxToolTip,
59014 _swigc__p_wxUpdateUIEvent,
59015 _swigc__p_wxValidator,
59016 _swigc__p_wxVisualAttributes,
59017 _swigc__p_wxWindow,
59018 _swigc__p_wxWindowCreateEvent,
59019 _swigc__p_wxWindowDestroyEvent,
59020 _swigc__p_wxXPMHandler,
59021 _swigc__p_wxZipFSHandler,
59022 };
59023
59024
59025 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
59026
59027 static swig_const_info swig_const_table[] = {
59028 {0, 0, 0, 0.0, 0, 0}};
59029
59030 #ifdef __cplusplus
59031 }
59032 #endif
59033 /* -----------------------------------------------------------------------------
59034 * Type initialization:
59035 * This problem is tough by the requirement that no dynamic
59036 * memory is used. Also, since swig_type_info structures store pointers to
59037 * swig_cast_info structures and swig_cast_info structures store pointers back
59038 * to swig_type_info structures, we need some lookup code at initialization.
59039 * The idea is that swig generates all the structures that are needed.
59040 * The runtime then collects these partially filled structures.
59041 * The SWIG_InitializeModule function takes these initial arrays out of
59042 * swig_module, and does all the lookup, filling in the swig_module.types
59043 * array with the correct data and linking the correct swig_cast_info
59044 * structures together.
59045 *
59046 * The generated swig_type_info structures are assigned staticly to an initial
59047 * array. We just loop though that array, and handle each type individually.
59048 * First we lookup if this type has been already loaded, and if so, use the
59049 * loaded structure instead of the generated one. Then we have to fill in the
59050 * cast linked list. The cast data is initially stored in something like a
59051 * two-dimensional array. Each row corresponds to a type (there are the same
59052 * number of rows as there are in the swig_type_initial array). Each entry in
59053 * a column is one of the swig_cast_info structures for that type.
59054 * The cast_initial array is actually an array of arrays, because each row has
59055 * a variable number of columns. So to actually build the cast linked list,
59056 * we find the array of casts associated with the type, and loop through it
59057 * adding the casts to the list. The one last trick we need to do is making
59058 * sure the type pointer in the swig_cast_info struct is correct.
59059 *
59060 * First off, we lookup the cast->type name to see if it is already loaded.
59061 * There are three cases to handle:
59062 * 1) If the cast->type has already been loaded AND the type we are adding
59063 * casting info to has not been loaded (it is in this module), THEN we
59064 * replace the cast->type pointer with the type pointer that has already
59065 * been loaded.
59066 * 2) If BOTH types (the one we are adding casting info to, and the
59067 * cast->type) are loaded, THEN the cast info has already been loaded by
59068 * the previous module so we just ignore it.
59069 * 3) Finally, if cast->type has not already been loaded, then we add that
59070 * swig_cast_info to the linked list (because the cast->type) pointer will
59071 * be correct.
59072 * ----------------------------------------------------------------------------- */
59073
59074 #ifdef __cplusplus
59075 extern "C" {
59076 #if 0
59077 } /* c-mode */
59078 #endif
59079 #endif
59080
59081 #if 0
59082 #define SWIGRUNTIME_DEBUG
59083 #endif
59084
59085 SWIGRUNTIME void
59086 SWIG_InitializeModule(void *clientdata) {
59087 size_t i;
59088 swig_module_info *module_head;
59089 static int init_run = 0;
59090
59091 clientdata = clientdata;
59092
59093 if (init_run) return;
59094 init_run = 1;
59095
59096 /* Initialize the swig_module */
59097 swig_module.type_initial = swig_type_initial;
59098 swig_module.cast_initial = swig_cast_initial;
59099
59100 /* Try and load any already created modules */
59101 module_head = SWIG_GetModule(clientdata);
59102 if (module_head) {
59103 swig_module.next = module_head->next;
59104 module_head->next = &swig_module;
59105 } else {
59106 /* This is the first module loaded */
59107 swig_module.next = &swig_module;
59108 SWIG_SetModule(clientdata, &swig_module);
59109 }
59110
59111 /* Now work on filling in swig_module.types */
59112 #ifdef SWIGRUNTIME_DEBUG
59113 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
59114 #endif
59115 for (i = 0; i < swig_module.size; ++i) {
59116 swig_type_info *type = 0;
59117 swig_type_info *ret;
59118 swig_cast_info *cast;
59119
59120 #ifdef SWIGRUNTIME_DEBUG
59121 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59122 #endif
59123
59124 /* if there is another module already loaded */
59125 if (swig_module.next != &swig_module) {
59126 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
59127 }
59128 if (type) {
59129 /* Overwrite clientdata field */
59130 #ifdef SWIGRUNTIME_DEBUG
59131 printf("SWIG_InitializeModule: found type %s\n", type->name);
59132 #endif
59133 if (swig_module.type_initial[i]->clientdata) {
59134 type->clientdata = swig_module.type_initial[i]->clientdata;
59135 #ifdef SWIGRUNTIME_DEBUG
59136 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
59137 #endif
59138 }
59139 } else {
59140 type = swig_module.type_initial[i];
59141 }
59142
59143 /* Insert casting types */
59144 cast = swig_module.cast_initial[i];
59145 while (cast->type) {
59146 /* Don't need to add information already in the list */
59147 ret = 0;
59148 #ifdef SWIGRUNTIME_DEBUG
59149 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
59150 #endif
59151 if (swig_module.next != &swig_module) {
59152 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
59153 #ifdef SWIGRUNTIME_DEBUG
59154 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
59155 #endif
59156 }
59157 if (ret) {
59158 if (type == swig_module.type_initial[i]) {
59159 #ifdef SWIGRUNTIME_DEBUG
59160 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
59161 #endif
59162 cast->type = ret;
59163 ret = 0;
59164 } else {
59165 /* Check for casting already in the list */
59166 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
59167 #ifdef SWIGRUNTIME_DEBUG
59168 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
59169 #endif
59170 if (!ocast) ret = 0;
59171 }
59172 }
59173
59174 if (!ret) {
59175 #ifdef SWIGRUNTIME_DEBUG
59176 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
59177 #endif
59178 if (type->cast) {
59179 type->cast->prev = cast;
59180 cast->next = type->cast;
59181 }
59182 type->cast = cast;
59183 }
59184 cast++;
59185 }
59186 /* Set entry in modules->types array equal to the type */
59187 swig_module.types[i] = type;
59188 }
59189 swig_module.types[i] = 0;
59190
59191 #ifdef SWIGRUNTIME_DEBUG
59192 printf("**** SWIG_InitializeModule: Cast List ******\n");
59193 for (i = 0; i < swig_module.size; ++i) {
59194 int j = 0;
59195 swig_cast_info *cast = swig_module.cast_initial[i];
59196 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59197 while (cast->type) {
59198 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
59199 cast++;
59200 ++j;
59201 }
59202 printf("---- Total casts: %d\n",j);
59203 }
59204 printf("**** SWIG_InitializeModule: Cast List ******\n");
59205 #endif
59206 }
59207
59208 /* This function will propagate the clientdata field of type to
59209 * any new swig_type_info structures that have been added into the list
59210 * of equivalent types. It is like calling
59211 * SWIG_TypeClientData(type, clientdata) a second time.
59212 */
59213 SWIGRUNTIME void
59214 SWIG_PropagateClientData(void) {
59215 size_t i;
59216 swig_cast_info *equiv;
59217 static int init_run = 0;
59218
59219 if (init_run) return;
59220 init_run = 1;
59221
59222 for (i = 0; i < swig_module.size; i++) {
59223 if (swig_module.types[i]->clientdata) {
59224 equiv = swig_module.types[i]->cast;
59225 while (equiv) {
59226 if (!equiv->converter) {
59227 if (equiv->type && !equiv->type->clientdata)
59228 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
59229 }
59230 equiv = equiv->next;
59231 }
59232 }
59233 }
59234 }
59235
59236 #ifdef __cplusplus
59237 #if 0
59238 {
59239 /* c-mode */
59240 #endif
59241 }
59242 #endif
59243
59244
59245
59246 #ifdef __cplusplus
59247 extern "C" {
59248 #endif
59249
59250 /* Python-specific SWIG API */
59251 #define SWIG_newvarlink() SWIG_Python_newvarlink()
59252 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
59253 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
59254
59255 /* -----------------------------------------------------------------------------
59256 * global variable support code.
59257 * ----------------------------------------------------------------------------- */
59258
59259 typedef struct swig_globalvar {
59260 char *name; /* Name of global variable */
59261 PyObject *(*get_attr)(void); /* Return the current value */
59262 int (*set_attr)(PyObject *); /* Set the value */
59263 struct swig_globalvar *next;
59264 } swig_globalvar;
59265
59266 typedef struct swig_varlinkobject {
59267 PyObject_HEAD
59268 swig_globalvar *vars;
59269 } swig_varlinkobject;
59270
59271 SWIGINTERN PyObject *
59272 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
59273 return PyString_FromString("<Swig global variables>");
59274 }
59275
59276 SWIGINTERN PyObject *
59277 swig_varlink_str(swig_varlinkobject *v) {
59278 PyObject *str = PyString_FromString("(");
59279 swig_globalvar *var;
59280 for (var = v->vars; var; var=var->next) {
59281 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
59282 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
59283 }
59284 PyString_ConcatAndDel(&str,PyString_FromString(")"));
59285 return str;
59286 }
59287
59288 SWIGINTERN int
59289 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
59290 PyObject *str = swig_varlink_str(v);
59291 fprintf(fp,"Swig global variables ");
59292 fprintf(fp,"%s\n", PyString_AsString(str));
59293 Py_DECREF(str);
59294 return 0;
59295 }
59296
59297 SWIGINTERN void
59298 swig_varlink_dealloc(swig_varlinkobject *v) {
59299 swig_globalvar *var = v->vars;
59300 while (var) {
59301 swig_globalvar *n = var->next;
59302 free(var->name);
59303 free(var);
59304 var = n;
59305 }
59306 }
59307
59308 SWIGINTERN PyObject *
59309 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
59310 PyObject *res = NULL;
59311 swig_globalvar *var = v->vars;
59312 while (var) {
59313 if (strcmp(var->name,n) == 0) {
59314 res = (*var->get_attr)();
59315 break;
59316 }
59317 var = var->next;
59318 }
59319 if (res == NULL && !PyErr_Occurred()) {
59320 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59321 }
59322 return res;
59323 }
59324
59325 SWIGINTERN int
59326 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
59327 int res = 1;
59328 swig_globalvar *var = v->vars;
59329 while (var) {
59330 if (strcmp(var->name,n) == 0) {
59331 res = (*var->set_attr)(p);
59332 break;
59333 }
59334 var = var->next;
59335 }
59336 if (res == 1 && !PyErr_Occurred()) {
59337 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59338 }
59339 return res;
59340 }
59341
59342 SWIGINTERN PyTypeObject*
59343 swig_varlink_type(void) {
59344 static char varlink__doc__[] = "Swig var link object";
59345 static PyTypeObject varlink_type;
59346 static int type_init = 0;
59347 if (!type_init) {
59348 const PyTypeObject tmp
59349 = {
59350 PyObject_HEAD_INIT(NULL)
59351 0, /* Number of items in variable part (ob_size) */
59352 (char *)"swigvarlink", /* Type name (tp_name) */
59353 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
59354 0, /* Itemsize (tp_itemsize) */
59355 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
59356 (printfunc) swig_varlink_print, /* Print (tp_print) */
59357 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
59358 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
59359 0, /* tp_compare */
59360 (reprfunc) swig_varlink_repr, /* tp_repr */
59361 0, /* tp_as_number */
59362 0, /* tp_as_sequence */
59363 0, /* tp_as_mapping */
59364 0, /* tp_hash */
59365 0, /* tp_call */
59366 (reprfunc)swig_varlink_str, /* tp_str */
59367 0, /* tp_getattro */
59368 0, /* tp_setattro */
59369 0, /* tp_as_buffer */
59370 0, /* tp_flags */
59371 varlink__doc__, /* tp_doc */
59372 0, /* tp_traverse */
59373 0, /* tp_clear */
59374 0, /* tp_richcompare */
59375 0, /* tp_weaklistoffset */
59376 #if PY_VERSION_HEX >= 0x02020000
59377 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
59378 #endif
59379 #if PY_VERSION_HEX >= 0x02030000
59380 0, /* tp_del */
59381 #endif
59382 #ifdef COUNT_ALLOCS
59383 0,0,0,0 /* tp_alloc -> tp_next */
59384 #endif
59385 };
59386 varlink_type = tmp;
59387 varlink_type.ob_type = &PyType_Type;
59388 type_init = 1;
59389 }
59390 return &varlink_type;
59391 }
59392
59393 /* Create a variable linking object for use later */
59394 SWIGINTERN PyObject *
59395 SWIG_Python_newvarlink(void) {
59396 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
59397 if (result) {
59398 result->vars = 0;
59399 }
59400 return ((PyObject*) result);
59401 }
59402
59403 SWIGINTERN void
59404 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
59405 swig_varlinkobject *v = (swig_varlinkobject *) p;
59406 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
59407 if (gv) {
59408 size_t size = strlen(name)+1;
59409 gv->name = (char *)malloc(size);
59410 if (gv->name) {
59411 strncpy(gv->name,name,size);
59412 gv->get_attr = get_attr;
59413 gv->set_attr = set_attr;
59414 gv->next = v->vars;
59415 }
59416 }
59417 v->vars = gv;
59418 }
59419
59420 SWIGINTERN PyObject *
59421 SWIG_globals() {
59422 static PyObject *_SWIG_globals = 0;
59423 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
59424 return _SWIG_globals;
59425 }
59426
59427 /* -----------------------------------------------------------------------------
59428 * constants/methods manipulation
59429 * ----------------------------------------------------------------------------- */
59430
59431 /* Install Constants */
59432 SWIGINTERN void
59433 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
59434 PyObject *obj = 0;
59435 size_t i;
59436 for (i = 0; constants[i].type; ++i) {
59437 switch(constants[i].type) {
59438 case SWIG_PY_POINTER:
59439 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
59440 break;
59441 case SWIG_PY_BINARY:
59442 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
59443 break;
59444 default:
59445 obj = 0;
59446 break;
59447 }
59448 if (obj) {
59449 PyDict_SetItemString(d, constants[i].name, obj);
59450 Py_DECREF(obj);
59451 }
59452 }
59453 }
59454
59455 /* -----------------------------------------------------------------------------*/
59456 /* Fix SwigMethods to carry the callback ptrs when needed */
59457 /* -----------------------------------------------------------------------------*/
59458
59459 SWIGINTERN void
59460 SWIG_Python_FixMethods(PyMethodDef *methods,
59461 swig_const_info *const_table,
59462 swig_type_info **types,
59463 swig_type_info **types_initial) {
59464 size_t i;
59465 for (i = 0; methods[i].ml_name; ++i) {
59466 const char *c = methods[i].ml_doc;
59467 if (c && (c = strstr(c, "swig_ptr: "))) {
59468 int j;
59469 swig_const_info *ci = 0;
59470 const char *name = c + 10;
59471 for (j = 0; const_table[j].type; ++j) {
59472 if (strncmp(const_table[j].name, name,
59473 strlen(const_table[j].name)) == 0) {
59474 ci = &(const_table[j]);
59475 break;
59476 }
59477 }
59478 if (ci) {
59479 size_t shift = (ci->ptype) - types;
59480 swig_type_info *ty = types_initial[shift];
59481 size_t ldoc = (c - methods[i].ml_doc);
59482 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
59483 char *ndoc = (char*)malloc(ldoc + lptr + 10);
59484 if (ndoc) {
59485 char *buff = ndoc;
59486 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
59487 if (ptr) {
59488 strncpy(buff, methods[i].ml_doc, ldoc);
59489 buff += ldoc;
59490 strncpy(buff, "swig_ptr: ", 10);
59491 buff += 10;
59492 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
59493 methods[i].ml_doc = ndoc;
59494 }
59495 }
59496 }
59497 }
59498 }
59499 }
59500
59501 #ifdef __cplusplus
59502 }
59503 #endif
59504
59505 /* -----------------------------------------------------------------------------*
59506 * Partial Init method
59507 * -----------------------------------------------------------------------------*/
59508
59509 #ifdef __cplusplus
59510 extern "C"
59511 #endif
59512 SWIGEXPORT void SWIG_init(void) {
59513 PyObject *m, *d;
59514
59515 /* Fix SwigMethods to carry the callback ptrs when needed */
59516 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
59517
59518 m = Py_InitModule((char *) SWIG_name, SwigMethods);
59519 d = PyModule_GetDict(m);
59520
59521 SWIG_InitializeModule(0);
59522 SWIG_InstallConstants(d,swig_const_table);
59523
59524
59525
59526 #ifndef wxPyUSE_EXPORT
59527 // Make our API structure a CObject so other modules can import it
59528 // from this module.
59529 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
59530 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
59531 Py_XDECREF(cobj);
59532 #endif
59533
59534 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
59535 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
59536 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
59537 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
59538 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
59539 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
59540 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
59541 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
59542 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
59543 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
59544 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
59545 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
59546 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
59547 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
59548 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
59549 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
59550 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
59551 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
59552 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
59553 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
59554 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
59555 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
59556 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
59557 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
59558 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
59559 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
59560 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
59561 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
59562 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
59563 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
59564 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
59565 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
59566 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
59567 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
59568 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
59569 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
59570 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
59571 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
59572 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
59573 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
59574 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
59575 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
59576 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
59577 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
59578 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
59579 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
59580 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
59581 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
59582 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
59583 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
59584 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
59585 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
59586 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
59587 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
59588 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
59589 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
59590 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
59591 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
59592 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
59593 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
59594 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
59595 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
59596 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
59597 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
59598 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
59599 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
59600 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
59601 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
59602 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
59603 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
59604 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
59605 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
59606 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
59607 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
59608 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
59609 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
59610 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
59611 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
59612 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
59613 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
59614 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
59615 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
59616 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
59617 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
59618 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
59619 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
59620 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
59621 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
59622 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
59623 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
59624 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
59625 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
59626 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
59627 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
59628 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
59629 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
59630 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
59631 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
59632 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
59633 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
59634 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
59635 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
59636 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
59637 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
59638 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
59639 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
59640 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
59641 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
59642 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
59643 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
59644 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
59645 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
59646 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
59647 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
59648 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
59649 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
59650 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
59651 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
59652 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
59653 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
59654 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
59655 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
59656 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
59657 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
59658 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
59659 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
59660 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
59661 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
59662 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
59663 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
59664 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
59665 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
59666 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
59667 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
59668 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
59669 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
59670 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
59671 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
59672 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
59673 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
59674 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
59675 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
59676 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
59677 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
59678 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
59679 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
59680 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
59681 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
59682 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
59683 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
59684 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
59685 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
59686 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
59687 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
59688 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
59689 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
59690 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
59691 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
59692 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
59693 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
59694 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
59695 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
59696 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
59697 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
59698 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
59699 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
59700 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
59701 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
59702 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
59703 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
59704 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
59705 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
59706 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
59707 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
59708 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
59709 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
59710 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
59711 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
59712 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
59713 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
59714 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
59715 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
59716 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
59717 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
59718 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
59719 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
59720 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
59721 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
59722 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
59723 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
59724 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
59725 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
59726 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
59727 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
59728 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
59729 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
59730 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
59731 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
59732 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
59733 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
59734 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
59735 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
59736 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
59737 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
59738 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
59739 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
59740 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
59741 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
59742 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
59743 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
59744 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
59745 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
59746 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
59747 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
59748 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
59749 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
59750 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
59751 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
59752 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
59753 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
59754 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
59755 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
59756 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
59757 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
59758 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
59759 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
59760 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
59761 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
59762 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
59763 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
59764 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
59765 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
59766 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
59767 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
59768 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
59769 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
59770 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
59771 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
59772 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
59773 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
59774 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
59775 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
59776 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
59777 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
59778 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
59779 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
59780 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
59781 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
59782 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
59783 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
59784 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
59785 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
59786 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
59787 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
59788 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
59789 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
59790 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
59791 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
59792 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
59793 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
59794 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
59795 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
59796 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
59797 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
59798 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
59799 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
59800 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
59801 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
59802 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
59803 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
59804 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
59805 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
59806 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
59807 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
59808 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
59809 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
59810 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
59811 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
59812 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
59813 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
59814 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
59815 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
59816 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
59817 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
59818 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
59819 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
59820 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
59821 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
59822 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
59823 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
59824 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
59825 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
59826 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
59827 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
59828 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
59829 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
59830 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
59831 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
59832 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
59833 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
59834 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
59835 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
59836 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
59837 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
59838 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
59839 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
59840 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
59841 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
59842 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
59843 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
59844 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
59845 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
59846 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
59847 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
59848 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
59849 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
59850 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
59851 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
59852 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
59853 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
59854 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
59855 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
59856 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
59857 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
59858 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
59859 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
59860 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
59861 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
59862 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
59863 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
59864 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
59865 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
59866 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
59867 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
59868 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
59869 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
59870 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
59871 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
59872 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
59873 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
59874 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
59875 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
59876 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
59877 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
59878 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
59879 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
59880 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
59881 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
59882 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
59883 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
59884 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
59885 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
59886 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
59887 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
59888 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
59889 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
59890 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
59891 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
59892 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
59893 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
59894 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
59895 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
59896 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
59897 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
59898 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
59899 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
59900 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
59901 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
59902 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
59903 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
59904 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
59905 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
59906 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
59907 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
59908 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
59909 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
59910 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
59911 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
59912 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
59913 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
59914 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
59915 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
59916 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
59917 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
59918 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
59919 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
59920 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
59921 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
59922 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
59923 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
59924 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
59925 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
59926 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
59927 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
59928 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
59929 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
59930 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
59931 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
59932 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
59933 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
59934 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
59935 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
59936 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
59937 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
59938 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
59939 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
59940 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
59941 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
59942 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
59943 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
59944 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
59945 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
59946 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
59947 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
59948 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
59949 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
59950 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
59951 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
59952 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
59953 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
59954 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
59955 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
59956 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
59957 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
59958 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
59959 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
59960 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
59961 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
59962 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
59963 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
59964 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
59965 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
59966 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
59967 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
59968 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
59969 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
59970 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
59971 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
59972 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
59973 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
59974 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
59975 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
59976 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
59977 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
59978 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
59979 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
59980 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
59981 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
59982 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
59983 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
59984 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
59985 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
59986 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
59987 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
59988 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
59989 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
59990 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
59991 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
59992 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
59993 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
59994 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
59995 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
59996 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
59997 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
59998 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
59999 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
60000 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
60001 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
60002 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
60003 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
60004 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
60005 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
60006 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
60007 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
60008 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
60009 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
60010 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
60011 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
60012 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
60013 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
60014 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
60015 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
60016 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
60017 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
60018 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
60019 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
60020 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
60021 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
60022 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
60023 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
60024 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
60025 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
60026 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
60027 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
60028 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
60029 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
60030 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
60031 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
60032 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
60033 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
60034 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
60035 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
60036 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
60037 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
60038 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
60039 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
60040 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
60041 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
60042 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
60043 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
60044 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
60045 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
60046 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
60047 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
60048 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
60049 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
60050 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
60051 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
60052 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
60053 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
60054 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
60055 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
60056 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
60057 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
60058 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
60059 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
60060 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
60061 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
60062 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
60063 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
60064 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
60065 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
60066 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
60067 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
60068 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
60069 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
60070 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
60071 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
60072 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
60073 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
60074 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
60075 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
60076 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
60077 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
60078 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
60079 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
60080 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
60081 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
60082 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
60083 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
60084 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
60085 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
60086 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
60087 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
60088 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
60089 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
60090 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
60091 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
60092 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
60093 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
60094 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
60095 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
60096 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
60097 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
60098 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
60099 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
60100 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
60101 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
60102 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
60103 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
60104 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
60105 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
60106 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
60107 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
60108 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
60109 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
60110 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
60111 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
60112 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
60113 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
60114 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
60115 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
60116 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
60117 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
60118 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
60119 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
60120 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
60121 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
60122 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
60123 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
60124 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
60125 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
60126 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
60127 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
60128 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
60129 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
60130 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
60131 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
60132 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
60133 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
60134 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
60135 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
60136 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
60137 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
60138 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
60139 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
60140 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
60141 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
60142 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
60143 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
60144 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
60145 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
60146 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
60147 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
60148 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
60149 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
60150 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
60151 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
60152 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
60153 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
60154 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
60155 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
60156 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
60157 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
60158 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
60159 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
60160 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
60161 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
60162 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
60163 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
60164 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
60165 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
60166 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
60167 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
60168 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
60169 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
60170 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
60171 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
60172 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
60173 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
60174 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
60175 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
60176 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
60177 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
60178 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
60179 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
60180 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
60181 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
60182 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
60183 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
60184 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
60185 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
60186 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
60187 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
60188 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
60189 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
60190 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
60191 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
60192 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
60193 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
60194 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
60195 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
60196 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
60197 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
60198
60199 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
60200
60201
60202 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
60203
60204 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
60205 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
60206 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
60207 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
60208 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
60209 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
60210 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
60211 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
60212 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
60213 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
60214 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
60215 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
60216 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
60217 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
60218 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
60219 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
60220 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
60221 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
60222 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
60223 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
60224 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
60225 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
60226 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
60227 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
60228 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
60229 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
60230 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
60231 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
60232 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
60233 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
60234 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
60235 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
60236 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
60237 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
60238 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
60239 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
60240 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
60241 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
60242 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
60243 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
60244 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
60245 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
60246 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
60247 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
60248 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
60249 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
60250 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
60251 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
60252 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
60253 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
60254 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
60255 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
60256 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
60257 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
60258 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
60259 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
60260 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
60261 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
60262 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
60263 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
60264 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
60265 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
60266 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
60267 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
60268 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
60269 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
60270 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
60271 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
60272 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
60273 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
60274 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
60275 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
60276 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
60277 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
60278 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
60279 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
60280 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
60281 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
60282 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
60283 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
60284 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
60285 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
60286 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
60287 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
60288 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
60289 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
60290 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
60291 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
60292 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
60293 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
60294 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
60295 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
60296 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
60297 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
60298 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
60299 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
60300 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
60301 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
60302 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
60303 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
60304 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
60305 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
60306 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
60307 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
60308 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
60309 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
60310 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
60311 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
60312 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
60313 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
60314 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
60315 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
60316 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
60317 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
60318 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
60319 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
60320 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
60321 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
60322 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
60323 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
60324 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
60325 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
60326 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
60327 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
60328 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
60329 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
60330 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
60331 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
60332 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
60333 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
60334 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
60335 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
60336 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
60337 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
60338 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
60339 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
60340 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
60341 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
60342 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
60343 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
60344 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
60345 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
60346 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
60347 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
60348 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
60349 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
60350 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
60351 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
60352 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
60353 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
60354 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
60355 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
60356 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
60357 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
60358 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
60359 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
60360 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
60361 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
60362 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
60363 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
60364 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
60365 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
60366 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
60367 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
60368 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
60369 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
60370 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
60371 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
60372 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
60373 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
60374 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
60375 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
60376 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
60377 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
60378 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
60379 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
60380 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
60381 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
60382 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
60383 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
60384 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
60385 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
60386 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
60387 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
60388 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
60389 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
60390 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
60391 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
60392 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
60393 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
60394 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
60395 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
60396 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
60397 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
60398 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
60399 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
60400 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
60401 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
60402 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
60403 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
60404 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
60405 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
60406 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
60407 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
60408 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
60409 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
60410 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
60411 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
60412 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
60413 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
60414 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
60415 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
60416 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
60417 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
60418
60419 // Initialize threading, some globals and such
60420 __wxPyPreStart(d);
60421
60422
60423 // Although these are defined in __version__ they need to be here too so
60424 // that an assert can be done to ensure that the wxPython and the wxWindows
60425 // versions match.
60426 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
60427 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
60428 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
60429
60430 }
60431
wxWidgets (Impactor)