]> 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
test for special keys first, before testing for alphanumeric ones as even keys such...
[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_wxEventBlocker swig_types[38]
2505 #define SWIGTYPE_p_wxEventLoop swig_types[39]
2506 #define SWIGTYPE_p_wxEventLoopActivator swig_types[40]
2507 #define SWIGTYPE_p_wxEvtHandler swig_types[41]
2508 #define SWIGTYPE_p_wxFSFile swig_types[42]
2509 #define SWIGTYPE_p_wxFileSystem swig_types[43]
2510 #define SWIGTYPE_p_wxFileSystemHandler swig_types[44]
2511 #define SWIGTYPE_p_wxFlexGridSizer swig_types[45]
2512 #define SWIGTYPE_p_wxFocusEvent swig_types[46]
2513 #define SWIGTYPE_p_wxFont swig_types[47]
2514 #define SWIGTYPE_p_wxFrame swig_types[48]
2515 #define SWIGTYPE_p_wxGBPosition swig_types[49]
2516 #define SWIGTYPE_p_wxGBSizerItem swig_types[50]
2517 #define SWIGTYPE_p_wxGBSpan swig_types[51]
2518 #define SWIGTYPE_p_wxGIFHandler swig_types[52]
2519 #define SWIGTYPE_p_wxGridBagSizer swig_types[53]
2520 #define SWIGTYPE_p_wxGridSizer swig_types[54]
2521 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[55]
2522 #define SWIGTYPE_p_wxICOHandler swig_types[56]
2523 #define SWIGTYPE_p_wxIconizeEvent swig_types[57]
2524 #define SWIGTYPE_p_wxIdleEvent swig_types[58]
2525 #define SWIGTYPE_p_wxImage swig_types[59]
2526 #define SWIGTYPE_p_wxImageHandler swig_types[60]
2527 #define SWIGTYPE_p_wxImageHistogram swig_types[61]
2528 #define SWIGTYPE_p_wxImage_HSVValue swig_types[62]
2529 #define SWIGTYPE_p_wxImage_RGBValue swig_types[63]
2530 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[64]
2531 #define SWIGTYPE_p_wxInitDialogEvent swig_types[65]
2532 #define SWIGTYPE_p_wxInputStream swig_types[66]
2533 #define SWIGTYPE_p_wxInternetFSHandler swig_types[67]
2534 #define SWIGTYPE_p_wxItemContainer swig_types[68]
2535 #define SWIGTYPE_p_wxJPEGHandler swig_types[69]
2536 #define SWIGTYPE_p_wxKeyEvent swig_types[70]
2537 #define SWIGTYPE_p_wxLayoutConstraints swig_types[71]
2538 #define SWIGTYPE_p_wxMaximizeEvent swig_types[72]
2539 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[73]
2540 #define SWIGTYPE_p_wxMenu swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBar swig_types[75]
2542 #define SWIGTYPE_p_wxMenuBarBase swig_types[76]
2543 #define SWIGTYPE_p_wxMenuEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMenuItem swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMouseEvent swig_types[81]
2548 #define SWIGTYPE_p_wxMoveEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNcPaintEvent swig_types[84]
2551 #define SWIGTYPE_p_wxNotifyEvent swig_types[85]
2552 #define SWIGTYPE_p_wxObject swig_types[86]
2553 #define SWIGTYPE_p_wxOutputStream swig_types[87]
2554 #define SWIGTYPE_p_wxPCXHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNGHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPNMHandler swig_types[90]
2557 #define SWIGTYPE_p_wxPaintEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[92]
2559 #define SWIGTYPE_p_wxPaperSize swig_types[93]
2560 #define SWIGTYPE_p_wxPoint swig_types[94]
2561 #define SWIGTYPE_p_wxPoint2D swig_types[95]
2562 #define SWIGTYPE_p_wxPropagateOnce swig_types[96]
2563 #define SWIGTYPE_p_wxPropagationDisabler swig_types[97]
2564 #define SWIGTYPE_p_wxPyApp swig_types[98]
2565 #define SWIGTYPE_p_wxPyCommandEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyDropTarget swig_types[100]
2567 #define SWIGTYPE_p_wxPyEvent swig_types[101]
2568 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[102]
2569 #define SWIGTYPE_p_wxPyImageHandler swig_types[103]
2570 #define SWIGTYPE_p_wxPyInputStream swig_types[104]
2571 #define SWIGTYPE_p_wxPySizer swig_types[105]
2572 #define SWIGTYPE_p_wxPyValidator swig_types[106]
2573 #define SWIGTYPE_p_wxQuantize swig_types[107]
2574 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[108]
2575 #define SWIGTYPE_p_wxRealPoint swig_types[109]
2576 #define SWIGTYPE_p_wxRect swig_types[110]
2577 #define SWIGTYPE_p_wxRect2D swig_types[111]
2578 #define SWIGTYPE_p_wxRegion swig_types[112]
2579 #define SWIGTYPE_p_wxScrollEvent swig_types[113]
2580 #define SWIGTYPE_p_wxScrollWinEvent swig_types[114]
2581 #define SWIGTYPE_p_wxSetCursorEvent swig_types[115]
2582 #define SWIGTYPE_p_wxShowEvent swig_types[116]
2583 #define SWIGTYPE_p_wxSize swig_types[117]
2584 #define SWIGTYPE_p_wxSizeEvent swig_types[118]
2585 #define SWIGTYPE_p_wxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxSizerItem swig_types[120]
2587 #define SWIGTYPE_p_wxStaticBox swig_types[121]
2588 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[122]
2589 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[123]
2590 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[124]
2591 #define SWIGTYPE_p_wxTGAHandler swig_types[125]
2592 #define SWIGTYPE_p_wxTIFFHandler swig_types[126]
2593 #define SWIGTYPE_p_wxToolTip swig_types[127]
2594 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[128]
2595 #define SWIGTYPE_p_wxValidator swig_types[129]
2596 #define SWIGTYPE_p_wxVisualAttributes swig_types[130]
2597 #define SWIGTYPE_p_wxWindow swig_types[131]
2598 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[132]
2599 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[133]
2600 #define SWIGTYPE_p_wxXPMHandler swig_types[134]
2601 #define SWIGTYPE_p_wxZipFSHandler swig_types[135]
2602 static swig_type_info *swig_types[137];
2603 static swig_module_info swig_module = {swig_types, 136, 0, 0, 0, 0};
2604 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2605 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2606
2607 /* -------- TYPES TABLE (END) -------- */
2608
2609 #if (PY_VERSION_HEX <= 0x02000000)
2610 # if !defined(SWIG_PYTHON_CLASSIC)
2611 # error "This python version requires to use swig with the '-classic' option"
2612 # endif
2613 #endif
2614 #if (PY_VERSION_HEX <= 0x02020000)
2615 # error "This python version requires to use swig with the '-nomodern' option"
2616 #endif
2617 #if (PY_VERSION_HEX <= 0x02020000)
2618 # error "This python version requires to use swig with the '-nomodernargs' option"
2619 #endif
2620 #ifndef METH_O
2621 # error "This python version requires to use swig with the '-nofastunpack' option"
2622 #endif
2623
2624 /*-----------------------------------------------
2625 @(target):= _core_.so
2626 ------------------------------------------------*/
2627 #define SWIG_init init_core_
2628
2629 #define SWIG_name "_core_"
2630
2631 #define SWIGVERSION 0x010329
2632
2633
2634 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2635 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2636
2637
2638 #include <stdexcept>
2639
2640
2641 namespace swig {
2642 class PyObject_ptr {
2643 protected:
2644 PyObject *_obj;
2645
2646 public:
2647 PyObject_ptr() :_obj(0)
2648 {
2649 }
2650
2651 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2652 {
2653 Py_XINCREF(_obj);
2654 }
2655
2656 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2657 {
2658 if (initial_ref) Py_XINCREF(_obj);
2659 }
2660
2661 PyObject_ptr & operator=(const PyObject_ptr& item)
2662 {
2663 Py_XINCREF(item._obj);
2664 Py_XDECREF(_obj);
2665 _obj = item._obj;
2666 return *this;
2667 }
2668
2669 ~PyObject_ptr()
2670 {
2671 Py_XDECREF(_obj);
2672 }
2673
2674 operator PyObject *() const
2675 {
2676 return _obj;
2677 }
2678
2679 PyObject *operator->() const
2680 {
2681 return _obj;
2682 }
2683 };
2684 }
2685
2686
2687 namespace swig {
2688 struct PyObject_var : PyObject_ptr {
2689 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2690
2691 PyObject_var & operator = (PyObject* obj)
2692 {
2693 Py_XDECREF(_obj);
2694 _obj = obj;
2695 return *this;
2696 }
2697 };
2698 }
2699
2700
2701 #include "wx/wxPython/wxPython_int.h"
2702 #include "wx/wxPython/pyclasses.h"
2703 #include "wx/wxPython/twoitem.h"
2704
2705
2706 #ifndef wxPyUSE_EXPORT
2707 // Helper functions for dealing with SWIG objects and such. These are
2708 // located here so they know about the SWIG types and functions declared
2709 // in the wrapper code.
2710
2711 #include <wx/hashmap.h>
2712 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2713
2714
2715 // Maintains a hashmap of className to swig_type_info pointers. Given the
2716 // name of a class either looks up the type info in the cache, or scans the
2717 // SWIG tables for it.
2718 extern PyObject* wxPyPtrTypeMap;
2719 static
2720 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2721
2722 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2723
2724 if (typeInfoCache == NULL)
2725 typeInfoCache = new wxPyTypeInfoHashMap;
2726
2727 wxString name(className);
2728 swig_type_info* swigType = (*typeInfoCache)[name];
2729
2730 if (! swigType) {
2731 // it wasn't in the cache, so look it up from SWIG
2732 name.Append(wxT(" *"));
2733 swigType = SWIG_TypeQuery(name.mb_str());
2734
2735 // if it still wasn't found, try looking for a mapped name
2736 if (!swigType) {
2737 PyObject* item;
2738 name = className;
2739
2740 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2741 (char*)(const char*)name.mbc_str())) != NULL) {
2742 name = wxString(PyString_AsString(item), *wxConvCurrent);
2743 name.Append(wxT(" *"));
2744 swigType = SWIG_TypeQuery(name.mb_str());
2745 }
2746 }
2747 if (swigType) {
2748 // and add it to the map if found
2749 (*typeInfoCache)[className] = swigType;
2750 }
2751 }
2752 return swigType;
2753 }
2754
2755
2756 // Check if a class name is a type known to SWIG
2757 bool wxPyCheckSwigType(const wxChar* className) {
2758
2759 swig_type_info* swigType = wxPyFindSwigType(className);
2760 return swigType != NULL;
2761 }
2762
2763
2764 // Given a pointer to a C++ object and a class name, construct a Python proxy
2765 // object for it.
2766 PyObject* wxPyConstructObject(void* ptr,
2767 const wxChar* className,
2768 int setThisOwn) {
2769
2770 swig_type_info* swigType = wxPyFindSwigType(className);
2771 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2772
2773 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2774 }
2775
2776
2777 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2778 // Ensures that the proxy object is of the specified (or derived) type. If
2779 // not able to perform the conversion then a Python exception is set and the
2780 // error should be handled properly in the caller. Returns True on success.
2781 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2782 const wxChar* className) {
2783
2784 swig_type_info* swigType = wxPyFindSwigType(className);
2785 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2786
2787 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2788 }
2789
2790
2791
2792 // Make a SWIGified pointer object suitable for a .this attribute
2793 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2794
2795 PyObject* robj = NULL;
2796
2797 swig_type_info* swigType = wxPyFindSwigType(className);
2798 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2799
2800 robj = PySwigObject_New(ptr, swigType, 0);
2801 return robj;
2802 }
2803
2804
2805 // Python's PyInstance_Check does not return True for instances of new-style
2806 // classes. This should get close enough for both new and old classes but I
2807 // should re-evaluate the need for doing instance checks...
2808 bool wxPyInstance_Check(PyObject* obj) {
2809 return PyObject_HasAttrString(obj, "__class__") != 0;
2810 }
2811
2812
2813 // This one checks if the object is an instance of a SWIG proxy class (it has
2814 // a .this attribute, and the .this attribute is a PySwigObject.)
2815 bool wxPySwigInstance_Check(PyObject* obj) {
2816 static PyObject* this_str = NULL;
2817 if (this_str == NULL)
2818 this_str = PyString_FromString("this");
2819
2820 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2821 if (this_attr) {
2822 bool retval = (PySwigObject_Check(this_attr) != 0);
2823 Py_DECREF(this_attr);
2824 return retval;
2825 }
2826
2827 PyErr_Clear();
2828 return false;
2829 }
2830
2831
2832 // Export a C API in a struct. Other modules will be able to load this from
2833 // the wx._core_ module and will then have safe access to these functions,
2834 // even if they are located in another shared library.
2835 static wxPyCoreAPI API = {
2836
2837 wxPyCheckSwigType,
2838 wxPyConstructObject,
2839 wxPyConvertSwigPtr,
2840 wxPyMakeSwigPtr,
2841
2842 wxPyBeginAllowThreads,
2843 wxPyEndAllowThreads,
2844 wxPyBeginBlockThreads,
2845 wxPyEndBlockThreads,
2846
2847 wxPy_ConvertList,
2848
2849 wxString_in_helper,
2850 Py2wxString,
2851 wx2PyString,
2852
2853 byte_LIST_helper,
2854 int_LIST_helper,
2855 long_LIST_helper,
2856 string_LIST_helper,
2857 wxPoint_LIST_helper,
2858 wxBitmap_LIST_helper,
2859 wxString_LIST_helper,
2860 wxAcceleratorEntry_LIST_helper,
2861
2862 wxSize_helper,
2863 wxPoint_helper,
2864 wxRealPoint_helper,
2865 wxRect_helper,
2866 wxColour_helper,
2867 wxPoint2D_helper,
2868
2869 wxPySimple_typecheck,
2870 wxColour_typecheck,
2871
2872 wxPyCBH_setCallbackInfo,
2873 wxPyCBH_findCallback,
2874 wxPyCBH_callCallback,
2875 wxPyCBH_callCallbackObj,
2876 wxPyCBH_delete,
2877
2878 wxPyMake_wxObject,
2879 wxPyMake_wxSizer,
2880 wxPyPtrTypeMap_Add,
2881 wxPy2int_seq_helper,
2882 wxPy4int_seq_helper,
2883 wxArrayString2PyList_helper,
2884 wxArrayInt2PyList_helper,
2885
2886 wxPyClientData_dtor,
2887 wxPyUserData_dtor,
2888 wxPyOORClientData_dtor,
2889
2890 wxPyCBInputStream_create,
2891 wxPyCBInputStream_copy,
2892
2893 wxPyInstance_Check,
2894 wxPySwigInstance_Check,
2895
2896 wxPyCheckForApp,
2897
2898 wxArrayDouble2PyList_helper,
2899 wxPoint2D_LIST_helper,
2900 wxRect2D_helper,
2901
2902 };
2903
2904 #endif
2905
2906
2907 #if !WXWIN_COMPATIBILITY_2_4
2908 #define wxHIDE_READONLY 0
2909 #endif
2910
2911
2912 #define SWIG_From_long PyInt_FromLong
2913
2914
2915 SWIGINTERNINLINE PyObject *
2916 SWIG_From_int (int value)
2917 {
2918 return SWIG_From_long (value);
2919 }
2920
2921 static const wxString wxPyEmptyString(wxEmptyString);
2922 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2923 return self->GetClassInfo()->GetClassName();
2924 }
2925 SWIGINTERN void wxObject_Destroy(wxObject *self){
2926 delete self;
2927 }
2928
2929 #ifndef __WXMAC__
2930 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2931 #endif
2932
2933
2934 #include <limits.h>
2935 #ifndef LLONG_MIN
2936 # define LLONG_MIN LONG_LONG_MIN
2937 #endif
2938 #ifndef LLONG_MAX
2939 # define LLONG_MAX LONG_LONG_MAX
2940 #endif
2941 #ifndef ULLONG_MAX
2942 # define ULLONG_MAX ULONG_LONG_MAX
2943 #endif
2944
2945
2946 SWIGINTERN int
2947 SWIG_AsVal_long (PyObject* obj, long* val)
2948 {
2949 if (PyNumber_Check(obj)) {
2950 if (val) *val = PyInt_AsLong(obj);
2951 return SWIG_OK;
2952 }
2953 return SWIG_TypeError;
2954 }
2955
2956
2957 SWIGINTERN int
2958 SWIG_AsVal_int (PyObject * obj, int *val)
2959 {
2960 long v;
2961 int res = SWIG_AsVal_long (obj, &v);
2962 if (SWIG_IsOK(res)) {
2963 if ((v < INT_MIN || v > INT_MAX)) {
2964 return SWIG_OverflowError;
2965 } else {
2966 if (val) *val = static_cast< int >(v);
2967 }
2968 }
2969 return res;
2970 }
2971
2972 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2973 wxSize temp, *obj = &temp;
2974 if ( other == Py_None ) return false;
2975 if ( ! wxSize_helper(other, &obj) ) {
2976 PyErr_Clear();
2977 return false;
2978 }
2979 return self->operator==(*obj);
2980 }
2981 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2982 wxSize temp, *obj = &temp;
2983 if ( other == Py_None ) return true;
2984 if ( ! wxSize_helper(other, &obj)) {
2985 PyErr_Clear();
2986 return true;
2987 }
2988 return self->operator!=(*obj);
2989 }
2990
2991 #include <float.h>
2992
2993
2994 SWIGINTERN int
2995 SWIG_AsVal_double (PyObject *obj, double* val)
2996 {
2997 if (PyNumber_Check(obj)) {
2998 if (val) *val = PyFloat_AsDouble(obj);
2999 return SWIG_OK;
3000 }
3001 return SWIG_TypeError;
3002 }
3003
3004
3005 SWIGINTERN int
3006 SWIG_AsVal_float (PyObject * obj, float *val)
3007 {
3008 double v;
3009 int res = SWIG_AsVal_double (obj, &v);
3010 if (SWIG_IsOK(res)) {
3011 if ((v < -FLT_MAX || v > FLT_MAX)) {
3012 return SWIG_OverflowError;
3013 } else {
3014 if (val) *val = static_cast< float >(v);
3015 }
3016 }
3017 return res;
3018 }
3019
3020 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3021 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3022 PyObject* tup = PyTuple_New(2);
3023 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3024 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3025 //wxPyEndBlockThreads(blocked);
3026 return tup;
3027 }
3028
3029 #define SWIG_From_double PyFloat_FromDouble
3030
3031 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3032 wxRealPoint temp, *obj = &temp;
3033 if ( other == Py_None ) return false;
3034 if ( ! wxRealPoint_helper(other, &obj) ) {
3035 PyErr_Clear();
3036 return false;
3037 }
3038 return self->operator==(*obj);
3039 }
3040 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3041 wxRealPoint temp, *obj = &temp;
3042 if ( other == Py_None ) return true;
3043 if ( ! wxRealPoint_helper(other, &obj)) {
3044 PyErr_Clear();
3045 return true;
3046 }
3047 return self->operator!=(*obj);
3048 }
3049 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3050 self->x = x;
3051 self->y = y;
3052 }
3053 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3054 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3055 PyObject* tup = PyTuple_New(2);
3056 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3057 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3058 //PyEndBlockThreads(blocked);
3059 return tup;
3060 }
3061 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3062 wxPoint temp, *obj = &temp;
3063 if ( other == Py_None ) return false;
3064 if ( ! wxPoint_helper(other, &obj) ) {
3065 PyErr_Clear();
3066 return false;
3067 }
3068 return self->operator==(*obj);
3069 }
3070 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3071 wxPoint temp, *obj = &temp;
3072 if ( other == Py_None ) return true;
3073 if ( ! wxPoint_helper(other, &obj)) {
3074 PyErr_Clear();
3075 return true;
3076 }
3077 return self->operator!=(*obj);
3078 }
3079 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3080 self->x = x;
3081 self->y = y;
3082 }
3083 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3084 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3085 PyObject* tup = PyTuple_New(2);
3086 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3087 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3088 //wxPyEndBlockThreads(blocked);
3089 return tup;
3090 }
3091 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3092 wxRect temp, *obj = &temp;
3093 if ( other == Py_None ) return false;
3094 if ( ! wxRect_helper(other, &obj) ) {
3095 PyErr_Clear();
3096 return false;
3097 }
3098 return self->operator==(*obj);
3099 }
3100 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3101 wxRect temp, *obj = &temp;
3102 if ( other == Py_None ) return true;
3103 if ( ! wxRect_helper(other, &obj)) {
3104 PyErr_Clear();
3105 return true;
3106 }
3107 return self->operator!=(*obj);
3108 }
3109 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3110 self->x = x;
3111 self->y = y;
3112 self->width = width;
3113 self->height = height;
3114 }
3115 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3116 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3117 PyObject* tup = PyTuple_New(4);
3118 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3119 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3120 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3121 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3122 //wxPyEndBlockThreads(blocked);
3123 return tup;
3124 }
3125
3126 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3127 wxRegion reg1(*r1);
3128 wxRegion reg2(*r2);
3129 wxRect dest(0,0,0,0);
3130 PyObject* obj;
3131
3132 reg1.Intersect(reg2);
3133 dest = reg1.GetBox();
3134
3135 if (dest != wxRect(0,0,0,0)) {
3136 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3137 wxRect* newRect = new wxRect(dest);
3138 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3139 //wxPyEndBlockThreads(blocked);
3140 return obj;
3141 }
3142 Py_INCREF(Py_None);
3143 return Py_None;
3144 }
3145
3146 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3147 wxPoint2D temp, *obj = &temp;
3148 if ( other == Py_None ) return false;
3149 if ( ! wxPoint2D_helper(other, &obj) ) {
3150 PyErr_Clear();
3151 return false;
3152 }
3153 return self->operator==(*obj);
3154 }
3155 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3156 wxPoint2D temp, *obj = &temp;
3157 if ( other == Py_None ) return true;
3158 if ( ! wxPoint2D_helper(other, &obj)) {
3159 PyErr_Clear();
3160 return true;
3161 }
3162 return self->operator!=(*obj);
3163 }
3164 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3165 self->m_x = x;
3166 self->m_y = y;
3167 }
3168 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3169 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3170 PyObject* tup = PyTuple_New(2);
3171 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3172 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3173 //wxPyEndBlockThreads(blocked);
3174 return tup;
3175 }
3176 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3177 wxRect2D temp, *obj = &temp;
3178 if ( other == Py_None ) return false;
3179 if ( ! wxRect2D_helper(other, &obj) ) {
3180 PyErr_Clear();
3181 return false;
3182 }
3183 return self->operator==(*obj);
3184 }
3185 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3186 wxRect2D temp, *obj = &temp;
3187 if ( other == Py_None ) return true;
3188 if ( ! wxRect2D_helper(other, &obj)) {
3189 PyErr_Clear();
3190 return true;
3191 }
3192 return self->operator!=(*obj);
3193 }
3194 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3195 self->m_x = x;
3196 self->m_y = y;
3197 self->m_width = width;
3198 self->m_height = height;
3199 }
3200 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3201 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3202 PyObject* tup = PyTuple_New(4);
3203 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3204 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3205 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3206 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3207 //wxPyEndBlockThreads(blocked);
3208 return tup;
3209 }
3210
3211 #include "wx/wxPython/pyistream.h"
3212
3213 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3214 wxInputStream* wxis = wxPyCBInputStream::create(p);
3215 if (wxis)
3216 return new wxPyInputStream(wxis);
3217 else
3218 return NULL;
3219 }
3220
3221 SWIGINTERN swig_type_info*
3222 SWIG_pchar_descriptor()
3223 {
3224 static int init = 0;
3225 static swig_type_info* info = 0;
3226 if (!init) {
3227 info = SWIG_TypeQuery("_p_char");
3228 init = 1;
3229 }
3230 return info;
3231 }
3232
3233
3234 SWIGINTERNINLINE PyObject *
3235 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3236 {
3237 if (carray) {
3238 if (size > INT_MAX) {
3239 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3240 return pchar_descriptor ?
3241 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3242 } else {
3243 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3244 }
3245 } else {
3246 return SWIG_Py_Void();
3247 }
3248 }
3249
3250
3251 SWIGINTERNINLINE PyObject *
3252 SWIG_From_char (char c)
3253 {
3254 return SWIG_FromCharPtrAndSize(&c,1);
3255 }
3256
3257
3258 SWIGINTERNINLINE PyObject*
3259 SWIG_From_unsigned_SS_long (unsigned long value)
3260 {
3261 return (value > LONG_MAX) ?
3262 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3263 }
3264
3265
3266 SWIGINTERNINLINE PyObject *
3267 SWIG_From_size_t (size_t value)
3268 {
3269 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3270 }
3271
3272
3273 SWIGINTERN int
3274 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3275 {
3276 if (PyString_Check(obj)) {
3277 char *cstr; Py_ssize_t len;
3278 PyString_AsStringAndSize(obj, &cstr, &len);
3279 if (cptr) {
3280 if (alloc) {
3281 /*
3282 In python the user should not be able to modify the inner
3283 string representation. To warranty that, if you define
3284 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3285 buffer is always returned.
3286
3287 The default behavior is just to return the pointer value,
3288 so, be careful.
3289 */
3290 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3291 if (*alloc != SWIG_OLDOBJ)
3292 #else
3293 if (*alloc == SWIG_NEWOBJ)
3294 #endif
3295 {
3296 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3297 *alloc = SWIG_NEWOBJ;
3298 }
3299 else {
3300 *cptr = cstr;
3301 *alloc = SWIG_OLDOBJ;
3302 }
3303 } else {
3304 *cptr = PyString_AsString(obj);
3305 }
3306 }
3307 if (psize) *psize = len + 1;
3308 return SWIG_OK;
3309 } else {
3310 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3311 if (pchar_descriptor) {
3312 void* vptr = 0;
3313 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3314 if (cptr) *cptr = (char *) vptr;
3315 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3316 if (alloc) *alloc = SWIG_OLDOBJ;
3317 return SWIG_OK;
3318 }
3319 }
3320 }
3321 return SWIG_TypeError;
3322 }
3323
3324
3325 SWIGINTERN int
3326 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3327 {
3328 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3329 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3330 if (SWIG_IsOK(res)) {
3331 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3332 if (csize <= size) {
3333 if (val) {
3334 if (csize) memcpy(val, cptr, csize*sizeof(char));
3335 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3336 }
3337 if (alloc == SWIG_NEWOBJ) {
3338 delete[] cptr;
3339 res = SWIG_DelNewMask(res);
3340 }
3341 return res;
3342 }
3343 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3344 }
3345 return SWIG_TypeError;
3346 }
3347
3348
3349 SWIGINTERN int
3350 SWIG_AsVal_char (PyObject * obj, char *val)
3351 {
3352 int res = SWIG_AsCharArray(obj, val, 1);
3353 if (!SWIG_IsOK(res)) {
3354 long v;
3355 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3356 if (SWIG_IsOK(res)) {
3357 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3358 if (val) *val = static_cast< char >(v);
3359 } else {
3360 res = SWIG_OverflowError;
3361 }
3362 }
3363 }
3364 return res;
3365 }
3366
3367 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3368 // We use only strings for the streams, not unicode
3369 PyObject* str = PyObject_Str(obj);
3370 if (! str) {
3371 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3372 return;
3373 }
3374 self->Write(PyString_AS_STRING(str),
3375 PyString_GET_SIZE(str));
3376 Py_DECREF(str);
3377 }
3378
3379 #include "wx/wxPython/pyistream.h"
3380
3381
3382 class wxPyFileSystemHandler : public wxFileSystemHandler
3383 {
3384 public:
3385 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3386
3387 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3388 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3389 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3390 DEC_PYCALLBACK_STRING__pure(FindNext);
3391
3392 wxString GetProtocol(const wxString& location) {
3393 return wxFileSystemHandler::GetProtocol(location);
3394 }
3395
3396 wxString GetLeftLocation(const wxString& location) {
3397 return wxFileSystemHandler::GetLeftLocation(location);
3398 }
3399
3400 wxString GetAnchor(const wxString& location) {
3401 return wxFileSystemHandler::GetAnchor(location);
3402 }
3403
3404 wxString GetRightLocation(const wxString& location) {
3405 return wxFileSystemHandler::GetRightLocation(location);
3406 }
3407
3408 wxString GetMimeTypeFromExt(const wxString& location) {
3409 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3410 }
3411
3412 PYPRIVATE;
3413 };
3414
3415
3416 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3417 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3418 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3419 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3420
3421
3422 SWIGINTERN int
3423 SWIG_AsVal_bool (PyObject *obj, bool *val)
3424 {
3425 if (obj == Py_True) {
3426 if (val) *val = true;
3427 return SWIG_OK;
3428 } else if (obj == Py_False) {
3429 if (val) *val = false;
3430 return SWIG_OK;
3431 } else {
3432 long v = 0;
3433 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3434 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3435 return res;
3436 }
3437 }
3438
3439 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3440 wxFileName fname = wxFileSystem::URLToFileName(url);
3441 return fname.GetFullPath();
3442 }
3443
3444 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3445 wxImage& image,
3446 long type) {
3447 wxMemoryFSHandler::AddFile(filename, image, type);
3448 }
3449
3450 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3451 const wxBitmap& bitmap,
3452 long type) {
3453 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3454 }
3455
3456 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3457 PyObject* data) {
3458 if (! PyString_Check(data)) {
3459 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3460 "Expected string object"));
3461 return;
3462 }
3463
3464 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3465 void* ptr = (void*)PyString_AsString(data);
3466 size_t size = PyString_Size(data);
3467 wxPyEndBlockThreads(blocked);
3468
3469 wxMemoryFSHandler::AddFile(filename, ptr, size);
3470 }
3471
3472
3473 #include "wx/wxPython/pyistream.h"
3474
3475
3476 SWIGINTERN int
3477 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3478 {
3479 long v = 0;
3480 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3481 return SWIG_TypeError;
3482 }
3483 else if (val)
3484 *val = (unsigned long)v;
3485 return SWIG_OK;
3486 }
3487
3488
3489 SWIGINTERN int
3490 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3491 {
3492 unsigned long v;
3493 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3494 if (SWIG_IsOK(res)) {
3495 if ((v > UCHAR_MAX)) {
3496 return SWIG_OverflowError;
3497 } else {
3498 if (val) *val = static_cast< unsigned char >(v);
3499 }
3500 }
3501 return res;
3502 }
3503
3504
3505 SWIGINTERNINLINE PyObject *
3506 SWIG_From_unsigned_SS_char (unsigned char value)
3507 {
3508 return SWIG_From_unsigned_SS_long (value);
3509 }
3510
3511 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3512 wxImageHistogramEntry e = (*self)[key];
3513 return e.value;
3514 }
3515 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3516 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3517 wxImageHistogramEntry e = (*self)[key];
3518 return e.value;
3519 }
3520 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3521 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3522 colour.Green(),
3523 colour.Blue());
3524 wxImageHistogramEntry e = (*self)[key];
3525 return e.value;
3526 }
3527
3528 // Pull the nested class out to the top level for SWIG's sake
3529 #define wxImage_RGBValue wxImage::RGBValue
3530 #define wxImage_HSVValue wxImage::HSVValue
3531
3532 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3533 if (width > 0 && height > 0)
3534 return new wxImage(width, height, clear);
3535 else
3536 return new wxImage;
3537 }
3538 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3539 return new wxImage(bitmap.ConvertToImage());
3540 }
3541 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3542 if (DATASIZE != width*height*3) {
3543 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3544 return NULL;
3545 }
3546
3547 // Copy the source data so the wxImage can clean it up later
3548 buffer copy = (buffer)malloc(DATASIZE);
3549 if (copy == NULL) {
3550 wxPyBLOCK_THREADS(PyErr_NoMemory());
3551 return NULL;
3552 }
3553 memcpy(copy, data, DATASIZE);
3554 return new wxImage(width, height, copy, false);
3555 }
3556 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3557 if (DATASIZE != width*height*3) {
3558 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3559 return NULL;
3560 }
3561 if (ALPHASIZE != width*height) {
3562 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3563 return NULL;
3564 }
3565
3566 // Copy the source data so the wxImage can clean it up later
3567 buffer dcopy = (buffer)malloc(DATASIZE);
3568 if (dcopy == NULL) {
3569 wxPyBLOCK_THREADS(PyErr_NoMemory());
3570 return NULL;
3571 }
3572 memcpy(dcopy, data, DATASIZE);
3573
3574 buffer acopy = (buffer)malloc(ALPHASIZE);
3575 if (acopy == NULL) {
3576 wxPyBLOCK_THREADS(PyErr_NoMemory());
3577 return NULL;
3578 }
3579 memcpy(acopy, alpha, ALPHASIZE);
3580
3581 return new wxImage(width, height, dcopy, acopy, false);
3582 }
3583 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3584 wxSize size(self->GetWidth(), self->GetHeight());
3585 return size;
3586 }
3587 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3588 buffer data = self->GetData();
3589 int len = self->GetWidth() * self->GetHeight() * 3;
3590 PyObject* rv;
3591 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3592 return rv;
3593 }
3594 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3595 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3596 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3597 return;
3598 }
3599 buffer copy = (buffer)malloc(DATASIZE);
3600 if (copy == NULL) {
3601 wxPyBLOCK_THREADS(PyErr_NoMemory());
3602 return;
3603 }
3604 memcpy(copy, data, DATASIZE);
3605 self->SetData(copy, false);
3606 // wxImage takes ownership of copy...
3607 }
3608 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3609 buffer data = self->GetData();
3610 int len = self->GetWidth() * self->GetHeight() * 3;
3611 PyObject* rv;
3612 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3613 return rv;
3614 }
3615 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3616 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3617 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3618 return;
3619 }
3620 self->SetData(data, true);
3621 }
3622 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3623 buffer data = self->GetAlpha();
3624 if (! data) {
3625 RETURN_NONE();
3626 } else {
3627 int len = self->GetWidth() * self->GetHeight();
3628 PyObject* rv;
3629 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3630 return rv;
3631 }
3632 }
3633 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3634 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3635 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3636 return;
3637 }
3638 buffer acopy = (buffer)malloc(ALPHASIZE);
3639 if (acopy == NULL) {
3640 wxPyBLOCK_THREADS(PyErr_NoMemory());
3641 return;
3642 }
3643 memcpy(acopy, alpha, ALPHASIZE);
3644 self->SetAlpha(acopy, false);
3645 // wxImage takes ownership of acopy...
3646 }
3647 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3648 buffer data = self->GetAlpha();
3649 int len = self->GetWidth() * self->GetHeight();
3650 PyObject* rv;
3651 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3652 return rv;
3653 }
3654 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3655 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3656 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3657 return;
3658 }
3659 self->SetAlpha(alpha, true);
3660 }
3661 SWIGINTERN PyObject *wxImage_GetHandlers(){
3662 wxList& list = wxImage::GetHandlers();
3663 return wxPy_ConvertList(&list);
3664 }
3665 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3666 wxBitmap bitmap(*self, depth);
3667 return bitmap;
3668 }
3669 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3670 wxImage mono = self->ConvertToMono( red, green, blue );
3671 wxBitmap bitmap( mono, 1 );
3672 return bitmap;
3673 }
3674
3675 wxImage* _ImageFromBuffer(int width, int height,
3676 buffer data, int DATASIZE,
3677 buffer alpha=NULL, int ALPHASIZE=0)
3678 {
3679 if (DATASIZE != width*height*3) {
3680 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3681 return NULL;
3682 }
3683 if (alpha != NULL) {
3684 if (ALPHASIZE != width*height) {
3685 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3686 return NULL;
3687 }
3688 return new wxImage(width, height, data, alpha, true);
3689 }
3690 return new wxImage(width, height, data, true);
3691 }
3692
3693 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3694 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3695 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3696 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3697 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3698 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3699 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3700 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3701 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3702 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3703 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3704 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3705 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3706 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3707 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3708
3709 #include <wx/imagtga.h>
3710
3711
3712 #include <wx/quantize.h>
3713
3714 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3715 return wxQuantize::Quantize(src, dest,
3716 //NULL, // palette
3717 desiredNoColours,
3718 NULL, // eightBitData
3719 flags);
3720 }
3721 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3722 if (PyCallable_Check(func)) {
3723 self->Connect(id, lastId, eventType,
3724 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3725 new wxPyCallback(func));
3726 }
3727 else if (func == Py_None) {
3728 self->Disconnect(id, lastId, eventType,
3729 (wxObjectEventFunction)
3730 &wxPyCallback::EventThunker);
3731 }
3732 else {
3733 wxPyBLOCK_THREADS(
3734 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3735 }
3736 }
3737 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3738 return self->Disconnect(id, lastId, eventType,
3739 (wxObjectEventFunction)
3740 &wxPyCallback::EventThunker);
3741 }
3742 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3743 if (_self && _self != Py_None) {
3744 self->SetClientObject(new wxPyOORClientData(_self, incref));
3745 }
3746 else {
3747 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3748 if (data) {
3749 self->SetClientObject(NULL); // This will delete it too
3750 }
3751 }
3752 }
3753
3754 #if ! wxUSE_HOTKEY
3755 #define wxEVT_HOTKEY -9999
3756 #endif
3757
3758 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3759 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3760 if (data) {
3761 Py_INCREF(data->m_obj);
3762 return data->m_obj;
3763 } else {
3764 Py_INCREF(Py_None);
3765 return Py_None;
3766 }
3767 }
3768 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3769 wxPyClientData* data = new wxPyClientData(clientData);
3770 self->SetClientObject(data);
3771 }
3772 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3773 #if wxUSE_UNICODE
3774 return self->GetUnicodeKey();
3775 #else
3776 return 0;
3777 #endif
3778 }
3779 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3780 #if wxUSE_UNICODE
3781 self->m_uniChar = uniChar;
3782 #endif
3783 }
3784
3785 SWIGINTERNINLINE PyObject *
3786 SWIG_From_unsigned_SS_int (unsigned int value)
3787 {
3788 return SWIG_From_unsigned_SS_long (value);
3789 }
3790
3791
3792 SWIGINTERN int
3793 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3794 {
3795 unsigned long v;
3796 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3797 if (SWIG_IsOK(res)) {
3798 if ((v > UINT_MAX)) {
3799 return SWIG_OverflowError;
3800 } else {
3801 if (val) *val = static_cast< unsigned int >(v);
3802 }
3803 }
3804 return res;
3805 }
3806
3807 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3808 self->m_size = size;
3809 }
3810 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3811 int count = self->GetNumberOfFiles();
3812 wxString* files = self->GetFiles();
3813 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3814 PyObject* list = PyList_New(count);
3815
3816 if (!list) {
3817 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3818 wxPyEndBlockThreads(blocked);
3819 return NULL;
3820 }
3821
3822 for (int i=0; i<count; i++) {
3823 PyList_SetItem(list, i, wx2PyString(files[i]));
3824 }
3825 wxPyEndBlockThreads(blocked);
3826 return list;
3827 }
3828
3829
3830 SWIGINTERN wxPyApp *new_wxPyApp(){
3831 wxPythonApp = new wxPyApp();
3832 return wxPythonApp;
3833 }
3834 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3835 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3836 return wxPyTestDisplayAvailable();
3837 }
3838
3839 void wxApp_CleanUp() {
3840 __wxPyCleanup();
3841 }
3842
3843
3844 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3845
3846
3847
3848
3849
3850 SWIGINTERNINLINE PyObject *
3851 SWIG_FromCharPtr(const char *cptr)
3852 {
3853 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3854 }
3855
3856
3857 #if 0 // #ifdef __WXMAC__
3858
3859 // A dummy class that raises an exception if used...
3860 class wxEventLoop
3861 {
3862 public:
3863 wxEventLoop() { wxPyRaiseNotImplemented(); }
3864 int Run() { return 0; }
3865 void Exit(int rc = 0) {}
3866 bool Pending() const { return false; }
3867 bool Dispatch() { return false; }
3868 bool IsRunning() const { return false; }
3869 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3870 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3871 };
3872
3873 #else
3874
3875 #include <wx/evtloop.h>
3876
3877 #endif
3878
3879
3880
3881 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3882 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3883 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3884 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3885 wxWindowList& list = self->GetChildren();
3886 return wxPy_ConvertList(&list);
3887 }
3888 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3889 #if wxUSE_HOTKEY
3890 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3891 #else
3892 return false;
3893 #endif
3894 }
3895 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3896
3897
3898
3899 return false;
3900
3901 }
3902 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3903 return wxPyGetWinHandle(self);
3904 }
3905 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3906 self->AssociateHandle((WXWidget)handle);
3907 }
3908 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3909
3910 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3911 return wxWindow::FindWindowById(id, parent);
3912 }
3913
3914 wxWindow* wxFindWindowByName( const wxString& name,
3915 const wxWindow *parent = NULL ) {
3916 return wxWindow::FindWindowByName(name, parent);
3917 }
3918
3919 wxWindow* wxFindWindowByLabel( const wxString& label,
3920 const wxWindow *parent = NULL ) {
3921 return wxWindow::FindWindowByLabel(label, parent);
3922 }
3923
3924
3925 #ifdef __WXMSW__
3926 #include <wx/msw/private.h> // to get wxGetWindowId
3927 #endif
3928
3929
3930 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3931 #ifdef __WXMSW__
3932 WXHWND hWnd = (WXHWND)_hWnd;
3933 long id = wxGetWindowId(hWnd);
3934 wxWindow* win = new wxWindow;
3935 if (parent)
3936 parent->AddChild(win);
3937 win->SetEventHandler(win);
3938 win->SetHWND(hWnd);
3939 win->SetId(id);
3940 win->SubclassWin(hWnd);
3941 win->AdoptAttributesFromHWND();
3942 win->SetupColours();
3943 return win;
3944 #else
3945 wxPyRaiseNotImplemented();
3946 return NULL;
3947 #endif
3948 }
3949
3950
3951 PyObject* GetTopLevelWindows() {
3952 return wxPy_ConvertList(&wxTopLevelWindows);
3953 }
3954
3955
3956 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3957 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3958 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3959
3960 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3961
3962
3963 SWIGINTERNINLINE int
3964 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3965 {
3966 unsigned long v;
3967 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3968 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3969 return res;
3970 }
3971
3972 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3973 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3974 wxMenuItemList& list = self->GetMenuItems();
3975 return wxPy_ConvertList(&list);
3976 }
3977 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3978 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3979 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3980 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3981 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3982 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3983 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3984 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3985 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3986 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3987 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3988 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3989 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3990 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3991 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3992 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3993 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3994 static const wxString wxPyControlNameStr(wxControlNameStr);
3995 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3996 if (clientData) {
3997 wxPyClientData* data = new wxPyClientData(clientData);
3998 return self->Append(item, data);
3999 } else
4000 return self->Append(item);
4001 }
4002 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
4003 if (clientData) {
4004 wxPyClientData* data = new wxPyClientData(clientData);
4005 return self->Insert(item, pos, data);
4006 } else
4007 return self->Insert(item, pos);
4008 }
4009 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
4010 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
4011 if (data) {
4012 Py_INCREF(data->m_obj);
4013 return data->m_obj;
4014 } else {
4015 Py_INCREF(Py_None);
4016 return Py_None;
4017 }
4018 }
4019 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
4020 wxPyClientData* data = new wxPyClientData(clientData);
4021 self->SetClientObject(n, data);
4022 }
4023
4024
4025 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4026 wxPyUserData* data = NULL;
4027 if ( userData ) {
4028 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4029 data = new wxPyUserData(userData);
4030 wxPyEndBlockThreads(blocked);
4031 }
4032 return new wxSizerItem(window, proportion, flag, border, data);
4033 }
4034 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4035 wxPyUserData* data = NULL;
4036 if ( userData ) {
4037 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4038 data = new wxPyUserData(userData);
4039 wxPyEndBlockThreads(blocked);
4040 }
4041 return new wxSizerItem(width, height, proportion, flag, border, data);
4042 }
4043 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4044 wxPyUserData* data = NULL;
4045 if ( userData ) {
4046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4047 data = new wxPyUserData(userData);
4048 wxPyEndBlockThreads(blocked);
4049 }
4050 return new wxSizerItem(sizer, proportion, flag, border, data);
4051 }
4052
4053 SWIGINTERNINLINE PyObject *
4054 SWIG_From_float (float value)
4055 {
4056 return SWIG_From_double (value);
4057 }
4058
4059 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4060 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4061 if (data) {
4062 Py_INCREF(data->m_obj);
4063 return data->m_obj;
4064 } else {
4065 Py_INCREF(Py_None);
4066 return Py_None;
4067 }
4068 }
4069 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4070 wxPyUserData* data = NULL;
4071 if ( userData ) {
4072 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4073 data = new wxPyUserData(userData);
4074 wxPyEndBlockThreads(blocked);
4075 }
4076 self->SetUserData(data);
4077 }
4078
4079 // Figure out the type of the sizer item
4080
4081 struct wxPySizerItemInfo {
4082 wxPySizerItemInfo()
4083 : window(NULL), sizer(NULL), gotSize(false),
4084 size(wxDefaultSize), gotPos(false), pos(-1)
4085 {}
4086
4087 wxWindow* window;
4088 wxSizer* sizer;
4089 bool gotSize;
4090 wxSize size;
4091 bool gotPos;
4092 int pos;
4093 };
4094
4095 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4096
4097 wxPySizerItemInfo info;
4098 wxSize size;
4099 wxSize* sizePtr = &size;
4100
4101 // Find out what the type of the item is
4102 // try wxWindow
4103 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4104 PyErr_Clear();
4105 info.window = NULL;
4106
4107 // try wxSizer
4108 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4109 PyErr_Clear();
4110 info.sizer = NULL;
4111
4112 // try wxSize or (w,h)
4113 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4114 info.size = *sizePtr;
4115 info.gotSize = true;
4116 }
4117
4118 // or a single int
4119 if (checkIdx && PyInt_Check(item)) {
4120 info.pos = PyInt_AsLong(item);
4121 info.gotPos = true;
4122 }
4123 }
4124 }
4125
4126 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4127 // no expected type, figure out what kind of error message to generate
4128 if ( !checkSize && !checkIdx )
4129 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4130 else if ( checkSize && !checkIdx )
4131 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4132 else if ( !checkSize && checkIdx)
4133 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4134 else
4135 // can this one happen?
4136 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4137 }
4138
4139 return info;
4140 }
4141
4142 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4143 if (!self->GetClientObject())
4144 self->SetClientObject(new wxPyOORClientData(_self));
4145 }
4146 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4147
4148 wxPyUserData* data = NULL;
4149 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4150 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4151 if ( userData && (info.window || info.sizer || info.gotSize) )
4152 data = new wxPyUserData(userData);
4153 if ( info.sizer )
4154 PyObject_SetAttrString(item,"thisown",Py_False);
4155 wxPyEndBlockThreads(blocked);
4156
4157 // Now call the real Add method if a valid item type was found
4158 if ( info.window )
4159 return self->Add(info.window, proportion, flag, border, data);
4160 else if ( info.sizer )
4161 return self->Add(info.sizer, proportion, flag, border, data);
4162 else if (info.gotSize)
4163 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4164 proportion, flag, border, data);
4165 else
4166 return NULL;
4167 }
4168 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4169
4170 wxPyUserData* data = NULL;
4171 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4172 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4173 if ( userData && (info.window || info.sizer || info.gotSize) )
4174 data = new wxPyUserData(userData);
4175 if ( info.sizer )
4176 PyObject_SetAttrString(item,"thisown",Py_False);
4177 wxPyEndBlockThreads(blocked);
4178
4179 // Now call the real Insert method if a valid item type was found
4180 if ( info.window )
4181 return self->Insert(before, info.window, proportion, flag, border, data);
4182 else if ( info.sizer )
4183 return self->Insert(before, info.sizer, proportion, flag, border, data);
4184 else if (info.gotSize)
4185 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4186 proportion, flag, border, data);
4187 else
4188 return NULL;
4189 }
4190 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4191
4192 wxPyUserData* data = NULL;
4193 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4194 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4195 if ( userData && (info.window || info.sizer || info.gotSize) )
4196 data = new wxPyUserData(userData);
4197 if ( info.sizer )
4198 PyObject_SetAttrString(item,"thisown",Py_False);
4199 wxPyEndBlockThreads(blocked);
4200
4201 // Now call the real Prepend method if a valid item type was found
4202 if ( info.window )
4203 return self->Prepend(info.window, proportion, flag, border, data);
4204 else if ( info.sizer )
4205 return self->Prepend(info.sizer, proportion, flag, border, data);
4206 else if (info.gotSize)
4207 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4208 proportion, flag, border, data);
4209 else
4210 return NULL;
4211 }
4212 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4213 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4214 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4215 wxPyEndBlockThreads(blocked);
4216 if ( info.window )
4217 return self->Remove(info.window);
4218 else if ( info.sizer )
4219 return self->Remove(info.sizer);
4220 else if ( info.gotPos )
4221 return self->Remove(info.pos);
4222 else
4223 return false;
4224 }
4225 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4226 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4227 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4228 wxPyEndBlockThreads(blocked);
4229 if ( info.window )
4230 return self->Detach(info.window);
4231 else if ( info.sizer )
4232 return self->Detach(info.sizer);
4233 else if ( info.gotPos )
4234 return self->Detach(info.pos);
4235 else
4236 return false;
4237 }
4238 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4239 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4240 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4241 wxPyEndBlockThreads(blocked);
4242 if ( info.window )
4243 return self->GetItem(info.window);
4244 else if ( info.sizer )
4245 return self->GetItem(info.sizer);
4246 else if ( info.gotPos )
4247 return self->GetItem(info.pos);
4248 else
4249 return NULL;
4250 }
4251 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4252 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4253 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4254 wxPyEndBlockThreads(blocked);
4255 if ( info.window )
4256 self->SetItemMinSize(info.window, size);
4257 else if ( info.sizer )
4258 self->SetItemMinSize(info.sizer, size);
4259 else if ( info.gotPos )
4260 self->SetItemMinSize(info.pos, size);
4261 }
4262 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4263 wxSizerItemList& list = self->GetChildren();
4264 return wxPy_ConvertList(&list);
4265 }
4266 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4267 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4268 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4269 wxPyEndBlockThreads(blocked);
4270 if ( info.window )
4271 return self->Show(info.window, show, recursive);
4272 else if ( info.sizer )
4273 return self->Show(info.sizer, show, recursive);
4274 else if ( info.gotPos )
4275 return self->Show(info.pos, show);
4276 else
4277 return false;
4278 }
4279 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4280 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4281 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4282 wxPyEndBlockThreads(blocked);
4283 if ( info.window )
4284 return self->IsShown(info.window);
4285 else if ( info.sizer )
4286 return self->IsShown(info.sizer);
4287 else if ( info.gotPos )
4288 return self->IsShown(info.pos);
4289 else
4290 return false;
4291 }
4292
4293 // See pyclasses.h
4294 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4295 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4296 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4297
4298
4299
4300
4301 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4302 {
4303 if (source == Py_None) {
4304 **obj = wxGBPosition(-1,-1);
4305 return true;
4306 }
4307 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4308 }
4309
4310 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4311 {
4312 if (source == Py_None) {
4313 **obj = wxGBSpan(-1,-1);
4314 return true;
4315 }
4316 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4317 }
4318
4319
4320 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4321 wxGBPosition temp, *obj = &temp;
4322 if ( other == Py_None ) return false;
4323 if ( ! wxGBPosition_helper(other, &obj) ) {
4324 PyErr_Clear();
4325 return false;
4326 }
4327 return self->operator==(*obj);
4328 }
4329 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4330 wxGBPosition temp, *obj = &temp;
4331 if ( other == Py_None ) return true;
4332 if ( ! wxGBPosition_helper(other, &obj)) {
4333 PyErr_Clear();
4334 return true;
4335 }
4336 return self->operator!=(*obj);
4337 }
4338 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4339 self->SetRow(row);
4340 self->SetCol(col);
4341 }
4342 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4343 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4344 PyObject* tup = PyTuple_New(2);
4345 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4346 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4347 wxPyEndBlockThreads(blocked);
4348 return tup;
4349 }
4350 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4351 wxGBSpan temp, *obj = &temp;
4352 if ( other == Py_None ) return false;
4353 if ( ! wxGBSpan_helper(other, &obj) ) {
4354 PyErr_Clear();
4355 return false;
4356 }
4357 return self->operator==(*obj);
4358 }
4359 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4360 wxGBSpan temp, *obj = &temp;
4361 if ( other == Py_None ) return true;
4362 if ( ! wxGBSpan_helper(other, &obj)) {
4363 PyErr_Clear();
4364 return true;
4365 }
4366 return self->operator!=(*obj);
4367 }
4368 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4369 self->SetRowspan(rowspan);
4370 self->SetColspan(colspan);
4371 }
4372 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4373 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4374 PyObject* tup = PyTuple_New(2);
4375 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4376 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4377 wxPyEndBlockThreads(blocked);
4378 return tup;
4379 }
4380 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4381 wxPyUserData* data = NULL;
4382 if ( userData ) {
4383 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4384 data = new wxPyUserData(userData);
4385 wxPyEndBlockThreads(blocked);
4386 }
4387 return new wxGBSizerItem(window, pos, span, flag, border, data);
4388 }
4389 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4390 wxPyUserData* data = NULL;
4391 if ( userData ) {
4392 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4393 data = new wxPyUserData(userData);
4394 wxPyEndBlockThreads(blocked);
4395 }
4396 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4397 }
4398 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4399 wxPyUserData* data = NULL;
4400 if ( userData ) {
4401 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4402 data = new wxPyUserData(userData);
4403 wxPyEndBlockThreads(blocked);
4404 }
4405 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4406 }
4407 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4408 int row, col;
4409 self->GetEndPos(row, col);
4410 return wxGBPosition(row, col);
4411 }
4412 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4413
4414 wxPyUserData* data = NULL;
4415 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4416 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4417 if ( userData && (info.window || info.sizer || info.gotSize) )
4418 data = new wxPyUserData(userData);
4419 if ( info.sizer )
4420 PyObject_SetAttrString(item,"thisown",Py_False);
4421 wxPyEndBlockThreads(blocked);
4422
4423 // Now call the real Add method if a valid item type was found
4424 if ( info.window )
4425 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4426 else if ( info.sizer )
4427 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4428 else if (info.gotSize)
4429 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4430 pos, span, flag, border, data);
4431 return NULL;
4432 }
4433
4434
4435 #ifdef __cplusplus
4436 extern "C" {
4437 #endif
4438 SWIGINTERN int EmptyString_set(PyObject *) {
4439 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4440 return 1;
4441 }
4442
4443
4444 SWIGINTERN PyObject *EmptyString_get(void) {
4445 PyObject *pyobj = 0;
4446
4447 {
4448 #if wxUSE_UNICODE
4449 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4450 #else
4451 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4452 #endif
4453 }
4454 return pyobj;
4455 }
4456
4457
4458 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4459 PyObject *resultobj = 0;
4460 wxObject *arg1 = (wxObject *) 0 ;
4461 wxString result;
4462 void *argp1 = 0 ;
4463 int res1 = 0 ;
4464 PyObject *swig_obj[1] ;
4465
4466 if (!args) SWIG_fail;
4467 swig_obj[0] = args;
4468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4469 if (!SWIG_IsOK(res1)) {
4470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4471 }
4472 arg1 = reinterpret_cast< wxObject * >(argp1);
4473 {
4474 PyThreadState* __tstate = wxPyBeginAllowThreads();
4475 result = wxObject_GetClassName(arg1);
4476 wxPyEndAllowThreads(__tstate);
4477 if (PyErr_Occurred()) SWIG_fail;
4478 }
4479 {
4480 #if wxUSE_UNICODE
4481 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4482 #else
4483 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4484 #endif
4485 }
4486 return resultobj;
4487 fail:
4488 return NULL;
4489 }
4490
4491
4492 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4493 PyObject *resultobj = 0;
4494 wxObject *arg1 = (wxObject *) 0 ;
4495 void *argp1 = 0 ;
4496 int res1 = 0 ;
4497 PyObject *swig_obj[1] ;
4498
4499 if (!args) SWIG_fail;
4500 swig_obj[0] = args;
4501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4502 if (!SWIG_IsOK(res1)) {
4503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4504 }
4505 arg1 = reinterpret_cast< wxObject * >(argp1);
4506 {
4507 PyThreadState* __tstate = wxPyBeginAllowThreads();
4508 wxObject_Destroy(arg1);
4509 wxPyEndAllowThreads(__tstate);
4510 if (PyErr_Occurred()) SWIG_fail;
4511 }
4512 resultobj = SWIG_Py_Void();
4513 return resultobj;
4514 fail:
4515 return NULL;
4516 }
4517
4518
4519 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4520 PyObject *resultobj = 0;
4521 wxObject *arg1 = (wxObject *) 0 ;
4522 wxObject *arg2 = 0 ;
4523 bool result;
4524 void *argp1 = 0 ;
4525 int res1 = 0 ;
4526 void *argp2 = 0 ;
4527 int res2 = 0 ;
4528 PyObject * obj0 = 0 ;
4529 PyObject * obj1 = 0 ;
4530 char * kwnames[] = {
4531 (char *) "self",(char *) "p", NULL
4532 };
4533
4534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4536 if (!SWIG_IsOK(res1)) {
4537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4538 }
4539 arg1 = reinterpret_cast< wxObject * >(argp1);
4540 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4541 if (!SWIG_IsOK(res2)) {
4542 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4543 }
4544 if (!argp2) {
4545 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4546 }
4547 arg2 = reinterpret_cast< wxObject * >(argp2);
4548 {
4549 PyThreadState* __tstate = wxPyBeginAllowThreads();
4550 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4551 wxPyEndAllowThreads(__tstate);
4552 if (PyErr_Occurred()) SWIG_fail;
4553 }
4554 {
4555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4556 }
4557 return resultobj;
4558 fail:
4559 return NULL;
4560 }
4561
4562
4563 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4564 PyObject *obj;
4565 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4566 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4567 return SWIG_Py_Void();
4568 }
4569
4570 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4571 PyObject *resultobj = 0;
4572 wxSize *arg1 = (wxSize *) 0 ;
4573 int arg2 ;
4574 void *argp1 = 0 ;
4575 int res1 = 0 ;
4576 int val2 ;
4577 int ecode2 = 0 ;
4578 PyObject *swig_obj[2] ;
4579
4580 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4582 if (!SWIG_IsOK(res1)) {
4583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4584 }
4585 arg1 = reinterpret_cast< wxSize * >(argp1);
4586 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4587 if (!SWIG_IsOK(ecode2)) {
4588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4589 }
4590 arg2 = static_cast< int >(val2);
4591 if (arg1) (arg1)->x = arg2;
4592
4593 resultobj = SWIG_Py_Void();
4594 return resultobj;
4595 fail:
4596 return NULL;
4597 }
4598
4599
4600 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4601 PyObject *resultobj = 0;
4602 wxSize *arg1 = (wxSize *) 0 ;
4603 int result;
4604 void *argp1 = 0 ;
4605 int res1 = 0 ;
4606 PyObject *swig_obj[1] ;
4607
4608 if (!args) SWIG_fail;
4609 swig_obj[0] = args;
4610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4611 if (!SWIG_IsOK(res1)) {
4612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4613 }
4614 arg1 = reinterpret_cast< wxSize * >(argp1);
4615 result = (int) ((arg1)->x);
4616 resultobj = SWIG_From_int(static_cast< int >(result));
4617 return resultobj;
4618 fail:
4619 return NULL;
4620 }
4621
4622
4623 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4624 PyObject *resultobj = 0;
4625 wxSize *arg1 = (wxSize *) 0 ;
4626 int arg2 ;
4627 void *argp1 = 0 ;
4628 int res1 = 0 ;
4629 int val2 ;
4630 int ecode2 = 0 ;
4631 PyObject *swig_obj[2] ;
4632
4633 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4635 if (!SWIG_IsOK(res1)) {
4636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4637 }
4638 arg1 = reinterpret_cast< wxSize * >(argp1);
4639 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4640 if (!SWIG_IsOK(ecode2)) {
4641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4642 }
4643 arg2 = static_cast< int >(val2);
4644 if (arg1) (arg1)->y = arg2;
4645
4646 resultobj = SWIG_Py_Void();
4647 return resultobj;
4648 fail:
4649 return NULL;
4650 }
4651
4652
4653 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4654 PyObject *resultobj = 0;
4655 wxSize *arg1 = (wxSize *) 0 ;
4656 int result;
4657 void *argp1 = 0 ;
4658 int res1 = 0 ;
4659 PyObject *swig_obj[1] ;
4660
4661 if (!args) SWIG_fail;
4662 swig_obj[0] = args;
4663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4664 if (!SWIG_IsOK(res1)) {
4665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4666 }
4667 arg1 = reinterpret_cast< wxSize * >(argp1);
4668 result = (int) ((arg1)->y);
4669 resultobj = SWIG_From_int(static_cast< int >(result));
4670 return resultobj;
4671 fail:
4672 return NULL;
4673 }
4674
4675
4676 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4677 PyObject *resultobj = 0;
4678 int arg1 = (int) 0 ;
4679 int arg2 = (int) 0 ;
4680 wxSize *result = 0 ;
4681 int val1 ;
4682 int ecode1 = 0 ;
4683 int val2 ;
4684 int ecode2 = 0 ;
4685 PyObject * obj0 = 0 ;
4686 PyObject * obj1 = 0 ;
4687 char * kwnames[] = {
4688 (char *) "w",(char *) "h", NULL
4689 };
4690
4691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4692 if (obj0) {
4693 ecode1 = SWIG_AsVal_int(obj0, &val1);
4694 if (!SWIG_IsOK(ecode1)) {
4695 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4696 }
4697 arg1 = static_cast< int >(val1);
4698 }
4699 if (obj1) {
4700 ecode2 = SWIG_AsVal_int(obj1, &val2);
4701 if (!SWIG_IsOK(ecode2)) {
4702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4703 }
4704 arg2 = static_cast< int >(val2);
4705 }
4706 {
4707 result = (wxSize *)new wxSize(arg1,arg2);
4708 if (PyErr_Occurred()) SWIG_fail;
4709 }
4710 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4711 return resultobj;
4712 fail:
4713 return NULL;
4714 }
4715
4716
4717 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4718 PyObject *resultobj = 0;
4719 wxSize *arg1 = (wxSize *) 0 ;
4720 void *argp1 = 0 ;
4721 int res1 = 0 ;
4722 PyObject *swig_obj[1] ;
4723
4724 if (!args) SWIG_fail;
4725 swig_obj[0] = args;
4726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4727 if (!SWIG_IsOK(res1)) {
4728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4729 }
4730 arg1 = reinterpret_cast< wxSize * >(argp1);
4731 {
4732 delete arg1;
4733
4734 if (PyErr_Occurred()) SWIG_fail;
4735 }
4736 resultobj = SWIG_Py_Void();
4737 return resultobj;
4738 fail:
4739 return NULL;
4740 }
4741
4742
4743 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4744 PyObject *resultobj = 0;
4745 wxSize *arg1 = (wxSize *) 0 ;
4746 PyObject *arg2 = (PyObject *) 0 ;
4747 bool result;
4748 void *argp1 = 0 ;
4749 int res1 = 0 ;
4750 PyObject * obj0 = 0 ;
4751 PyObject * obj1 = 0 ;
4752 char * kwnames[] = {
4753 (char *) "self",(char *) "other", NULL
4754 };
4755
4756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4758 if (!SWIG_IsOK(res1)) {
4759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4760 }
4761 arg1 = reinterpret_cast< wxSize * >(argp1);
4762 arg2 = obj1;
4763 {
4764 result = (bool)wxSize___eq__(arg1,arg2);
4765 if (PyErr_Occurred()) SWIG_fail;
4766 }
4767 {
4768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4769 }
4770 return resultobj;
4771 fail:
4772 return NULL;
4773 }
4774
4775
4776 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4777 PyObject *resultobj = 0;
4778 wxSize *arg1 = (wxSize *) 0 ;
4779 PyObject *arg2 = (PyObject *) 0 ;
4780 bool result;
4781 void *argp1 = 0 ;
4782 int res1 = 0 ;
4783 PyObject * obj0 = 0 ;
4784 PyObject * obj1 = 0 ;
4785 char * kwnames[] = {
4786 (char *) "self",(char *) "other", NULL
4787 };
4788
4789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4791 if (!SWIG_IsOK(res1)) {
4792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4793 }
4794 arg1 = reinterpret_cast< wxSize * >(argp1);
4795 arg2 = obj1;
4796 {
4797 result = (bool)wxSize___ne__(arg1,arg2);
4798 if (PyErr_Occurred()) SWIG_fail;
4799 }
4800 {
4801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4802 }
4803 return resultobj;
4804 fail:
4805 return NULL;
4806 }
4807
4808
4809 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4810 PyObject *resultobj = 0;
4811 wxSize *arg1 = (wxSize *) 0 ;
4812 wxSize *arg2 = 0 ;
4813 wxSize result;
4814 void *argp1 = 0 ;
4815 int res1 = 0 ;
4816 wxSize temp2 ;
4817 PyObject * obj0 = 0 ;
4818 PyObject * obj1 = 0 ;
4819 char * kwnames[] = {
4820 (char *) "self",(char *) "sz", NULL
4821 };
4822
4823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4825 if (!SWIG_IsOK(res1)) {
4826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4827 }
4828 arg1 = reinterpret_cast< wxSize * >(argp1);
4829 {
4830 arg2 = &temp2;
4831 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4832 }
4833 {
4834 result = (arg1)->operator +((wxSize const &)*arg2);
4835 if (PyErr_Occurred()) SWIG_fail;
4836 }
4837 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4838 return resultobj;
4839 fail:
4840 return NULL;
4841 }
4842
4843
4844 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4845 PyObject *resultobj = 0;
4846 wxSize *arg1 = (wxSize *) 0 ;
4847 wxSize *arg2 = 0 ;
4848 wxSize result;
4849 void *argp1 = 0 ;
4850 int res1 = 0 ;
4851 wxSize temp2 ;
4852 PyObject * obj0 = 0 ;
4853 PyObject * obj1 = 0 ;
4854 char * kwnames[] = {
4855 (char *) "self",(char *) "sz", NULL
4856 };
4857
4858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4860 if (!SWIG_IsOK(res1)) {
4861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4862 }
4863 arg1 = reinterpret_cast< wxSize * >(argp1);
4864 {
4865 arg2 = &temp2;
4866 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4867 }
4868 {
4869 result = (arg1)->operator -((wxSize const &)*arg2);
4870 if (PyErr_Occurred()) SWIG_fail;
4871 }
4872 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4873 return resultobj;
4874 fail:
4875 return NULL;
4876 }
4877
4878
4879 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4880 PyObject *resultobj = 0;
4881 wxSize *arg1 = (wxSize *) 0 ;
4882 wxSize *arg2 = 0 ;
4883 void *argp1 = 0 ;
4884 int res1 = 0 ;
4885 wxSize temp2 ;
4886 PyObject * obj0 = 0 ;
4887 PyObject * obj1 = 0 ;
4888 char * kwnames[] = {
4889 (char *) "self",(char *) "sz", NULL
4890 };
4891
4892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4894 if (!SWIG_IsOK(res1)) {
4895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4896 }
4897 arg1 = reinterpret_cast< wxSize * >(argp1);
4898 {
4899 arg2 = &temp2;
4900 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4901 }
4902 {
4903 (arg1)->IncTo((wxSize const &)*arg2);
4904 if (PyErr_Occurred()) SWIG_fail;
4905 }
4906 resultobj = SWIG_Py_Void();
4907 return resultobj;
4908 fail:
4909 return NULL;
4910 }
4911
4912
4913 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4914 PyObject *resultobj = 0;
4915 wxSize *arg1 = (wxSize *) 0 ;
4916 wxSize *arg2 = 0 ;
4917 void *argp1 = 0 ;
4918 int res1 = 0 ;
4919 wxSize temp2 ;
4920 PyObject * obj0 = 0 ;
4921 PyObject * obj1 = 0 ;
4922 char * kwnames[] = {
4923 (char *) "self",(char *) "sz", NULL
4924 };
4925
4926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4928 if (!SWIG_IsOK(res1)) {
4929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4930 }
4931 arg1 = reinterpret_cast< wxSize * >(argp1);
4932 {
4933 arg2 = &temp2;
4934 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4935 }
4936 {
4937 (arg1)->DecTo((wxSize const &)*arg2);
4938 if (PyErr_Occurred()) SWIG_fail;
4939 }
4940 resultobj = SWIG_Py_Void();
4941 return resultobj;
4942 fail:
4943 return NULL;
4944 }
4945
4946
4947 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4948 PyObject *resultobj = 0;
4949 wxSize *arg1 = (wxSize *) 0 ;
4950 int arg2 ;
4951 int arg3 ;
4952 void *argp1 = 0 ;
4953 int res1 = 0 ;
4954 int val2 ;
4955 int ecode2 = 0 ;
4956 int val3 ;
4957 int ecode3 = 0 ;
4958 PyObject * obj0 = 0 ;
4959 PyObject * obj1 = 0 ;
4960 PyObject * obj2 = 0 ;
4961 char * kwnames[] = {
4962 (char *) "self",(char *) "dx",(char *) "dy", NULL
4963 };
4964
4965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4967 if (!SWIG_IsOK(res1)) {
4968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4969 }
4970 arg1 = reinterpret_cast< wxSize * >(argp1);
4971 ecode2 = SWIG_AsVal_int(obj1, &val2);
4972 if (!SWIG_IsOK(ecode2)) {
4973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4974 }
4975 arg2 = static_cast< int >(val2);
4976 ecode3 = SWIG_AsVal_int(obj2, &val3);
4977 if (!SWIG_IsOK(ecode3)) {
4978 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4979 }
4980 arg3 = static_cast< int >(val3);
4981 {
4982 (arg1)->IncBy(arg2,arg3);
4983 if (PyErr_Occurred()) SWIG_fail;
4984 }
4985 resultobj = SWIG_Py_Void();
4986 return resultobj;
4987 fail:
4988 return NULL;
4989 }
4990
4991
4992 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4993 PyObject *resultobj = 0;
4994 wxSize *arg1 = (wxSize *) 0 ;
4995 int arg2 ;
4996 int arg3 ;
4997 void *argp1 = 0 ;
4998 int res1 = 0 ;
4999 int val2 ;
5000 int ecode2 = 0 ;
5001 int val3 ;
5002 int ecode3 = 0 ;
5003 PyObject * obj0 = 0 ;
5004 PyObject * obj1 = 0 ;
5005 PyObject * obj2 = 0 ;
5006 char * kwnames[] = {
5007 (char *) "self",(char *) "dx",(char *) "dy", NULL
5008 };
5009
5010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5012 if (!SWIG_IsOK(res1)) {
5013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
5014 }
5015 arg1 = reinterpret_cast< wxSize * >(argp1);
5016 ecode2 = SWIG_AsVal_int(obj1, &val2);
5017 if (!SWIG_IsOK(ecode2)) {
5018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5019 }
5020 arg2 = static_cast< int >(val2);
5021 ecode3 = SWIG_AsVal_int(obj2, &val3);
5022 if (!SWIG_IsOK(ecode3)) {
5023 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5024 }
5025 arg3 = static_cast< int >(val3);
5026 {
5027 (arg1)->DecBy(arg2,arg3);
5028 if (PyErr_Occurred()) SWIG_fail;
5029 }
5030 resultobj = SWIG_Py_Void();
5031 return resultobj;
5032 fail:
5033 return NULL;
5034 }
5035
5036
5037 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5038 PyObject *resultobj = 0;
5039 wxSize *arg1 = (wxSize *) 0 ;
5040 float arg2 ;
5041 float arg3 ;
5042 void *argp1 = 0 ;
5043 int res1 = 0 ;
5044 float val2 ;
5045 int ecode2 = 0 ;
5046 float val3 ;
5047 int ecode3 = 0 ;
5048 PyObject * obj0 = 0 ;
5049 PyObject * obj1 = 0 ;
5050 PyObject * obj2 = 0 ;
5051 char * kwnames[] = {
5052 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5053 };
5054
5055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5057 if (!SWIG_IsOK(res1)) {
5058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5059 }
5060 arg1 = reinterpret_cast< wxSize * >(argp1);
5061 ecode2 = SWIG_AsVal_float(obj1, &val2);
5062 if (!SWIG_IsOK(ecode2)) {
5063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5064 }
5065 arg2 = static_cast< float >(val2);
5066 ecode3 = SWIG_AsVal_float(obj2, &val3);
5067 if (!SWIG_IsOK(ecode3)) {
5068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5069 }
5070 arg3 = static_cast< float >(val3);
5071 {
5072 (arg1)->Scale(arg2,arg3);
5073 if (PyErr_Occurred()) SWIG_fail;
5074 }
5075 resultobj = SWIG_Py_Void();
5076 return resultobj;
5077 fail:
5078 return NULL;
5079 }
5080
5081
5082 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5083 PyObject *resultobj = 0;
5084 wxSize *arg1 = (wxSize *) 0 ;
5085 int arg2 ;
5086 int arg3 ;
5087 void *argp1 = 0 ;
5088 int res1 = 0 ;
5089 int val2 ;
5090 int ecode2 = 0 ;
5091 int val3 ;
5092 int ecode3 = 0 ;
5093 PyObject * obj0 = 0 ;
5094 PyObject * obj1 = 0 ;
5095 PyObject * obj2 = 0 ;
5096 char * kwnames[] = {
5097 (char *) "self",(char *) "w",(char *) "h", NULL
5098 };
5099
5100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5102 if (!SWIG_IsOK(res1)) {
5103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5104 }
5105 arg1 = reinterpret_cast< wxSize * >(argp1);
5106 ecode2 = SWIG_AsVal_int(obj1, &val2);
5107 if (!SWIG_IsOK(ecode2)) {
5108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5109 }
5110 arg2 = static_cast< int >(val2);
5111 ecode3 = SWIG_AsVal_int(obj2, &val3);
5112 if (!SWIG_IsOK(ecode3)) {
5113 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5114 }
5115 arg3 = static_cast< int >(val3);
5116 {
5117 (arg1)->Set(arg2,arg3);
5118 if (PyErr_Occurred()) SWIG_fail;
5119 }
5120 resultobj = SWIG_Py_Void();
5121 return resultobj;
5122 fail:
5123 return NULL;
5124 }
5125
5126
5127 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5128 PyObject *resultobj = 0;
5129 wxSize *arg1 = (wxSize *) 0 ;
5130 int arg2 ;
5131 void *argp1 = 0 ;
5132 int res1 = 0 ;
5133 int val2 ;
5134 int ecode2 = 0 ;
5135 PyObject * obj0 = 0 ;
5136 PyObject * obj1 = 0 ;
5137 char * kwnames[] = {
5138 (char *) "self",(char *) "w", NULL
5139 };
5140
5141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5143 if (!SWIG_IsOK(res1)) {
5144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5145 }
5146 arg1 = reinterpret_cast< wxSize * >(argp1);
5147 ecode2 = SWIG_AsVal_int(obj1, &val2);
5148 if (!SWIG_IsOK(ecode2)) {
5149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5150 }
5151 arg2 = static_cast< int >(val2);
5152 {
5153 (arg1)->SetWidth(arg2);
5154 if (PyErr_Occurred()) SWIG_fail;
5155 }
5156 resultobj = SWIG_Py_Void();
5157 return resultobj;
5158 fail:
5159 return NULL;
5160 }
5161
5162
5163 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5164 PyObject *resultobj = 0;
5165 wxSize *arg1 = (wxSize *) 0 ;
5166 int arg2 ;
5167 void *argp1 = 0 ;
5168 int res1 = 0 ;
5169 int val2 ;
5170 int ecode2 = 0 ;
5171 PyObject * obj0 = 0 ;
5172 PyObject * obj1 = 0 ;
5173 char * kwnames[] = {
5174 (char *) "self",(char *) "h", NULL
5175 };
5176
5177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5179 if (!SWIG_IsOK(res1)) {
5180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5181 }
5182 arg1 = reinterpret_cast< wxSize * >(argp1);
5183 ecode2 = SWIG_AsVal_int(obj1, &val2);
5184 if (!SWIG_IsOK(ecode2)) {
5185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5186 }
5187 arg2 = static_cast< int >(val2);
5188 {
5189 (arg1)->SetHeight(arg2);
5190 if (PyErr_Occurred()) SWIG_fail;
5191 }
5192 resultobj = SWIG_Py_Void();
5193 return resultobj;
5194 fail:
5195 return NULL;
5196 }
5197
5198
5199 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5200 PyObject *resultobj = 0;
5201 wxSize *arg1 = (wxSize *) 0 ;
5202 int result;
5203 void *argp1 = 0 ;
5204 int res1 = 0 ;
5205 PyObject *swig_obj[1] ;
5206
5207 if (!args) SWIG_fail;
5208 swig_obj[0] = args;
5209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5210 if (!SWIG_IsOK(res1)) {
5211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5212 }
5213 arg1 = reinterpret_cast< wxSize * >(argp1);
5214 {
5215 result = (int)((wxSize const *)arg1)->GetWidth();
5216 if (PyErr_Occurred()) SWIG_fail;
5217 }
5218 resultobj = SWIG_From_int(static_cast< int >(result));
5219 return resultobj;
5220 fail:
5221 return NULL;
5222 }
5223
5224
5225 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5226 PyObject *resultobj = 0;
5227 wxSize *arg1 = (wxSize *) 0 ;
5228 int result;
5229 void *argp1 = 0 ;
5230 int res1 = 0 ;
5231 PyObject *swig_obj[1] ;
5232
5233 if (!args) SWIG_fail;
5234 swig_obj[0] = args;
5235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5236 if (!SWIG_IsOK(res1)) {
5237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5238 }
5239 arg1 = reinterpret_cast< wxSize * >(argp1);
5240 {
5241 result = (int)((wxSize const *)arg1)->GetHeight();
5242 if (PyErr_Occurred()) SWIG_fail;
5243 }
5244 resultobj = SWIG_From_int(static_cast< int >(result));
5245 return resultobj;
5246 fail:
5247 return NULL;
5248 }
5249
5250
5251 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5252 PyObject *resultobj = 0;
5253 wxSize *arg1 = (wxSize *) 0 ;
5254 bool result;
5255 void *argp1 = 0 ;
5256 int res1 = 0 ;
5257 PyObject *swig_obj[1] ;
5258
5259 if (!args) SWIG_fail;
5260 swig_obj[0] = args;
5261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5262 if (!SWIG_IsOK(res1)) {
5263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5264 }
5265 arg1 = reinterpret_cast< wxSize * >(argp1);
5266 {
5267 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5268 if (PyErr_Occurred()) SWIG_fail;
5269 }
5270 {
5271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5272 }
5273 return resultobj;
5274 fail:
5275 return NULL;
5276 }
5277
5278
5279 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5280 PyObject *resultobj = 0;
5281 wxSize *arg1 = (wxSize *) 0 ;
5282 wxSize *arg2 = 0 ;
5283 void *argp1 = 0 ;
5284 int res1 = 0 ;
5285 wxSize temp2 ;
5286 PyObject * obj0 = 0 ;
5287 PyObject * obj1 = 0 ;
5288 char * kwnames[] = {
5289 (char *) "self",(char *) "size", NULL
5290 };
5291
5292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5294 if (!SWIG_IsOK(res1)) {
5295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5296 }
5297 arg1 = reinterpret_cast< wxSize * >(argp1);
5298 {
5299 arg2 = &temp2;
5300 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5301 }
5302 {
5303 (arg1)->SetDefaults((wxSize const &)*arg2);
5304 if (PyErr_Occurred()) SWIG_fail;
5305 }
5306 resultobj = SWIG_Py_Void();
5307 return resultobj;
5308 fail:
5309 return NULL;
5310 }
5311
5312
5313 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5314 PyObject *resultobj = 0;
5315 wxSize *arg1 = (wxSize *) 0 ;
5316 PyObject *result = 0 ;
5317 void *argp1 = 0 ;
5318 int res1 = 0 ;
5319 PyObject *swig_obj[1] ;
5320
5321 if (!args) SWIG_fail;
5322 swig_obj[0] = args;
5323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5324 if (!SWIG_IsOK(res1)) {
5325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5326 }
5327 arg1 = reinterpret_cast< wxSize * >(argp1);
5328 {
5329 result = (PyObject *)wxSize_Get(arg1);
5330 if (PyErr_Occurred()) SWIG_fail;
5331 }
5332 resultobj = result;
5333 return resultobj;
5334 fail:
5335 return NULL;
5336 }
5337
5338
5339 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5340 PyObject *obj;
5341 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5342 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5343 return SWIG_Py_Void();
5344 }
5345
5346 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5347 return SWIG_Python_InitShadowInstance(args);
5348 }
5349
5350 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5351 PyObject *resultobj = 0;
5352 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5353 double arg2 ;
5354 void *argp1 = 0 ;
5355 int res1 = 0 ;
5356 double val2 ;
5357 int ecode2 = 0 ;
5358 PyObject *swig_obj[2] ;
5359
5360 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5362 if (!SWIG_IsOK(res1)) {
5363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5364 }
5365 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5366 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5367 if (!SWIG_IsOK(ecode2)) {
5368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5369 }
5370 arg2 = static_cast< double >(val2);
5371 if (arg1) (arg1)->x = arg2;
5372
5373 resultobj = SWIG_Py_Void();
5374 return resultobj;
5375 fail:
5376 return NULL;
5377 }
5378
5379
5380 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5381 PyObject *resultobj = 0;
5382 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5383 double result;
5384 void *argp1 = 0 ;
5385 int res1 = 0 ;
5386 PyObject *swig_obj[1] ;
5387
5388 if (!args) SWIG_fail;
5389 swig_obj[0] = args;
5390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5391 if (!SWIG_IsOK(res1)) {
5392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5393 }
5394 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5395 result = (double) ((arg1)->x);
5396 resultobj = SWIG_From_double(static_cast< double >(result));
5397 return resultobj;
5398 fail:
5399 return NULL;
5400 }
5401
5402
5403 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5404 PyObject *resultobj = 0;
5405 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5406 double arg2 ;
5407 void *argp1 = 0 ;
5408 int res1 = 0 ;
5409 double val2 ;
5410 int ecode2 = 0 ;
5411 PyObject *swig_obj[2] ;
5412
5413 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5415 if (!SWIG_IsOK(res1)) {
5416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5417 }
5418 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5419 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5420 if (!SWIG_IsOK(ecode2)) {
5421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5422 }
5423 arg2 = static_cast< double >(val2);
5424 if (arg1) (arg1)->y = arg2;
5425
5426 resultobj = SWIG_Py_Void();
5427 return resultobj;
5428 fail:
5429 return NULL;
5430 }
5431
5432
5433 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5434 PyObject *resultobj = 0;
5435 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5436 double result;
5437 void *argp1 = 0 ;
5438 int res1 = 0 ;
5439 PyObject *swig_obj[1] ;
5440
5441 if (!args) SWIG_fail;
5442 swig_obj[0] = args;
5443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5444 if (!SWIG_IsOK(res1)) {
5445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5446 }
5447 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5448 result = (double) ((arg1)->y);
5449 resultobj = SWIG_From_double(static_cast< double >(result));
5450 return resultobj;
5451 fail:
5452 return NULL;
5453 }
5454
5455
5456 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5457 PyObject *resultobj = 0;
5458 double arg1 = (double) 0.0 ;
5459 double arg2 = (double) 0.0 ;
5460 wxRealPoint *result = 0 ;
5461 double val1 ;
5462 int ecode1 = 0 ;
5463 double val2 ;
5464 int ecode2 = 0 ;
5465 PyObject * obj0 = 0 ;
5466 PyObject * obj1 = 0 ;
5467 char * kwnames[] = {
5468 (char *) "x",(char *) "y", NULL
5469 };
5470
5471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5472 if (obj0) {
5473 ecode1 = SWIG_AsVal_double(obj0, &val1);
5474 if (!SWIG_IsOK(ecode1)) {
5475 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5476 }
5477 arg1 = static_cast< double >(val1);
5478 }
5479 if (obj1) {
5480 ecode2 = SWIG_AsVal_double(obj1, &val2);
5481 if (!SWIG_IsOK(ecode2)) {
5482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5483 }
5484 arg2 = static_cast< double >(val2);
5485 }
5486 {
5487 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5488 if (PyErr_Occurred()) SWIG_fail;
5489 }
5490 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5491 return resultobj;
5492 fail:
5493 return NULL;
5494 }
5495
5496
5497 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5498 PyObject *resultobj = 0;
5499 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5500 void *argp1 = 0 ;
5501 int res1 = 0 ;
5502 PyObject *swig_obj[1] ;
5503
5504 if (!args) SWIG_fail;
5505 swig_obj[0] = args;
5506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5507 if (!SWIG_IsOK(res1)) {
5508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5509 }
5510 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5511 {
5512 delete arg1;
5513
5514 if (PyErr_Occurred()) SWIG_fail;
5515 }
5516 resultobj = SWIG_Py_Void();
5517 return resultobj;
5518 fail:
5519 return NULL;
5520 }
5521
5522
5523 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5524 PyObject *resultobj = 0;
5525 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5526 PyObject *arg2 = (PyObject *) 0 ;
5527 bool result;
5528 void *argp1 = 0 ;
5529 int res1 = 0 ;
5530 PyObject * obj0 = 0 ;
5531 PyObject * obj1 = 0 ;
5532 char * kwnames[] = {
5533 (char *) "self",(char *) "other", NULL
5534 };
5535
5536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5538 if (!SWIG_IsOK(res1)) {
5539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5540 }
5541 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5542 arg2 = obj1;
5543 {
5544 result = (bool)wxRealPoint___eq__(arg1,arg2);
5545 if (PyErr_Occurred()) SWIG_fail;
5546 }
5547 {
5548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5549 }
5550 return resultobj;
5551 fail:
5552 return NULL;
5553 }
5554
5555
5556 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5557 PyObject *resultobj = 0;
5558 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5559 PyObject *arg2 = (PyObject *) 0 ;
5560 bool result;
5561 void *argp1 = 0 ;
5562 int res1 = 0 ;
5563 PyObject * obj0 = 0 ;
5564 PyObject * obj1 = 0 ;
5565 char * kwnames[] = {
5566 (char *) "self",(char *) "other", NULL
5567 };
5568
5569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5571 if (!SWIG_IsOK(res1)) {
5572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5573 }
5574 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5575 arg2 = obj1;
5576 {
5577 result = (bool)wxRealPoint___ne__(arg1,arg2);
5578 if (PyErr_Occurred()) SWIG_fail;
5579 }
5580 {
5581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5582 }
5583 return resultobj;
5584 fail:
5585 return NULL;
5586 }
5587
5588
5589 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5590 PyObject *resultobj = 0;
5591 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5592 wxRealPoint *arg2 = 0 ;
5593 wxRealPoint result;
5594 void *argp1 = 0 ;
5595 int res1 = 0 ;
5596 wxRealPoint temp2 ;
5597 PyObject * obj0 = 0 ;
5598 PyObject * obj1 = 0 ;
5599 char * kwnames[] = {
5600 (char *) "self",(char *) "pt", NULL
5601 };
5602
5603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5605 if (!SWIG_IsOK(res1)) {
5606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5607 }
5608 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5609 {
5610 arg2 = &temp2;
5611 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5612 }
5613 {
5614 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5615 if (PyErr_Occurred()) SWIG_fail;
5616 }
5617 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5618 return resultobj;
5619 fail:
5620 return NULL;
5621 }
5622
5623
5624 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5625 PyObject *resultobj = 0;
5626 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5627 wxRealPoint *arg2 = 0 ;
5628 wxRealPoint result;
5629 void *argp1 = 0 ;
5630 int res1 = 0 ;
5631 wxRealPoint temp2 ;
5632 PyObject * obj0 = 0 ;
5633 PyObject * obj1 = 0 ;
5634 char * kwnames[] = {
5635 (char *) "self",(char *) "pt", NULL
5636 };
5637
5638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5640 if (!SWIG_IsOK(res1)) {
5641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5642 }
5643 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5644 {
5645 arg2 = &temp2;
5646 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5647 }
5648 {
5649 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5650 if (PyErr_Occurred()) SWIG_fail;
5651 }
5652 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5653 return resultobj;
5654 fail:
5655 return NULL;
5656 }
5657
5658
5659 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5660 PyObject *resultobj = 0;
5661 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5662 double arg2 ;
5663 double arg3 ;
5664 void *argp1 = 0 ;
5665 int res1 = 0 ;
5666 double val2 ;
5667 int ecode2 = 0 ;
5668 double val3 ;
5669 int ecode3 = 0 ;
5670 PyObject * obj0 = 0 ;
5671 PyObject * obj1 = 0 ;
5672 PyObject * obj2 = 0 ;
5673 char * kwnames[] = {
5674 (char *) "self",(char *) "x",(char *) "y", NULL
5675 };
5676
5677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5679 if (!SWIG_IsOK(res1)) {
5680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5681 }
5682 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5683 ecode2 = SWIG_AsVal_double(obj1, &val2);
5684 if (!SWIG_IsOK(ecode2)) {
5685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5686 }
5687 arg2 = static_cast< double >(val2);
5688 ecode3 = SWIG_AsVal_double(obj2, &val3);
5689 if (!SWIG_IsOK(ecode3)) {
5690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5691 }
5692 arg3 = static_cast< double >(val3);
5693 {
5694 wxRealPoint_Set(arg1,arg2,arg3);
5695 if (PyErr_Occurred()) SWIG_fail;
5696 }
5697 resultobj = SWIG_Py_Void();
5698 return resultobj;
5699 fail:
5700 return NULL;
5701 }
5702
5703
5704 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5705 PyObject *resultobj = 0;
5706 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5707 PyObject *result = 0 ;
5708 void *argp1 = 0 ;
5709 int res1 = 0 ;
5710 PyObject *swig_obj[1] ;
5711
5712 if (!args) SWIG_fail;
5713 swig_obj[0] = args;
5714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5715 if (!SWIG_IsOK(res1)) {
5716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5717 }
5718 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5719 {
5720 result = (PyObject *)wxRealPoint_Get(arg1);
5721 if (PyErr_Occurred()) SWIG_fail;
5722 }
5723 resultobj = result;
5724 return resultobj;
5725 fail:
5726 return NULL;
5727 }
5728
5729
5730 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5731 PyObject *obj;
5732 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5733 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5734 return SWIG_Py_Void();
5735 }
5736
5737 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5738 return SWIG_Python_InitShadowInstance(args);
5739 }
5740
5741 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5742 PyObject *resultobj = 0;
5743 wxPoint *arg1 = (wxPoint *) 0 ;
5744 int arg2 ;
5745 void *argp1 = 0 ;
5746 int res1 = 0 ;
5747 int val2 ;
5748 int ecode2 = 0 ;
5749 PyObject *swig_obj[2] ;
5750
5751 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5753 if (!SWIG_IsOK(res1)) {
5754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5755 }
5756 arg1 = reinterpret_cast< wxPoint * >(argp1);
5757 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5758 if (!SWIG_IsOK(ecode2)) {
5759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5760 }
5761 arg2 = static_cast< int >(val2);
5762 if (arg1) (arg1)->x = arg2;
5763
5764 resultobj = SWIG_Py_Void();
5765 return resultobj;
5766 fail:
5767 return NULL;
5768 }
5769
5770
5771 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5772 PyObject *resultobj = 0;
5773 wxPoint *arg1 = (wxPoint *) 0 ;
5774 int result;
5775 void *argp1 = 0 ;
5776 int res1 = 0 ;
5777 PyObject *swig_obj[1] ;
5778
5779 if (!args) SWIG_fail;
5780 swig_obj[0] = args;
5781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5782 if (!SWIG_IsOK(res1)) {
5783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5784 }
5785 arg1 = reinterpret_cast< wxPoint * >(argp1);
5786 result = (int) ((arg1)->x);
5787 resultobj = SWIG_From_int(static_cast< int >(result));
5788 return resultobj;
5789 fail:
5790 return NULL;
5791 }
5792
5793
5794 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5795 PyObject *resultobj = 0;
5796 wxPoint *arg1 = (wxPoint *) 0 ;
5797 int arg2 ;
5798 void *argp1 = 0 ;
5799 int res1 = 0 ;
5800 int val2 ;
5801 int ecode2 = 0 ;
5802 PyObject *swig_obj[2] ;
5803
5804 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5806 if (!SWIG_IsOK(res1)) {
5807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5808 }
5809 arg1 = reinterpret_cast< wxPoint * >(argp1);
5810 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5811 if (!SWIG_IsOK(ecode2)) {
5812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5813 }
5814 arg2 = static_cast< int >(val2);
5815 if (arg1) (arg1)->y = arg2;
5816
5817 resultobj = SWIG_Py_Void();
5818 return resultobj;
5819 fail:
5820 return NULL;
5821 }
5822
5823
5824 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5825 PyObject *resultobj = 0;
5826 wxPoint *arg1 = (wxPoint *) 0 ;
5827 int result;
5828 void *argp1 = 0 ;
5829 int res1 = 0 ;
5830 PyObject *swig_obj[1] ;
5831
5832 if (!args) SWIG_fail;
5833 swig_obj[0] = args;
5834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5835 if (!SWIG_IsOK(res1)) {
5836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5837 }
5838 arg1 = reinterpret_cast< wxPoint * >(argp1);
5839 result = (int) ((arg1)->y);
5840 resultobj = SWIG_From_int(static_cast< int >(result));
5841 return resultobj;
5842 fail:
5843 return NULL;
5844 }
5845
5846
5847 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5848 PyObject *resultobj = 0;
5849 int arg1 = (int) 0 ;
5850 int arg2 = (int) 0 ;
5851 wxPoint *result = 0 ;
5852 int val1 ;
5853 int ecode1 = 0 ;
5854 int val2 ;
5855 int ecode2 = 0 ;
5856 PyObject * obj0 = 0 ;
5857 PyObject * obj1 = 0 ;
5858 char * kwnames[] = {
5859 (char *) "x",(char *) "y", NULL
5860 };
5861
5862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5863 if (obj0) {
5864 ecode1 = SWIG_AsVal_int(obj0, &val1);
5865 if (!SWIG_IsOK(ecode1)) {
5866 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5867 }
5868 arg1 = static_cast< int >(val1);
5869 }
5870 if (obj1) {
5871 ecode2 = SWIG_AsVal_int(obj1, &val2);
5872 if (!SWIG_IsOK(ecode2)) {
5873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5874 }
5875 arg2 = static_cast< int >(val2);
5876 }
5877 {
5878 result = (wxPoint *)new wxPoint(arg1,arg2);
5879 if (PyErr_Occurred()) SWIG_fail;
5880 }
5881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5882 return resultobj;
5883 fail:
5884 return NULL;
5885 }
5886
5887
5888 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5889 PyObject *resultobj = 0;
5890 wxPoint *arg1 = (wxPoint *) 0 ;
5891 void *argp1 = 0 ;
5892 int res1 = 0 ;
5893 PyObject *swig_obj[1] ;
5894
5895 if (!args) SWIG_fail;
5896 swig_obj[0] = args;
5897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5898 if (!SWIG_IsOK(res1)) {
5899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5900 }
5901 arg1 = reinterpret_cast< wxPoint * >(argp1);
5902 {
5903 delete arg1;
5904
5905 if (PyErr_Occurred()) SWIG_fail;
5906 }
5907 resultobj = SWIG_Py_Void();
5908 return resultobj;
5909 fail:
5910 return NULL;
5911 }
5912
5913
5914 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5915 PyObject *resultobj = 0;
5916 wxPoint *arg1 = (wxPoint *) 0 ;
5917 PyObject *arg2 = (PyObject *) 0 ;
5918 bool result;
5919 void *argp1 = 0 ;
5920 int res1 = 0 ;
5921 PyObject * obj0 = 0 ;
5922 PyObject * obj1 = 0 ;
5923 char * kwnames[] = {
5924 (char *) "self",(char *) "other", NULL
5925 };
5926
5927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5929 if (!SWIG_IsOK(res1)) {
5930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5931 }
5932 arg1 = reinterpret_cast< wxPoint * >(argp1);
5933 arg2 = obj1;
5934 {
5935 result = (bool)wxPoint___eq__(arg1,arg2);
5936 if (PyErr_Occurred()) SWIG_fail;
5937 }
5938 {
5939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5940 }
5941 return resultobj;
5942 fail:
5943 return NULL;
5944 }
5945
5946
5947 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5948 PyObject *resultobj = 0;
5949 wxPoint *arg1 = (wxPoint *) 0 ;
5950 PyObject *arg2 = (PyObject *) 0 ;
5951 bool result;
5952 void *argp1 = 0 ;
5953 int res1 = 0 ;
5954 PyObject * obj0 = 0 ;
5955 PyObject * obj1 = 0 ;
5956 char * kwnames[] = {
5957 (char *) "self",(char *) "other", NULL
5958 };
5959
5960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5962 if (!SWIG_IsOK(res1)) {
5963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5964 }
5965 arg1 = reinterpret_cast< wxPoint * >(argp1);
5966 arg2 = obj1;
5967 {
5968 result = (bool)wxPoint___ne__(arg1,arg2);
5969 if (PyErr_Occurred()) SWIG_fail;
5970 }
5971 {
5972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5973 }
5974 return resultobj;
5975 fail:
5976 return NULL;
5977 }
5978
5979
5980 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5981 PyObject *resultobj = 0;
5982 wxPoint *arg1 = (wxPoint *) 0 ;
5983 wxPoint *arg2 = 0 ;
5984 wxPoint result;
5985 void *argp1 = 0 ;
5986 int res1 = 0 ;
5987 wxPoint temp2 ;
5988 PyObject * obj0 = 0 ;
5989 PyObject * obj1 = 0 ;
5990 char * kwnames[] = {
5991 (char *) "self",(char *) "pt", NULL
5992 };
5993
5994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5996 if (!SWIG_IsOK(res1)) {
5997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5998 }
5999 arg1 = reinterpret_cast< wxPoint * >(argp1);
6000 {
6001 arg2 = &temp2;
6002 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6003 }
6004 {
6005 result = (arg1)->operator +((wxPoint const &)*arg2);
6006 if (PyErr_Occurred()) SWIG_fail;
6007 }
6008 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6009 return resultobj;
6010 fail:
6011 return NULL;
6012 }
6013
6014
6015 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6016 PyObject *resultobj = 0;
6017 wxPoint *arg1 = (wxPoint *) 0 ;
6018 wxPoint *arg2 = 0 ;
6019 wxPoint result;
6020 void *argp1 = 0 ;
6021 int res1 = 0 ;
6022 wxPoint temp2 ;
6023 PyObject * obj0 = 0 ;
6024 PyObject * obj1 = 0 ;
6025 char * kwnames[] = {
6026 (char *) "self",(char *) "pt", NULL
6027 };
6028
6029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6031 if (!SWIG_IsOK(res1)) {
6032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6033 }
6034 arg1 = reinterpret_cast< wxPoint * >(argp1);
6035 {
6036 arg2 = &temp2;
6037 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6038 }
6039 {
6040 result = (arg1)->operator -((wxPoint const &)*arg2);
6041 if (PyErr_Occurred()) SWIG_fail;
6042 }
6043 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6044 return resultobj;
6045 fail:
6046 return NULL;
6047 }
6048
6049
6050 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6051 PyObject *resultobj = 0;
6052 wxPoint *arg1 = (wxPoint *) 0 ;
6053 wxPoint *arg2 = 0 ;
6054 wxPoint *result = 0 ;
6055 void *argp1 = 0 ;
6056 int res1 = 0 ;
6057 wxPoint temp2 ;
6058 PyObject * obj0 = 0 ;
6059 PyObject * obj1 = 0 ;
6060 char * kwnames[] = {
6061 (char *) "self",(char *) "pt", NULL
6062 };
6063
6064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6066 if (!SWIG_IsOK(res1)) {
6067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6068 }
6069 arg1 = reinterpret_cast< wxPoint * >(argp1);
6070 {
6071 arg2 = &temp2;
6072 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6073 }
6074 {
6075 {
6076 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6077 result = (wxPoint *) &_result_ref;
6078 }
6079 if (PyErr_Occurred()) SWIG_fail;
6080 }
6081 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6082 return resultobj;
6083 fail:
6084 return NULL;
6085 }
6086
6087
6088 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6089 PyObject *resultobj = 0;
6090 wxPoint *arg1 = (wxPoint *) 0 ;
6091 wxPoint *arg2 = 0 ;
6092 wxPoint *result = 0 ;
6093 void *argp1 = 0 ;
6094 int res1 = 0 ;
6095 wxPoint temp2 ;
6096 PyObject * obj0 = 0 ;
6097 PyObject * obj1 = 0 ;
6098 char * kwnames[] = {
6099 (char *) "self",(char *) "pt", NULL
6100 };
6101
6102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6104 if (!SWIG_IsOK(res1)) {
6105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6106 }
6107 arg1 = reinterpret_cast< wxPoint * >(argp1);
6108 {
6109 arg2 = &temp2;
6110 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6111 }
6112 {
6113 {
6114 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6115 result = (wxPoint *) &_result_ref;
6116 }
6117 if (PyErr_Occurred()) SWIG_fail;
6118 }
6119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6120 return resultobj;
6121 fail:
6122 return NULL;
6123 }
6124
6125
6126 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6127 PyObject *resultobj = 0;
6128 wxPoint *arg1 = (wxPoint *) 0 ;
6129 long arg2 ;
6130 long arg3 ;
6131 void *argp1 = 0 ;
6132 int res1 = 0 ;
6133 long val2 ;
6134 int ecode2 = 0 ;
6135 long val3 ;
6136 int ecode3 = 0 ;
6137 PyObject * obj0 = 0 ;
6138 PyObject * obj1 = 0 ;
6139 PyObject * obj2 = 0 ;
6140 char * kwnames[] = {
6141 (char *) "self",(char *) "x",(char *) "y", NULL
6142 };
6143
6144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6146 if (!SWIG_IsOK(res1)) {
6147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6148 }
6149 arg1 = reinterpret_cast< wxPoint * >(argp1);
6150 ecode2 = SWIG_AsVal_long(obj1, &val2);
6151 if (!SWIG_IsOK(ecode2)) {
6152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6153 }
6154 arg2 = static_cast< long >(val2);
6155 ecode3 = SWIG_AsVal_long(obj2, &val3);
6156 if (!SWIG_IsOK(ecode3)) {
6157 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6158 }
6159 arg3 = static_cast< long >(val3);
6160 {
6161 wxPoint_Set(arg1,arg2,arg3);
6162 if (PyErr_Occurred()) SWIG_fail;
6163 }
6164 resultobj = SWIG_Py_Void();
6165 return resultobj;
6166 fail:
6167 return NULL;
6168 }
6169
6170
6171 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6172 PyObject *resultobj = 0;
6173 wxPoint *arg1 = (wxPoint *) 0 ;
6174 PyObject *result = 0 ;
6175 void *argp1 = 0 ;
6176 int res1 = 0 ;
6177 PyObject *swig_obj[1] ;
6178
6179 if (!args) SWIG_fail;
6180 swig_obj[0] = args;
6181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6182 if (!SWIG_IsOK(res1)) {
6183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6184 }
6185 arg1 = reinterpret_cast< wxPoint * >(argp1);
6186 {
6187 result = (PyObject *)wxPoint_Get(arg1);
6188 if (PyErr_Occurred()) SWIG_fail;
6189 }
6190 resultobj = result;
6191 return resultobj;
6192 fail:
6193 return NULL;
6194 }
6195
6196
6197 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6198 PyObject *obj;
6199 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6200 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6201 return SWIG_Py_Void();
6202 }
6203
6204 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6205 return SWIG_Python_InitShadowInstance(args);
6206 }
6207
6208 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6209 PyObject *resultobj = 0;
6210 int arg1 = (int) 0 ;
6211 int arg2 = (int) 0 ;
6212 int arg3 = (int) 0 ;
6213 int arg4 = (int) 0 ;
6214 wxRect *result = 0 ;
6215 int val1 ;
6216 int ecode1 = 0 ;
6217 int val2 ;
6218 int ecode2 = 0 ;
6219 int val3 ;
6220 int ecode3 = 0 ;
6221 int val4 ;
6222 int ecode4 = 0 ;
6223 PyObject * obj0 = 0 ;
6224 PyObject * obj1 = 0 ;
6225 PyObject * obj2 = 0 ;
6226 PyObject * obj3 = 0 ;
6227 char * kwnames[] = {
6228 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6229 };
6230
6231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6232 if (obj0) {
6233 ecode1 = SWIG_AsVal_int(obj0, &val1);
6234 if (!SWIG_IsOK(ecode1)) {
6235 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6236 }
6237 arg1 = static_cast< int >(val1);
6238 }
6239 if (obj1) {
6240 ecode2 = SWIG_AsVal_int(obj1, &val2);
6241 if (!SWIG_IsOK(ecode2)) {
6242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6243 }
6244 arg2 = static_cast< int >(val2);
6245 }
6246 if (obj2) {
6247 ecode3 = SWIG_AsVal_int(obj2, &val3);
6248 if (!SWIG_IsOK(ecode3)) {
6249 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6250 }
6251 arg3 = static_cast< int >(val3);
6252 }
6253 if (obj3) {
6254 ecode4 = SWIG_AsVal_int(obj3, &val4);
6255 if (!SWIG_IsOK(ecode4)) {
6256 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6257 }
6258 arg4 = static_cast< int >(val4);
6259 }
6260 {
6261 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6262 if (PyErr_Occurred()) SWIG_fail;
6263 }
6264 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6265 return resultobj;
6266 fail:
6267 return NULL;
6268 }
6269
6270
6271 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6272 PyObject *resultobj = 0;
6273 wxPoint *arg1 = 0 ;
6274 wxPoint *arg2 = 0 ;
6275 wxRect *result = 0 ;
6276 wxPoint temp1 ;
6277 wxPoint temp2 ;
6278 PyObject * obj0 = 0 ;
6279 PyObject * obj1 = 0 ;
6280 char * kwnames[] = {
6281 (char *) "topLeft",(char *) "bottomRight", NULL
6282 };
6283
6284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6285 {
6286 arg1 = &temp1;
6287 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6288 }
6289 {
6290 arg2 = &temp2;
6291 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6292 }
6293 {
6294 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6295 if (PyErr_Occurred()) SWIG_fail;
6296 }
6297 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6298 return resultobj;
6299 fail:
6300 return NULL;
6301 }
6302
6303
6304 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6305 PyObject *resultobj = 0;
6306 wxPoint *arg1 = 0 ;
6307 wxSize *arg2 = 0 ;
6308 wxRect *result = 0 ;
6309 wxPoint temp1 ;
6310 wxSize temp2 ;
6311 PyObject * obj0 = 0 ;
6312 PyObject * obj1 = 0 ;
6313 char * kwnames[] = {
6314 (char *) "pos",(char *) "size", NULL
6315 };
6316
6317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6318 {
6319 arg1 = &temp1;
6320 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6321 }
6322 {
6323 arg2 = &temp2;
6324 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6325 }
6326 {
6327 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6328 if (PyErr_Occurred()) SWIG_fail;
6329 }
6330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6331 return resultobj;
6332 fail:
6333 return NULL;
6334 }
6335
6336
6337 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6338 PyObject *resultobj = 0;
6339 wxSize *arg1 = 0 ;
6340 wxRect *result = 0 ;
6341 wxSize temp1 ;
6342 PyObject * obj0 = 0 ;
6343 char * kwnames[] = {
6344 (char *) "size", NULL
6345 };
6346
6347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6348 {
6349 arg1 = &temp1;
6350 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6351 }
6352 {
6353 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6354 if (PyErr_Occurred()) SWIG_fail;
6355 }
6356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6357 return resultobj;
6358 fail:
6359 return NULL;
6360 }
6361
6362
6363 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6364 PyObject *resultobj = 0;
6365 wxRect *arg1 = (wxRect *) 0 ;
6366 void *argp1 = 0 ;
6367 int res1 = 0 ;
6368 PyObject *swig_obj[1] ;
6369
6370 if (!args) SWIG_fail;
6371 swig_obj[0] = args;
6372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6373 if (!SWIG_IsOK(res1)) {
6374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6375 }
6376 arg1 = reinterpret_cast< wxRect * >(argp1);
6377 {
6378 delete arg1;
6379
6380 if (PyErr_Occurred()) SWIG_fail;
6381 }
6382 resultobj = SWIG_Py_Void();
6383 return resultobj;
6384 fail:
6385 return NULL;
6386 }
6387
6388
6389 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6390 PyObject *resultobj = 0;
6391 wxRect *arg1 = (wxRect *) 0 ;
6392 int result;
6393 void *argp1 = 0 ;
6394 int res1 = 0 ;
6395 PyObject *swig_obj[1] ;
6396
6397 if (!args) SWIG_fail;
6398 swig_obj[0] = args;
6399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6400 if (!SWIG_IsOK(res1)) {
6401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6402 }
6403 arg1 = reinterpret_cast< wxRect * >(argp1);
6404 {
6405 result = (int)((wxRect const *)arg1)->GetX();
6406 if (PyErr_Occurred()) SWIG_fail;
6407 }
6408 resultobj = SWIG_From_int(static_cast< int >(result));
6409 return resultobj;
6410 fail:
6411 return NULL;
6412 }
6413
6414
6415 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6416 PyObject *resultobj = 0;
6417 wxRect *arg1 = (wxRect *) 0 ;
6418 int arg2 ;
6419 void *argp1 = 0 ;
6420 int res1 = 0 ;
6421 int val2 ;
6422 int ecode2 = 0 ;
6423 PyObject * obj0 = 0 ;
6424 PyObject * obj1 = 0 ;
6425 char * kwnames[] = {
6426 (char *) "self",(char *) "x", NULL
6427 };
6428
6429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6431 if (!SWIG_IsOK(res1)) {
6432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6433 }
6434 arg1 = reinterpret_cast< wxRect * >(argp1);
6435 ecode2 = SWIG_AsVal_int(obj1, &val2);
6436 if (!SWIG_IsOK(ecode2)) {
6437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6438 }
6439 arg2 = static_cast< int >(val2);
6440 {
6441 (arg1)->SetX(arg2);
6442 if (PyErr_Occurred()) SWIG_fail;
6443 }
6444 resultobj = SWIG_Py_Void();
6445 return resultobj;
6446 fail:
6447 return NULL;
6448 }
6449
6450
6451 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6452 PyObject *resultobj = 0;
6453 wxRect *arg1 = (wxRect *) 0 ;
6454 int result;
6455 void *argp1 = 0 ;
6456 int res1 = 0 ;
6457 PyObject *swig_obj[1] ;
6458
6459 if (!args) SWIG_fail;
6460 swig_obj[0] = args;
6461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6462 if (!SWIG_IsOK(res1)) {
6463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6464 }
6465 arg1 = reinterpret_cast< wxRect * >(argp1);
6466 {
6467 result = (int)(arg1)->GetY();
6468 if (PyErr_Occurred()) SWIG_fail;
6469 }
6470 resultobj = SWIG_From_int(static_cast< int >(result));
6471 return resultobj;
6472 fail:
6473 return NULL;
6474 }
6475
6476
6477 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6478 PyObject *resultobj = 0;
6479 wxRect *arg1 = (wxRect *) 0 ;
6480 int arg2 ;
6481 void *argp1 = 0 ;
6482 int res1 = 0 ;
6483 int val2 ;
6484 int ecode2 = 0 ;
6485 PyObject * obj0 = 0 ;
6486 PyObject * obj1 = 0 ;
6487 char * kwnames[] = {
6488 (char *) "self",(char *) "y", NULL
6489 };
6490
6491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6493 if (!SWIG_IsOK(res1)) {
6494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6495 }
6496 arg1 = reinterpret_cast< wxRect * >(argp1);
6497 ecode2 = SWIG_AsVal_int(obj1, &val2);
6498 if (!SWIG_IsOK(ecode2)) {
6499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6500 }
6501 arg2 = static_cast< int >(val2);
6502 {
6503 (arg1)->SetY(arg2);
6504 if (PyErr_Occurred()) SWIG_fail;
6505 }
6506 resultobj = SWIG_Py_Void();
6507 return resultobj;
6508 fail:
6509 return NULL;
6510 }
6511
6512
6513 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6514 PyObject *resultobj = 0;
6515 wxRect *arg1 = (wxRect *) 0 ;
6516 int result;
6517 void *argp1 = 0 ;
6518 int res1 = 0 ;
6519 PyObject *swig_obj[1] ;
6520
6521 if (!args) SWIG_fail;
6522 swig_obj[0] = args;
6523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6524 if (!SWIG_IsOK(res1)) {
6525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6526 }
6527 arg1 = reinterpret_cast< wxRect * >(argp1);
6528 {
6529 result = (int)((wxRect const *)arg1)->GetWidth();
6530 if (PyErr_Occurred()) SWIG_fail;
6531 }
6532 resultobj = SWIG_From_int(static_cast< int >(result));
6533 return resultobj;
6534 fail:
6535 return NULL;
6536 }
6537
6538
6539 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6540 PyObject *resultobj = 0;
6541 wxRect *arg1 = (wxRect *) 0 ;
6542 int arg2 ;
6543 void *argp1 = 0 ;
6544 int res1 = 0 ;
6545 int val2 ;
6546 int ecode2 = 0 ;
6547 PyObject * obj0 = 0 ;
6548 PyObject * obj1 = 0 ;
6549 char * kwnames[] = {
6550 (char *) "self",(char *) "w", NULL
6551 };
6552
6553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6555 if (!SWIG_IsOK(res1)) {
6556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6557 }
6558 arg1 = reinterpret_cast< wxRect * >(argp1);
6559 ecode2 = SWIG_AsVal_int(obj1, &val2);
6560 if (!SWIG_IsOK(ecode2)) {
6561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6562 }
6563 arg2 = static_cast< int >(val2);
6564 {
6565 (arg1)->SetWidth(arg2);
6566 if (PyErr_Occurred()) SWIG_fail;
6567 }
6568 resultobj = SWIG_Py_Void();
6569 return resultobj;
6570 fail:
6571 return NULL;
6572 }
6573
6574
6575 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6576 PyObject *resultobj = 0;
6577 wxRect *arg1 = (wxRect *) 0 ;
6578 int result;
6579 void *argp1 = 0 ;
6580 int res1 = 0 ;
6581 PyObject *swig_obj[1] ;
6582
6583 if (!args) SWIG_fail;
6584 swig_obj[0] = args;
6585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6586 if (!SWIG_IsOK(res1)) {
6587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6588 }
6589 arg1 = reinterpret_cast< wxRect * >(argp1);
6590 {
6591 result = (int)((wxRect const *)arg1)->GetHeight();
6592 if (PyErr_Occurred()) SWIG_fail;
6593 }
6594 resultobj = SWIG_From_int(static_cast< int >(result));
6595 return resultobj;
6596 fail:
6597 return NULL;
6598 }
6599
6600
6601 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6602 PyObject *resultobj = 0;
6603 wxRect *arg1 = (wxRect *) 0 ;
6604 int arg2 ;
6605 void *argp1 = 0 ;
6606 int res1 = 0 ;
6607 int val2 ;
6608 int ecode2 = 0 ;
6609 PyObject * obj0 = 0 ;
6610 PyObject * obj1 = 0 ;
6611 char * kwnames[] = {
6612 (char *) "self",(char *) "h", NULL
6613 };
6614
6615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6617 if (!SWIG_IsOK(res1)) {
6618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6619 }
6620 arg1 = reinterpret_cast< wxRect * >(argp1);
6621 ecode2 = SWIG_AsVal_int(obj1, &val2);
6622 if (!SWIG_IsOK(ecode2)) {
6623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6624 }
6625 arg2 = static_cast< int >(val2);
6626 {
6627 (arg1)->SetHeight(arg2);
6628 if (PyErr_Occurred()) SWIG_fail;
6629 }
6630 resultobj = SWIG_Py_Void();
6631 return resultobj;
6632 fail:
6633 return NULL;
6634 }
6635
6636
6637 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6638 PyObject *resultobj = 0;
6639 wxRect *arg1 = (wxRect *) 0 ;
6640 wxPoint result;
6641 void *argp1 = 0 ;
6642 int res1 = 0 ;
6643 PyObject *swig_obj[1] ;
6644
6645 if (!args) SWIG_fail;
6646 swig_obj[0] = args;
6647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6648 if (!SWIG_IsOK(res1)) {
6649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6650 }
6651 arg1 = reinterpret_cast< wxRect * >(argp1);
6652 {
6653 result = ((wxRect const *)arg1)->GetPosition();
6654 if (PyErr_Occurred()) SWIG_fail;
6655 }
6656 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6657 return resultobj;
6658 fail:
6659 return NULL;
6660 }
6661
6662
6663 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6664 PyObject *resultobj = 0;
6665 wxRect *arg1 = (wxRect *) 0 ;
6666 wxPoint *arg2 = 0 ;
6667 void *argp1 = 0 ;
6668 int res1 = 0 ;
6669 wxPoint temp2 ;
6670 PyObject * obj0 = 0 ;
6671 PyObject * obj1 = 0 ;
6672 char * kwnames[] = {
6673 (char *) "self",(char *) "p", NULL
6674 };
6675
6676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6678 if (!SWIG_IsOK(res1)) {
6679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6680 }
6681 arg1 = reinterpret_cast< wxRect * >(argp1);
6682 {
6683 arg2 = &temp2;
6684 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6685 }
6686 {
6687 (arg1)->SetPosition((wxPoint const &)*arg2);
6688 if (PyErr_Occurred()) SWIG_fail;
6689 }
6690 resultobj = SWIG_Py_Void();
6691 return resultobj;
6692 fail:
6693 return NULL;
6694 }
6695
6696
6697 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6698 PyObject *resultobj = 0;
6699 wxRect *arg1 = (wxRect *) 0 ;
6700 wxSize result;
6701 void *argp1 = 0 ;
6702 int res1 = 0 ;
6703 PyObject *swig_obj[1] ;
6704
6705 if (!args) SWIG_fail;
6706 swig_obj[0] = args;
6707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6708 if (!SWIG_IsOK(res1)) {
6709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6710 }
6711 arg1 = reinterpret_cast< wxRect * >(argp1);
6712 {
6713 result = ((wxRect const *)arg1)->GetSize();
6714 if (PyErr_Occurred()) SWIG_fail;
6715 }
6716 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6717 return resultobj;
6718 fail:
6719 return NULL;
6720 }
6721
6722
6723 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6724 PyObject *resultobj = 0;
6725 wxRect *arg1 = (wxRect *) 0 ;
6726 wxSize *arg2 = 0 ;
6727 void *argp1 = 0 ;
6728 int res1 = 0 ;
6729 wxSize temp2 ;
6730 PyObject * obj0 = 0 ;
6731 PyObject * obj1 = 0 ;
6732 char * kwnames[] = {
6733 (char *) "self",(char *) "s", NULL
6734 };
6735
6736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6738 if (!SWIG_IsOK(res1)) {
6739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6740 }
6741 arg1 = reinterpret_cast< wxRect * >(argp1);
6742 {
6743 arg2 = &temp2;
6744 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6745 }
6746 {
6747 (arg1)->SetSize((wxSize const &)*arg2);
6748 if (PyErr_Occurred()) SWIG_fail;
6749 }
6750 resultobj = SWIG_Py_Void();
6751 return resultobj;
6752 fail:
6753 return NULL;
6754 }
6755
6756
6757 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6758 PyObject *resultobj = 0;
6759 wxRect *arg1 = (wxRect *) 0 ;
6760 bool result;
6761 void *argp1 = 0 ;
6762 int res1 = 0 ;
6763 PyObject *swig_obj[1] ;
6764
6765 if (!args) SWIG_fail;
6766 swig_obj[0] = args;
6767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6768 if (!SWIG_IsOK(res1)) {
6769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6770 }
6771 arg1 = reinterpret_cast< wxRect * >(argp1);
6772 {
6773 result = (bool)((wxRect const *)arg1)->IsEmpty();
6774 if (PyErr_Occurred()) SWIG_fail;
6775 }
6776 {
6777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6778 }
6779 return resultobj;
6780 fail:
6781 return NULL;
6782 }
6783
6784
6785 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6786 PyObject *resultobj = 0;
6787 wxRect *arg1 = (wxRect *) 0 ;
6788 wxPoint result;
6789 void *argp1 = 0 ;
6790 int res1 = 0 ;
6791 PyObject *swig_obj[1] ;
6792
6793 if (!args) SWIG_fail;
6794 swig_obj[0] = args;
6795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6796 if (!SWIG_IsOK(res1)) {
6797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6798 }
6799 arg1 = reinterpret_cast< wxRect * >(argp1);
6800 {
6801 result = ((wxRect const *)arg1)->GetTopLeft();
6802 if (PyErr_Occurred()) SWIG_fail;
6803 }
6804 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6805 return resultobj;
6806 fail:
6807 return NULL;
6808 }
6809
6810
6811 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6812 PyObject *resultobj = 0;
6813 wxRect *arg1 = (wxRect *) 0 ;
6814 wxPoint *arg2 = 0 ;
6815 void *argp1 = 0 ;
6816 int res1 = 0 ;
6817 wxPoint temp2 ;
6818 PyObject * obj0 = 0 ;
6819 PyObject * obj1 = 0 ;
6820 char * kwnames[] = {
6821 (char *) "self",(char *) "p", NULL
6822 };
6823
6824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6826 if (!SWIG_IsOK(res1)) {
6827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6828 }
6829 arg1 = reinterpret_cast< wxRect * >(argp1);
6830 {
6831 arg2 = &temp2;
6832 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6833 }
6834 {
6835 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6836 if (PyErr_Occurred()) SWIG_fail;
6837 }
6838 resultobj = SWIG_Py_Void();
6839 return resultobj;
6840 fail:
6841 return NULL;
6842 }
6843
6844
6845 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6846 PyObject *resultobj = 0;
6847 wxRect *arg1 = (wxRect *) 0 ;
6848 wxPoint result;
6849 void *argp1 = 0 ;
6850 int res1 = 0 ;
6851 PyObject *swig_obj[1] ;
6852
6853 if (!args) SWIG_fail;
6854 swig_obj[0] = args;
6855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6856 if (!SWIG_IsOK(res1)) {
6857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6858 }
6859 arg1 = reinterpret_cast< wxRect * >(argp1);
6860 {
6861 result = ((wxRect const *)arg1)->GetBottomRight();
6862 if (PyErr_Occurred()) SWIG_fail;
6863 }
6864 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6865 return resultobj;
6866 fail:
6867 return NULL;
6868 }
6869
6870
6871 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6872 PyObject *resultobj = 0;
6873 wxRect *arg1 = (wxRect *) 0 ;
6874 wxPoint *arg2 = 0 ;
6875 void *argp1 = 0 ;
6876 int res1 = 0 ;
6877 wxPoint temp2 ;
6878 PyObject * obj0 = 0 ;
6879 PyObject * obj1 = 0 ;
6880 char * kwnames[] = {
6881 (char *) "self",(char *) "p", NULL
6882 };
6883
6884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6886 if (!SWIG_IsOK(res1)) {
6887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6888 }
6889 arg1 = reinterpret_cast< wxRect * >(argp1);
6890 {
6891 arg2 = &temp2;
6892 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6893 }
6894 {
6895 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6896 if (PyErr_Occurred()) SWIG_fail;
6897 }
6898 resultobj = SWIG_Py_Void();
6899 return resultobj;
6900 fail:
6901 return NULL;
6902 }
6903
6904
6905 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6906 PyObject *resultobj = 0;
6907 wxRect *arg1 = (wxRect *) 0 ;
6908 wxPoint result;
6909 void *argp1 = 0 ;
6910 int res1 = 0 ;
6911 PyObject *swig_obj[1] ;
6912
6913 if (!args) SWIG_fail;
6914 swig_obj[0] = args;
6915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6916 if (!SWIG_IsOK(res1)) {
6917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6918 }
6919 arg1 = reinterpret_cast< wxRect * >(argp1);
6920 {
6921 result = ((wxRect const *)arg1)->GetTopRight();
6922 if (PyErr_Occurred()) SWIG_fail;
6923 }
6924 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6925 return resultobj;
6926 fail:
6927 return NULL;
6928 }
6929
6930
6931 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6932 PyObject *resultobj = 0;
6933 wxRect *arg1 = (wxRect *) 0 ;
6934 wxPoint *arg2 = 0 ;
6935 void *argp1 = 0 ;
6936 int res1 = 0 ;
6937 wxPoint temp2 ;
6938 PyObject * obj0 = 0 ;
6939 PyObject * obj1 = 0 ;
6940 char * kwnames[] = {
6941 (char *) "self",(char *) "p", NULL
6942 };
6943
6944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6946 if (!SWIG_IsOK(res1)) {
6947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6948 }
6949 arg1 = reinterpret_cast< wxRect * >(argp1);
6950 {
6951 arg2 = &temp2;
6952 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6953 }
6954 {
6955 (arg1)->SetTopRight((wxPoint const &)*arg2);
6956 if (PyErr_Occurred()) SWIG_fail;
6957 }
6958 resultobj = SWIG_Py_Void();
6959 return resultobj;
6960 fail:
6961 return NULL;
6962 }
6963
6964
6965 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6966 PyObject *resultobj = 0;
6967 wxRect *arg1 = (wxRect *) 0 ;
6968 wxPoint result;
6969 void *argp1 = 0 ;
6970 int res1 = 0 ;
6971 PyObject *swig_obj[1] ;
6972
6973 if (!args) SWIG_fail;
6974 swig_obj[0] = args;
6975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6976 if (!SWIG_IsOK(res1)) {
6977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6978 }
6979 arg1 = reinterpret_cast< wxRect * >(argp1);
6980 {
6981 result = ((wxRect const *)arg1)->GetBottomLeft();
6982 if (PyErr_Occurred()) SWIG_fail;
6983 }
6984 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6985 return resultobj;
6986 fail:
6987 return NULL;
6988 }
6989
6990
6991 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6992 PyObject *resultobj = 0;
6993 wxRect *arg1 = (wxRect *) 0 ;
6994 wxPoint *arg2 = 0 ;
6995 void *argp1 = 0 ;
6996 int res1 = 0 ;
6997 wxPoint temp2 ;
6998 PyObject * obj0 = 0 ;
6999 PyObject * obj1 = 0 ;
7000 char * kwnames[] = {
7001 (char *) "self",(char *) "p", NULL
7002 };
7003
7004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7006 if (!SWIG_IsOK(res1)) {
7007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7008 }
7009 arg1 = reinterpret_cast< wxRect * >(argp1);
7010 {
7011 arg2 = &temp2;
7012 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7013 }
7014 {
7015 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7016 if (PyErr_Occurred()) SWIG_fail;
7017 }
7018 resultobj = SWIG_Py_Void();
7019 return resultobj;
7020 fail:
7021 return NULL;
7022 }
7023
7024
7025 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7026 PyObject *resultobj = 0;
7027 wxRect *arg1 = (wxRect *) 0 ;
7028 int result;
7029 void *argp1 = 0 ;
7030 int res1 = 0 ;
7031 PyObject *swig_obj[1] ;
7032
7033 if (!args) SWIG_fail;
7034 swig_obj[0] = args;
7035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7036 if (!SWIG_IsOK(res1)) {
7037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7038 }
7039 arg1 = reinterpret_cast< wxRect * >(argp1);
7040 {
7041 result = (int)((wxRect const *)arg1)->GetLeft();
7042 if (PyErr_Occurred()) SWIG_fail;
7043 }
7044 resultobj = SWIG_From_int(static_cast< int >(result));
7045 return resultobj;
7046 fail:
7047 return NULL;
7048 }
7049
7050
7051 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7052 PyObject *resultobj = 0;
7053 wxRect *arg1 = (wxRect *) 0 ;
7054 int result;
7055 void *argp1 = 0 ;
7056 int res1 = 0 ;
7057 PyObject *swig_obj[1] ;
7058
7059 if (!args) SWIG_fail;
7060 swig_obj[0] = args;
7061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7062 if (!SWIG_IsOK(res1)) {
7063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7064 }
7065 arg1 = reinterpret_cast< wxRect * >(argp1);
7066 {
7067 result = (int)((wxRect const *)arg1)->GetTop();
7068 if (PyErr_Occurred()) SWIG_fail;
7069 }
7070 resultobj = SWIG_From_int(static_cast< int >(result));
7071 return resultobj;
7072 fail:
7073 return NULL;
7074 }
7075
7076
7077 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7078 PyObject *resultobj = 0;
7079 wxRect *arg1 = (wxRect *) 0 ;
7080 int result;
7081 void *argp1 = 0 ;
7082 int res1 = 0 ;
7083 PyObject *swig_obj[1] ;
7084
7085 if (!args) SWIG_fail;
7086 swig_obj[0] = args;
7087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7088 if (!SWIG_IsOK(res1)) {
7089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7090 }
7091 arg1 = reinterpret_cast< wxRect * >(argp1);
7092 {
7093 result = (int)((wxRect const *)arg1)->GetBottom();
7094 if (PyErr_Occurred()) SWIG_fail;
7095 }
7096 resultobj = SWIG_From_int(static_cast< int >(result));
7097 return resultobj;
7098 fail:
7099 return NULL;
7100 }
7101
7102
7103 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7104 PyObject *resultobj = 0;
7105 wxRect *arg1 = (wxRect *) 0 ;
7106 int result;
7107 void *argp1 = 0 ;
7108 int res1 = 0 ;
7109 PyObject *swig_obj[1] ;
7110
7111 if (!args) SWIG_fail;
7112 swig_obj[0] = args;
7113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7114 if (!SWIG_IsOK(res1)) {
7115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7116 }
7117 arg1 = reinterpret_cast< wxRect * >(argp1);
7118 {
7119 result = (int)((wxRect const *)arg1)->GetRight();
7120 if (PyErr_Occurred()) SWIG_fail;
7121 }
7122 resultobj = SWIG_From_int(static_cast< int >(result));
7123 return resultobj;
7124 fail:
7125 return NULL;
7126 }
7127
7128
7129 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7130 PyObject *resultobj = 0;
7131 wxRect *arg1 = (wxRect *) 0 ;
7132 int arg2 ;
7133 void *argp1 = 0 ;
7134 int res1 = 0 ;
7135 int val2 ;
7136 int ecode2 = 0 ;
7137 PyObject * obj0 = 0 ;
7138 PyObject * obj1 = 0 ;
7139 char * kwnames[] = {
7140 (char *) "self",(char *) "left", NULL
7141 };
7142
7143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7145 if (!SWIG_IsOK(res1)) {
7146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7147 }
7148 arg1 = reinterpret_cast< wxRect * >(argp1);
7149 ecode2 = SWIG_AsVal_int(obj1, &val2);
7150 if (!SWIG_IsOK(ecode2)) {
7151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7152 }
7153 arg2 = static_cast< int >(val2);
7154 {
7155 (arg1)->SetLeft(arg2);
7156 if (PyErr_Occurred()) SWIG_fail;
7157 }
7158 resultobj = SWIG_Py_Void();
7159 return resultobj;
7160 fail:
7161 return NULL;
7162 }
7163
7164
7165 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7166 PyObject *resultobj = 0;
7167 wxRect *arg1 = (wxRect *) 0 ;
7168 int arg2 ;
7169 void *argp1 = 0 ;
7170 int res1 = 0 ;
7171 int val2 ;
7172 int ecode2 = 0 ;
7173 PyObject * obj0 = 0 ;
7174 PyObject * obj1 = 0 ;
7175 char * kwnames[] = {
7176 (char *) "self",(char *) "right", NULL
7177 };
7178
7179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7181 if (!SWIG_IsOK(res1)) {
7182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7183 }
7184 arg1 = reinterpret_cast< wxRect * >(argp1);
7185 ecode2 = SWIG_AsVal_int(obj1, &val2);
7186 if (!SWIG_IsOK(ecode2)) {
7187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7188 }
7189 arg2 = static_cast< int >(val2);
7190 {
7191 (arg1)->SetRight(arg2);
7192 if (PyErr_Occurred()) SWIG_fail;
7193 }
7194 resultobj = SWIG_Py_Void();
7195 return resultobj;
7196 fail:
7197 return NULL;
7198 }
7199
7200
7201 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7202 PyObject *resultobj = 0;
7203 wxRect *arg1 = (wxRect *) 0 ;
7204 int arg2 ;
7205 void *argp1 = 0 ;
7206 int res1 = 0 ;
7207 int val2 ;
7208 int ecode2 = 0 ;
7209 PyObject * obj0 = 0 ;
7210 PyObject * obj1 = 0 ;
7211 char * kwnames[] = {
7212 (char *) "self",(char *) "top", NULL
7213 };
7214
7215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7217 if (!SWIG_IsOK(res1)) {
7218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7219 }
7220 arg1 = reinterpret_cast< wxRect * >(argp1);
7221 ecode2 = SWIG_AsVal_int(obj1, &val2);
7222 if (!SWIG_IsOK(ecode2)) {
7223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7224 }
7225 arg2 = static_cast< int >(val2);
7226 {
7227 (arg1)->SetTop(arg2);
7228 if (PyErr_Occurred()) SWIG_fail;
7229 }
7230 resultobj = SWIG_Py_Void();
7231 return resultobj;
7232 fail:
7233 return NULL;
7234 }
7235
7236
7237 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7238 PyObject *resultobj = 0;
7239 wxRect *arg1 = (wxRect *) 0 ;
7240 int arg2 ;
7241 void *argp1 = 0 ;
7242 int res1 = 0 ;
7243 int val2 ;
7244 int ecode2 = 0 ;
7245 PyObject * obj0 = 0 ;
7246 PyObject * obj1 = 0 ;
7247 char * kwnames[] = {
7248 (char *) "self",(char *) "bottom", NULL
7249 };
7250
7251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7253 if (!SWIG_IsOK(res1)) {
7254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7255 }
7256 arg1 = reinterpret_cast< wxRect * >(argp1);
7257 ecode2 = SWIG_AsVal_int(obj1, &val2);
7258 if (!SWIG_IsOK(ecode2)) {
7259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7260 }
7261 arg2 = static_cast< int >(val2);
7262 {
7263 (arg1)->SetBottom(arg2);
7264 if (PyErr_Occurred()) SWIG_fail;
7265 }
7266 resultobj = SWIG_Py_Void();
7267 return resultobj;
7268 fail:
7269 return NULL;
7270 }
7271
7272
7273 SWIGINTERN PyObject *_wrap_Rect_Inflate(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;
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_Inflate",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_Inflate" "', 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_Inflate" "', 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_Inflate" "', expected argument " "3"" of type '" "int""'");
7306 }
7307 arg3 = static_cast< int >(val3);
7308 {
7309 result = (arg1)->Inflate(arg2,arg3);
7310 if (PyErr_Occurred()) SWIG_fail;
7311 }
7312 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7313 return resultobj;
7314 fail:
7315 return NULL;
7316 }
7317
7318
7319 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7320 PyObject *resultobj = 0;
7321 wxRect *arg1 = (wxRect *) 0 ;
7322 int arg2 ;
7323 int arg3 ;
7324 wxRect *result = 0 ;
7325 void *argp1 = 0 ;
7326 int res1 = 0 ;
7327 int val2 ;
7328 int ecode2 = 0 ;
7329 int val3 ;
7330 int ecode3 = 0 ;
7331 PyObject * obj0 = 0 ;
7332 PyObject * obj1 = 0 ;
7333 PyObject * obj2 = 0 ;
7334 char * kwnames[] = {
7335 (char *) "self",(char *) "dx",(char *) "dy", NULL
7336 };
7337
7338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7340 if (!SWIG_IsOK(res1)) {
7341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7342 }
7343 arg1 = reinterpret_cast< wxRect * >(argp1);
7344 ecode2 = SWIG_AsVal_int(obj1, &val2);
7345 if (!SWIG_IsOK(ecode2)) {
7346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7347 }
7348 arg2 = static_cast< int >(val2);
7349 ecode3 = SWIG_AsVal_int(obj2, &val3);
7350 if (!SWIG_IsOK(ecode3)) {
7351 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7352 }
7353 arg3 = static_cast< int >(val3);
7354 {
7355 {
7356 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7357 result = (wxRect *) &_result_ref;
7358 }
7359 if (PyErr_Occurred()) SWIG_fail;
7360 }
7361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7362 return resultobj;
7363 fail:
7364 return NULL;
7365 }
7366
7367
7368 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7369 PyObject *resultobj = 0;
7370 wxRect *arg1 = (wxRect *) 0 ;
7371 int arg2 ;
7372 int arg3 ;
7373 void *argp1 = 0 ;
7374 int res1 = 0 ;
7375 int val2 ;
7376 int ecode2 = 0 ;
7377 int val3 ;
7378 int ecode3 = 0 ;
7379 PyObject * obj0 = 0 ;
7380 PyObject * obj1 = 0 ;
7381 PyObject * obj2 = 0 ;
7382 char * kwnames[] = {
7383 (char *) "self",(char *) "dx",(char *) "dy", NULL
7384 };
7385
7386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7388 if (!SWIG_IsOK(res1)) {
7389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7390 }
7391 arg1 = reinterpret_cast< wxRect * >(argp1);
7392 ecode2 = SWIG_AsVal_int(obj1, &val2);
7393 if (!SWIG_IsOK(ecode2)) {
7394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7395 }
7396 arg2 = static_cast< int >(val2);
7397 ecode3 = SWIG_AsVal_int(obj2, &val3);
7398 if (!SWIG_IsOK(ecode3)) {
7399 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7400 }
7401 arg3 = static_cast< int >(val3);
7402 {
7403 (arg1)->Offset(arg2,arg3);
7404 if (PyErr_Occurred()) SWIG_fail;
7405 }
7406 resultobj = SWIG_Py_Void();
7407 return resultobj;
7408 fail:
7409 return NULL;
7410 }
7411
7412
7413 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7414 PyObject *resultobj = 0;
7415 wxRect *arg1 = (wxRect *) 0 ;
7416 wxPoint *arg2 = 0 ;
7417 void *argp1 = 0 ;
7418 int res1 = 0 ;
7419 wxPoint temp2 ;
7420 PyObject * obj0 = 0 ;
7421 PyObject * obj1 = 0 ;
7422 char * kwnames[] = {
7423 (char *) "self",(char *) "pt", NULL
7424 };
7425
7426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7428 if (!SWIG_IsOK(res1)) {
7429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7430 }
7431 arg1 = reinterpret_cast< wxRect * >(argp1);
7432 {
7433 arg2 = &temp2;
7434 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7435 }
7436 {
7437 (arg1)->Offset((wxPoint const &)*arg2);
7438 if (PyErr_Occurred()) SWIG_fail;
7439 }
7440 resultobj = SWIG_Py_Void();
7441 return resultobj;
7442 fail:
7443 return NULL;
7444 }
7445
7446
7447 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7448 PyObject *resultobj = 0;
7449 wxRect *arg1 = (wxRect *) 0 ;
7450 wxRect *arg2 = 0 ;
7451 wxRect result;
7452 void *argp1 = 0 ;
7453 int res1 = 0 ;
7454 wxRect temp2 ;
7455 PyObject * obj0 = 0 ;
7456 PyObject * obj1 = 0 ;
7457 char * kwnames[] = {
7458 (char *) "self",(char *) "rect", NULL
7459 };
7460
7461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7463 if (!SWIG_IsOK(res1)) {
7464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7465 }
7466 arg1 = reinterpret_cast< wxRect * >(argp1);
7467 {
7468 arg2 = &temp2;
7469 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7470 }
7471 {
7472 result = (arg1)->Intersect((wxRect const &)*arg2);
7473 if (PyErr_Occurred()) SWIG_fail;
7474 }
7475 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7476 return resultobj;
7477 fail:
7478 return NULL;
7479 }
7480
7481
7482 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7483 PyObject *resultobj = 0;
7484 wxRect *arg1 = (wxRect *) 0 ;
7485 wxRect *arg2 = 0 ;
7486 wxRect result;
7487 void *argp1 = 0 ;
7488 int res1 = 0 ;
7489 wxRect temp2 ;
7490 PyObject * obj0 = 0 ;
7491 PyObject * obj1 = 0 ;
7492 char * kwnames[] = {
7493 (char *) "self",(char *) "rect", NULL
7494 };
7495
7496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7498 if (!SWIG_IsOK(res1)) {
7499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7500 }
7501 arg1 = reinterpret_cast< wxRect * >(argp1);
7502 {
7503 arg2 = &temp2;
7504 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7505 }
7506 {
7507 result = (arg1)->Union((wxRect const &)*arg2);
7508 if (PyErr_Occurred()) SWIG_fail;
7509 }
7510 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7511 return resultobj;
7512 fail:
7513 return NULL;
7514 }
7515
7516
7517 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7518 PyObject *resultobj = 0;
7519 wxRect *arg1 = (wxRect *) 0 ;
7520 wxRect *arg2 = 0 ;
7521 wxRect result;
7522 void *argp1 = 0 ;
7523 int res1 = 0 ;
7524 wxRect temp2 ;
7525 PyObject * obj0 = 0 ;
7526 PyObject * obj1 = 0 ;
7527 char * kwnames[] = {
7528 (char *) "self",(char *) "rect", NULL
7529 };
7530
7531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7533 if (!SWIG_IsOK(res1)) {
7534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7535 }
7536 arg1 = reinterpret_cast< wxRect * >(argp1);
7537 {
7538 arg2 = &temp2;
7539 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7540 }
7541 {
7542 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7543 if (PyErr_Occurred()) SWIG_fail;
7544 }
7545 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7546 return resultobj;
7547 fail:
7548 return NULL;
7549 }
7550
7551
7552 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7553 PyObject *resultobj = 0;
7554 wxRect *arg1 = (wxRect *) 0 ;
7555 wxRect *arg2 = 0 ;
7556 wxRect *result = 0 ;
7557 void *argp1 = 0 ;
7558 int res1 = 0 ;
7559 wxRect temp2 ;
7560 PyObject * obj0 = 0 ;
7561 PyObject * obj1 = 0 ;
7562 char * kwnames[] = {
7563 (char *) "self",(char *) "rect", NULL
7564 };
7565
7566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7568 if (!SWIG_IsOK(res1)) {
7569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7570 }
7571 arg1 = reinterpret_cast< wxRect * >(argp1);
7572 {
7573 arg2 = &temp2;
7574 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7575 }
7576 {
7577 {
7578 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7579 result = (wxRect *) &_result_ref;
7580 }
7581 if (PyErr_Occurred()) SWIG_fail;
7582 }
7583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7584 return resultobj;
7585 fail:
7586 return NULL;
7587 }
7588
7589
7590 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7591 PyObject *resultobj = 0;
7592 wxRect *arg1 = (wxRect *) 0 ;
7593 PyObject *arg2 = (PyObject *) 0 ;
7594 bool result;
7595 void *argp1 = 0 ;
7596 int res1 = 0 ;
7597 PyObject * obj0 = 0 ;
7598 PyObject * obj1 = 0 ;
7599 char * kwnames[] = {
7600 (char *) "self",(char *) "other", NULL
7601 };
7602
7603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7605 if (!SWIG_IsOK(res1)) {
7606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7607 }
7608 arg1 = reinterpret_cast< wxRect * >(argp1);
7609 arg2 = obj1;
7610 {
7611 result = (bool)wxRect___eq__(arg1,arg2);
7612 if (PyErr_Occurred()) SWIG_fail;
7613 }
7614 {
7615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7616 }
7617 return resultobj;
7618 fail:
7619 return NULL;
7620 }
7621
7622
7623 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7624 PyObject *resultobj = 0;
7625 wxRect *arg1 = (wxRect *) 0 ;
7626 PyObject *arg2 = (PyObject *) 0 ;
7627 bool result;
7628 void *argp1 = 0 ;
7629 int res1 = 0 ;
7630 PyObject * obj0 = 0 ;
7631 PyObject * obj1 = 0 ;
7632 char * kwnames[] = {
7633 (char *) "self",(char *) "other", NULL
7634 };
7635
7636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7638 if (!SWIG_IsOK(res1)) {
7639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7640 }
7641 arg1 = reinterpret_cast< wxRect * >(argp1);
7642 arg2 = obj1;
7643 {
7644 result = (bool)wxRect___ne__(arg1,arg2);
7645 if (PyErr_Occurred()) SWIG_fail;
7646 }
7647 {
7648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7649 }
7650 return resultobj;
7651 fail:
7652 return NULL;
7653 }
7654
7655
7656 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7657 PyObject *resultobj = 0;
7658 wxRect *arg1 = (wxRect *) 0 ;
7659 int arg2 ;
7660 int arg3 ;
7661 bool result;
7662 void *argp1 = 0 ;
7663 int res1 = 0 ;
7664 int val2 ;
7665 int ecode2 = 0 ;
7666 int val3 ;
7667 int ecode3 = 0 ;
7668 PyObject * obj0 = 0 ;
7669 PyObject * obj1 = 0 ;
7670 PyObject * obj2 = 0 ;
7671 char * kwnames[] = {
7672 (char *) "self",(char *) "x",(char *) "y", NULL
7673 };
7674
7675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7677 if (!SWIG_IsOK(res1)) {
7678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7679 }
7680 arg1 = reinterpret_cast< wxRect * >(argp1);
7681 ecode2 = SWIG_AsVal_int(obj1, &val2);
7682 if (!SWIG_IsOK(ecode2)) {
7683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7684 }
7685 arg2 = static_cast< int >(val2);
7686 ecode3 = SWIG_AsVal_int(obj2, &val3);
7687 if (!SWIG_IsOK(ecode3)) {
7688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7689 }
7690 arg3 = static_cast< int >(val3);
7691 {
7692 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7693 if (PyErr_Occurred()) SWIG_fail;
7694 }
7695 {
7696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7697 }
7698 return resultobj;
7699 fail:
7700 return NULL;
7701 }
7702
7703
7704 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7705 PyObject *resultobj = 0;
7706 wxRect *arg1 = (wxRect *) 0 ;
7707 wxPoint *arg2 = 0 ;
7708 bool result;
7709 void *argp1 = 0 ;
7710 int res1 = 0 ;
7711 wxPoint temp2 ;
7712 PyObject * obj0 = 0 ;
7713 PyObject * obj1 = 0 ;
7714 char * kwnames[] = {
7715 (char *) "self",(char *) "pt", NULL
7716 };
7717
7718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7720 if (!SWIG_IsOK(res1)) {
7721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7722 }
7723 arg1 = reinterpret_cast< wxRect * >(argp1);
7724 {
7725 arg2 = &temp2;
7726 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7727 }
7728 {
7729 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7730 if (PyErr_Occurred()) SWIG_fail;
7731 }
7732 {
7733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7734 }
7735 return resultobj;
7736 fail:
7737 return NULL;
7738 }
7739
7740
7741 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7742 PyObject *resultobj = 0;
7743 wxRect *arg1 = (wxRect *) 0 ;
7744 wxRect *arg2 = 0 ;
7745 bool result;
7746 void *argp1 = 0 ;
7747 int res1 = 0 ;
7748 wxRect temp2 ;
7749 PyObject * obj0 = 0 ;
7750 PyObject * obj1 = 0 ;
7751 char * kwnames[] = {
7752 (char *) "self",(char *) "rect", NULL
7753 };
7754
7755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7757 if (!SWIG_IsOK(res1)) {
7758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7759 }
7760 arg1 = reinterpret_cast< wxRect * >(argp1);
7761 {
7762 arg2 = &temp2;
7763 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7764 }
7765 {
7766 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7767 if (PyErr_Occurred()) SWIG_fail;
7768 }
7769 {
7770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7771 }
7772 return resultobj;
7773 fail:
7774 return NULL;
7775 }
7776
7777
7778 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7779 PyObject *resultobj = 0;
7780 wxRect *arg1 = (wxRect *) 0 ;
7781 wxRect *arg2 = 0 ;
7782 bool result;
7783 void *argp1 = 0 ;
7784 int res1 = 0 ;
7785 wxRect temp2 ;
7786 PyObject * obj0 = 0 ;
7787 PyObject * obj1 = 0 ;
7788 char * kwnames[] = {
7789 (char *) "self",(char *) "rect", NULL
7790 };
7791
7792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7794 if (!SWIG_IsOK(res1)) {
7795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7796 }
7797 arg1 = reinterpret_cast< wxRect * >(argp1);
7798 {
7799 arg2 = &temp2;
7800 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7801 }
7802 {
7803 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7804 if (PyErr_Occurred()) SWIG_fail;
7805 }
7806 {
7807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7808 }
7809 return resultobj;
7810 fail:
7811 return NULL;
7812 }
7813
7814
7815 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7816 PyObject *resultobj = 0;
7817 wxRect *arg1 = (wxRect *) 0 ;
7818 wxRect *arg2 = 0 ;
7819 int arg3 = (int) wxBOTH ;
7820 wxRect result;
7821 void *argp1 = 0 ;
7822 int res1 = 0 ;
7823 wxRect temp2 ;
7824 int val3 ;
7825 int ecode3 = 0 ;
7826 PyObject * obj0 = 0 ;
7827 PyObject * obj1 = 0 ;
7828 PyObject * obj2 = 0 ;
7829 char * kwnames[] = {
7830 (char *) "self",(char *) "r",(char *) "dir", NULL
7831 };
7832
7833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7835 if (!SWIG_IsOK(res1)) {
7836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7837 }
7838 arg1 = reinterpret_cast< wxRect * >(argp1);
7839 {
7840 arg2 = &temp2;
7841 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7842 }
7843 if (obj2) {
7844 ecode3 = SWIG_AsVal_int(obj2, &val3);
7845 if (!SWIG_IsOK(ecode3)) {
7846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7847 }
7848 arg3 = static_cast< int >(val3);
7849 }
7850 {
7851 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7852 if (PyErr_Occurred()) SWIG_fail;
7853 }
7854 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7855 return resultobj;
7856 fail:
7857 return NULL;
7858 }
7859
7860
7861 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7862 PyObject *resultobj = 0;
7863 wxRect *arg1 = (wxRect *) 0 ;
7864 int arg2 ;
7865 void *argp1 = 0 ;
7866 int res1 = 0 ;
7867 int val2 ;
7868 int ecode2 = 0 ;
7869 PyObject *swig_obj[2] ;
7870
7871 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7873 if (!SWIG_IsOK(res1)) {
7874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7875 }
7876 arg1 = reinterpret_cast< wxRect * >(argp1);
7877 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7878 if (!SWIG_IsOK(ecode2)) {
7879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7880 }
7881 arg2 = static_cast< int >(val2);
7882 if (arg1) (arg1)->x = arg2;
7883
7884 resultobj = SWIG_Py_Void();
7885 return resultobj;
7886 fail:
7887 return NULL;
7888 }
7889
7890
7891 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7892 PyObject *resultobj = 0;
7893 wxRect *arg1 = (wxRect *) 0 ;
7894 int result;
7895 void *argp1 = 0 ;
7896 int res1 = 0 ;
7897 PyObject *swig_obj[1] ;
7898
7899 if (!args) SWIG_fail;
7900 swig_obj[0] = args;
7901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7902 if (!SWIG_IsOK(res1)) {
7903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7904 }
7905 arg1 = reinterpret_cast< wxRect * >(argp1);
7906 result = (int) ((arg1)->x);
7907 resultobj = SWIG_From_int(static_cast< int >(result));
7908 return resultobj;
7909 fail:
7910 return NULL;
7911 }
7912
7913
7914 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7915 PyObject *resultobj = 0;
7916 wxRect *arg1 = (wxRect *) 0 ;
7917 int arg2 ;
7918 void *argp1 = 0 ;
7919 int res1 = 0 ;
7920 int val2 ;
7921 int ecode2 = 0 ;
7922 PyObject *swig_obj[2] ;
7923
7924 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7926 if (!SWIG_IsOK(res1)) {
7927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7928 }
7929 arg1 = reinterpret_cast< wxRect * >(argp1);
7930 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7931 if (!SWIG_IsOK(ecode2)) {
7932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7933 }
7934 arg2 = static_cast< int >(val2);
7935 if (arg1) (arg1)->y = arg2;
7936
7937 resultobj = SWIG_Py_Void();
7938 return resultobj;
7939 fail:
7940 return NULL;
7941 }
7942
7943
7944 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7945 PyObject *resultobj = 0;
7946 wxRect *arg1 = (wxRect *) 0 ;
7947 int result;
7948 void *argp1 = 0 ;
7949 int res1 = 0 ;
7950 PyObject *swig_obj[1] ;
7951
7952 if (!args) SWIG_fail;
7953 swig_obj[0] = args;
7954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7955 if (!SWIG_IsOK(res1)) {
7956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7957 }
7958 arg1 = reinterpret_cast< wxRect * >(argp1);
7959 result = (int) ((arg1)->y);
7960 resultobj = SWIG_From_int(static_cast< int >(result));
7961 return resultobj;
7962 fail:
7963 return NULL;
7964 }
7965
7966
7967 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7968 PyObject *resultobj = 0;
7969 wxRect *arg1 = (wxRect *) 0 ;
7970 int arg2 ;
7971 void *argp1 = 0 ;
7972 int res1 = 0 ;
7973 int val2 ;
7974 int ecode2 = 0 ;
7975 PyObject *swig_obj[2] ;
7976
7977 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7979 if (!SWIG_IsOK(res1)) {
7980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7981 }
7982 arg1 = reinterpret_cast< wxRect * >(argp1);
7983 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7984 if (!SWIG_IsOK(ecode2)) {
7985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7986 }
7987 arg2 = static_cast< int >(val2);
7988 if (arg1) (arg1)->width = arg2;
7989
7990 resultobj = SWIG_Py_Void();
7991 return resultobj;
7992 fail:
7993 return NULL;
7994 }
7995
7996
7997 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7998 PyObject *resultobj = 0;
7999 wxRect *arg1 = (wxRect *) 0 ;
8000 int result;
8001 void *argp1 = 0 ;
8002 int res1 = 0 ;
8003 PyObject *swig_obj[1] ;
8004
8005 if (!args) SWIG_fail;
8006 swig_obj[0] = args;
8007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8008 if (!SWIG_IsOK(res1)) {
8009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8010 }
8011 arg1 = reinterpret_cast< wxRect * >(argp1);
8012 result = (int) ((arg1)->width);
8013 resultobj = SWIG_From_int(static_cast< int >(result));
8014 return resultobj;
8015 fail:
8016 return NULL;
8017 }
8018
8019
8020 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8021 PyObject *resultobj = 0;
8022 wxRect *arg1 = (wxRect *) 0 ;
8023 int arg2 ;
8024 void *argp1 = 0 ;
8025 int res1 = 0 ;
8026 int val2 ;
8027 int ecode2 = 0 ;
8028 PyObject *swig_obj[2] ;
8029
8030 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8032 if (!SWIG_IsOK(res1)) {
8033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8034 }
8035 arg1 = reinterpret_cast< wxRect * >(argp1);
8036 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8037 if (!SWIG_IsOK(ecode2)) {
8038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8039 }
8040 arg2 = static_cast< int >(val2);
8041 if (arg1) (arg1)->height = arg2;
8042
8043 resultobj = SWIG_Py_Void();
8044 return resultobj;
8045 fail:
8046 return NULL;
8047 }
8048
8049
8050 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8051 PyObject *resultobj = 0;
8052 wxRect *arg1 = (wxRect *) 0 ;
8053 int result;
8054 void *argp1 = 0 ;
8055 int res1 = 0 ;
8056 PyObject *swig_obj[1] ;
8057
8058 if (!args) SWIG_fail;
8059 swig_obj[0] = args;
8060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8061 if (!SWIG_IsOK(res1)) {
8062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8063 }
8064 arg1 = reinterpret_cast< wxRect * >(argp1);
8065 result = (int) ((arg1)->height);
8066 resultobj = SWIG_From_int(static_cast< int >(result));
8067 return resultobj;
8068 fail:
8069 return NULL;
8070 }
8071
8072
8073 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8074 PyObject *resultobj = 0;
8075 wxRect *arg1 = (wxRect *) 0 ;
8076 int arg2 = (int) 0 ;
8077 int arg3 = (int) 0 ;
8078 int arg4 = (int) 0 ;
8079 int arg5 = (int) 0 ;
8080 void *argp1 = 0 ;
8081 int res1 = 0 ;
8082 int val2 ;
8083 int ecode2 = 0 ;
8084 int val3 ;
8085 int ecode3 = 0 ;
8086 int val4 ;
8087 int ecode4 = 0 ;
8088 int val5 ;
8089 int ecode5 = 0 ;
8090 PyObject * obj0 = 0 ;
8091 PyObject * obj1 = 0 ;
8092 PyObject * obj2 = 0 ;
8093 PyObject * obj3 = 0 ;
8094 PyObject * obj4 = 0 ;
8095 char * kwnames[] = {
8096 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8097 };
8098
8099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8101 if (!SWIG_IsOK(res1)) {
8102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8103 }
8104 arg1 = reinterpret_cast< wxRect * >(argp1);
8105 if (obj1) {
8106 ecode2 = SWIG_AsVal_int(obj1, &val2);
8107 if (!SWIG_IsOK(ecode2)) {
8108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8109 }
8110 arg2 = static_cast< int >(val2);
8111 }
8112 if (obj2) {
8113 ecode3 = SWIG_AsVal_int(obj2, &val3);
8114 if (!SWIG_IsOK(ecode3)) {
8115 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8116 }
8117 arg3 = static_cast< int >(val3);
8118 }
8119 if (obj3) {
8120 ecode4 = SWIG_AsVal_int(obj3, &val4);
8121 if (!SWIG_IsOK(ecode4)) {
8122 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8123 }
8124 arg4 = static_cast< int >(val4);
8125 }
8126 if (obj4) {
8127 ecode5 = SWIG_AsVal_int(obj4, &val5);
8128 if (!SWIG_IsOK(ecode5)) {
8129 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8130 }
8131 arg5 = static_cast< int >(val5);
8132 }
8133 {
8134 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8135 if (PyErr_Occurred()) SWIG_fail;
8136 }
8137 resultobj = SWIG_Py_Void();
8138 return resultobj;
8139 fail:
8140 return NULL;
8141 }
8142
8143
8144 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8145 PyObject *resultobj = 0;
8146 wxRect *arg1 = (wxRect *) 0 ;
8147 PyObject *result = 0 ;
8148 void *argp1 = 0 ;
8149 int res1 = 0 ;
8150 PyObject *swig_obj[1] ;
8151
8152 if (!args) SWIG_fail;
8153 swig_obj[0] = args;
8154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8155 if (!SWIG_IsOK(res1)) {
8156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8157 }
8158 arg1 = reinterpret_cast< wxRect * >(argp1);
8159 {
8160 result = (PyObject *)wxRect_Get(arg1);
8161 if (PyErr_Occurred()) SWIG_fail;
8162 }
8163 resultobj = result;
8164 return resultobj;
8165 fail:
8166 return NULL;
8167 }
8168
8169
8170 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8171 PyObject *obj;
8172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8173 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8174 return SWIG_Py_Void();
8175 }
8176
8177 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8178 return SWIG_Python_InitShadowInstance(args);
8179 }
8180
8181 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8182 PyObject *resultobj = 0;
8183 wxRect *arg1 = (wxRect *) 0 ;
8184 wxRect *arg2 = (wxRect *) 0 ;
8185 PyObject *result = 0 ;
8186 void *argp1 = 0 ;
8187 int res1 = 0 ;
8188 void *argp2 = 0 ;
8189 int res2 = 0 ;
8190 PyObject * obj0 = 0 ;
8191 PyObject * obj1 = 0 ;
8192 char * kwnames[] = {
8193 (char *) "r1",(char *) "r2", NULL
8194 };
8195
8196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8198 if (!SWIG_IsOK(res1)) {
8199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8200 }
8201 arg1 = reinterpret_cast< wxRect * >(argp1);
8202 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8203 if (!SWIG_IsOK(res2)) {
8204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8205 }
8206 arg2 = reinterpret_cast< wxRect * >(argp2);
8207 {
8208 if (!wxPyCheckForApp()) SWIG_fail;
8209 PyThreadState* __tstate = wxPyBeginAllowThreads();
8210 result = (PyObject *)wxIntersectRect(arg1,arg2);
8211 wxPyEndAllowThreads(__tstate);
8212 if (PyErr_Occurred()) SWIG_fail;
8213 }
8214 resultobj = result;
8215 return resultobj;
8216 fail:
8217 return NULL;
8218 }
8219
8220
8221 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8222 PyObject *resultobj = 0;
8223 double arg1 = (double) 0.0 ;
8224 double arg2 = (double) 0.0 ;
8225 wxPoint2D *result = 0 ;
8226 double val1 ;
8227 int ecode1 = 0 ;
8228 double val2 ;
8229 int ecode2 = 0 ;
8230 PyObject * obj0 = 0 ;
8231 PyObject * obj1 = 0 ;
8232 char * kwnames[] = {
8233 (char *) "x",(char *) "y", NULL
8234 };
8235
8236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8237 if (obj0) {
8238 ecode1 = SWIG_AsVal_double(obj0, &val1);
8239 if (!SWIG_IsOK(ecode1)) {
8240 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8241 }
8242 arg1 = static_cast< double >(val1);
8243 }
8244 if (obj1) {
8245 ecode2 = SWIG_AsVal_double(obj1, &val2);
8246 if (!SWIG_IsOK(ecode2)) {
8247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8248 }
8249 arg2 = static_cast< double >(val2);
8250 }
8251 {
8252 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8253 if (PyErr_Occurred()) SWIG_fail;
8254 }
8255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8256 return resultobj;
8257 fail:
8258 return NULL;
8259 }
8260
8261
8262 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8263 PyObject *resultobj = 0;
8264 wxPoint2D *arg1 = 0 ;
8265 wxPoint2D *result = 0 ;
8266 wxPoint2D temp1 ;
8267 PyObject * obj0 = 0 ;
8268 char * kwnames[] = {
8269 (char *) "pt", NULL
8270 };
8271
8272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8273 {
8274 arg1 = &temp1;
8275 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8276 }
8277 {
8278 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8279 if (PyErr_Occurred()) SWIG_fail;
8280 }
8281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8282 return resultobj;
8283 fail:
8284 return NULL;
8285 }
8286
8287
8288 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8289 PyObject *resultobj = 0;
8290 wxPoint *arg1 = 0 ;
8291 wxPoint2D *result = 0 ;
8292 wxPoint temp1 ;
8293 PyObject * obj0 = 0 ;
8294 char * kwnames[] = {
8295 (char *) "pt", NULL
8296 };
8297
8298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8299 {
8300 arg1 = &temp1;
8301 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8302 }
8303 {
8304 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8305 if (PyErr_Occurred()) SWIG_fail;
8306 }
8307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8308 return resultobj;
8309 fail:
8310 return NULL;
8311 }
8312
8313
8314 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8315 PyObject *resultobj = 0;
8316 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8317 void *argp1 = 0 ;
8318 int res1 = 0 ;
8319 PyObject *swig_obj[1] ;
8320
8321 if (!args) SWIG_fail;
8322 swig_obj[0] = args;
8323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8324 if (!SWIG_IsOK(res1)) {
8325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8326 }
8327 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8328 {
8329 delete arg1;
8330
8331 if (PyErr_Occurred()) SWIG_fail;
8332 }
8333 resultobj = SWIG_Py_Void();
8334 return resultobj;
8335 fail:
8336 return NULL;
8337 }
8338
8339
8340 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8341 PyObject *resultobj = 0;
8342 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8343 int *arg2 = (int *) 0 ;
8344 int *arg3 = (int *) 0 ;
8345 void *argp1 = 0 ;
8346 int res1 = 0 ;
8347 int temp2 ;
8348 int res2 = SWIG_TMPOBJ ;
8349 int temp3 ;
8350 int res3 = SWIG_TMPOBJ ;
8351 PyObject *swig_obj[1] ;
8352
8353 arg2 = &temp2;
8354 arg3 = &temp3;
8355 if (!args) SWIG_fail;
8356 swig_obj[0] = args;
8357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8358 if (!SWIG_IsOK(res1)) {
8359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8360 }
8361 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8362 {
8363 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8364 if (PyErr_Occurred()) SWIG_fail;
8365 }
8366 resultobj = SWIG_Py_Void();
8367 if (SWIG_IsTmpObj(res2)) {
8368 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8369 } else {
8370 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8371 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8372 }
8373 if (SWIG_IsTmpObj(res3)) {
8374 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8375 } else {
8376 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8377 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8378 }
8379 return resultobj;
8380 fail:
8381 return NULL;
8382 }
8383
8384
8385 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8386 PyObject *resultobj = 0;
8387 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8388 int *arg2 = (int *) 0 ;
8389 int *arg3 = (int *) 0 ;
8390 void *argp1 = 0 ;
8391 int res1 = 0 ;
8392 int temp2 ;
8393 int res2 = SWIG_TMPOBJ ;
8394 int temp3 ;
8395 int res3 = SWIG_TMPOBJ ;
8396 PyObject *swig_obj[1] ;
8397
8398 arg2 = &temp2;
8399 arg3 = &temp3;
8400 if (!args) SWIG_fail;
8401 swig_obj[0] = args;
8402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8403 if (!SWIG_IsOK(res1)) {
8404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8405 }
8406 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8407 {
8408 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8409 if (PyErr_Occurred()) SWIG_fail;
8410 }
8411 resultobj = SWIG_Py_Void();
8412 if (SWIG_IsTmpObj(res2)) {
8413 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8414 } else {
8415 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8416 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8417 }
8418 if (SWIG_IsTmpObj(res3)) {
8419 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8420 } else {
8421 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8422 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8423 }
8424 return resultobj;
8425 fail:
8426 return NULL;
8427 }
8428
8429
8430 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8431 PyObject *resultobj = 0;
8432 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8433 double result;
8434 void *argp1 = 0 ;
8435 int res1 = 0 ;
8436 PyObject *swig_obj[1] ;
8437
8438 if (!args) SWIG_fail;
8439 swig_obj[0] = args;
8440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8441 if (!SWIG_IsOK(res1)) {
8442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8443 }
8444 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8445 {
8446 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8447 if (PyErr_Occurred()) SWIG_fail;
8448 }
8449 resultobj = SWIG_From_double(static_cast< double >(result));
8450 return resultobj;
8451 fail:
8452 return NULL;
8453 }
8454
8455
8456 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8457 PyObject *resultobj = 0;
8458 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8459 double result;
8460 void *argp1 = 0 ;
8461 int res1 = 0 ;
8462 PyObject *swig_obj[1] ;
8463
8464 if (!args) SWIG_fail;
8465 swig_obj[0] = args;
8466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8467 if (!SWIG_IsOK(res1)) {
8468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8469 }
8470 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8471 {
8472 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8473 if (PyErr_Occurred()) SWIG_fail;
8474 }
8475 resultobj = SWIG_From_double(static_cast< double >(result));
8476 return resultobj;
8477 fail:
8478 return NULL;
8479 }
8480
8481
8482 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8483 PyObject *resultobj = 0;
8484 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8485 double arg2 ;
8486 void *argp1 = 0 ;
8487 int res1 = 0 ;
8488 double val2 ;
8489 int ecode2 = 0 ;
8490 PyObject * obj0 = 0 ;
8491 PyObject * obj1 = 0 ;
8492 char * kwnames[] = {
8493 (char *) "self",(char *) "length", NULL
8494 };
8495
8496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8498 if (!SWIG_IsOK(res1)) {
8499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8500 }
8501 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8502 ecode2 = SWIG_AsVal_double(obj1, &val2);
8503 if (!SWIG_IsOK(ecode2)) {
8504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8505 }
8506 arg2 = static_cast< double >(val2);
8507 {
8508 (arg1)->SetVectorLength(arg2);
8509 if (PyErr_Occurred()) SWIG_fail;
8510 }
8511 resultobj = SWIG_Py_Void();
8512 return resultobj;
8513 fail:
8514 return NULL;
8515 }
8516
8517
8518 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8519 PyObject *resultobj = 0;
8520 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8521 double arg2 ;
8522 void *argp1 = 0 ;
8523 int res1 = 0 ;
8524 double val2 ;
8525 int ecode2 = 0 ;
8526 PyObject * obj0 = 0 ;
8527 PyObject * obj1 = 0 ;
8528 char * kwnames[] = {
8529 (char *) "self",(char *) "degrees", NULL
8530 };
8531
8532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8534 if (!SWIG_IsOK(res1)) {
8535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8536 }
8537 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8538 ecode2 = SWIG_AsVal_double(obj1, &val2);
8539 if (!SWIG_IsOK(ecode2)) {
8540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8541 }
8542 arg2 = static_cast< double >(val2);
8543 {
8544 (arg1)->SetVectorAngle(arg2);
8545 if (PyErr_Occurred()) SWIG_fail;
8546 }
8547 resultobj = SWIG_Py_Void();
8548 return resultobj;
8549 fail:
8550 return NULL;
8551 }
8552
8553
8554 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8555 PyObject *resultobj = 0;
8556 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8557 wxPoint2D *arg2 = 0 ;
8558 double result;
8559 void *argp1 = 0 ;
8560 int res1 = 0 ;
8561 wxPoint2D temp2 ;
8562 PyObject * obj0 = 0 ;
8563 PyObject * obj1 = 0 ;
8564 char * kwnames[] = {
8565 (char *) "self",(char *) "pt", NULL
8566 };
8567
8568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8570 if (!SWIG_IsOK(res1)) {
8571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8572 }
8573 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8574 {
8575 arg2 = &temp2;
8576 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8577 }
8578 {
8579 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8580 if (PyErr_Occurred()) SWIG_fail;
8581 }
8582 resultobj = SWIG_From_double(static_cast< double >(result));
8583 return resultobj;
8584 fail:
8585 return NULL;
8586 }
8587
8588
8589 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8590 PyObject *resultobj = 0;
8591 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8592 wxPoint2D *arg2 = 0 ;
8593 double result;
8594 void *argp1 = 0 ;
8595 int res1 = 0 ;
8596 wxPoint2D temp2 ;
8597 PyObject * obj0 = 0 ;
8598 PyObject * obj1 = 0 ;
8599 char * kwnames[] = {
8600 (char *) "self",(char *) "pt", NULL
8601 };
8602
8603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8605 if (!SWIG_IsOK(res1)) {
8606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8607 }
8608 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8609 {
8610 arg2 = &temp2;
8611 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8612 }
8613 {
8614 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8615 if (PyErr_Occurred()) SWIG_fail;
8616 }
8617 resultobj = SWIG_From_double(static_cast< double >(result));
8618 return resultobj;
8619 fail:
8620 return NULL;
8621 }
8622
8623
8624 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8625 PyObject *resultobj = 0;
8626 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8627 wxPoint2D *arg2 = 0 ;
8628 double result;
8629 void *argp1 = 0 ;
8630 int res1 = 0 ;
8631 wxPoint2D temp2 ;
8632 PyObject * obj0 = 0 ;
8633 PyObject * obj1 = 0 ;
8634 char * kwnames[] = {
8635 (char *) "self",(char *) "vec", NULL
8636 };
8637
8638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8640 if (!SWIG_IsOK(res1)) {
8641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8642 }
8643 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8644 {
8645 arg2 = &temp2;
8646 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8647 }
8648 {
8649 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8650 if (PyErr_Occurred()) SWIG_fail;
8651 }
8652 resultobj = SWIG_From_double(static_cast< double >(result));
8653 return resultobj;
8654 fail:
8655 return NULL;
8656 }
8657
8658
8659 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8660 PyObject *resultobj = 0;
8661 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8662 wxPoint2D *arg2 = 0 ;
8663 double result;
8664 void *argp1 = 0 ;
8665 int res1 = 0 ;
8666 wxPoint2D temp2 ;
8667 PyObject * obj0 = 0 ;
8668 PyObject * obj1 = 0 ;
8669 char * kwnames[] = {
8670 (char *) "self",(char *) "vec", NULL
8671 };
8672
8673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8675 if (!SWIG_IsOK(res1)) {
8676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8677 }
8678 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8679 {
8680 arg2 = &temp2;
8681 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8682 }
8683 {
8684 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8685 if (PyErr_Occurred()) SWIG_fail;
8686 }
8687 resultobj = SWIG_From_double(static_cast< double >(result));
8688 return resultobj;
8689 fail:
8690 return NULL;
8691 }
8692
8693
8694 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8695 PyObject *resultobj = 0;
8696 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8697 wxPoint2D result;
8698 void *argp1 = 0 ;
8699 int res1 = 0 ;
8700 PyObject *swig_obj[1] ;
8701
8702 if (!args) SWIG_fail;
8703 swig_obj[0] = args;
8704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8705 if (!SWIG_IsOK(res1)) {
8706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8707 }
8708 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8709 {
8710 result = (arg1)->operator -();
8711 if (PyErr_Occurred()) SWIG_fail;
8712 }
8713 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8714 return resultobj;
8715 fail:
8716 return NULL;
8717 }
8718
8719
8720 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8721 PyObject *resultobj = 0;
8722 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8723 wxPoint2D *arg2 = 0 ;
8724 wxPoint2D *result = 0 ;
8725 void *argp1 = 0 ;
8726 int res1 = 0 ;
8727 wxPoint2D temp2 ;
8728 PyObject * obj0 = 0 ;
8729 PyObject * obj1 = 0 ;
8730 char * kwnames[] = {
8731 (char *) "self",(char *) "pt", NULL
8732 };
8733
8734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8736 if (!SWIG_IsOK(res1)) {
8737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8738 }
8739 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8740 {
8741 arg2 = &temp2;
8742 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8743 }
8744 {
8745 {
8746 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8747 result = (wxPoint2D *) &_result_ref;
8748 }
8749 if (PyErr_Occurred()) SWIG_fail;
8750 }
8751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8752 return resultobj;
8753 fail:
8754 return NULL;
8755 }
8756
8757
8758 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8759 PyObject *resultobj = 0;
8760 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8761 wxPoint2D *arg2 = 0 ;
8762 wxPoint2D *result = 0 ;
8763 void *argp1 = 0 ;
8764 int res1 = 0 ;
8765 wxPoint2D temp2 ;
8766 PyObject * obj0 = 0 ;
8767 PyObject * obj1 = 0 ;
8768 char * kwnames[] = {
8769 (char *) "self",(char *) "pt", NULL
8770 };
8771
8772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8774 if (!SWIG_IsOK(res1)) {
8775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8776 }
8777 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8778 {
8779 arg2 = &temp2;
8780 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8781 }
8782 {
8783 {
8784 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8785 result = (wxPoint2D *) &_result_ref;
8786 }
8787 if (PyErr_Occurred()) SWIG_fail;
8788 }
8789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8790 return resultobj;
8791 fail:
8792 return NULL;
8793 }
8794
8795
8796 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8797 PyObject *resultobj = 0;
8798 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8799 wxPoint2D *arg2 = 0 ;
8800 wxPoint2D *result = 0 ;
8801 void *argp1 = 0 ;
8802 int res1 = 0 ;
8803 wxPoint2D temp2 ;
8804 PyObject * obj0 = 0 ;
8805 PyObject * obj1 = 0 ;
8806 char * kwnames[] = {
8807 (char *) "self",(char *) "pt", NULL
8808 };
8809
8810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8812 if (!SWIG_IsOK(res1)) {
8813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8814 }
8815 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8816 {
8817 arg2 = &temp2;
8818 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8819 }
8820 {
8821 {
8822 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8823 result = (wxPoint2D *) &_result_ref;
8824 }
8825 if (PyErr_Occurred()) SWIG_fail;
8826 }
8827 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8828 return resultobj;
8829 fail:
8830 return NULL;
8831 }
8832
8833
8834 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8835 PyObject *resultobj = 0;
8836 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8837 wxPoint2D *arg2 = 0 ;
8838 wxPoint2D *result = 0 ;
8839 void *argp1 = 0 ;
8840 int res1 = 0 ;
8841 wxPoint2D temp2 ;
8842 PyObject * obj0 = 0 ;
8843 PyObject * obj1 = 0 ;
8844 char * kwnames[] = {
8845 (char *) "self",(char *) "pt", NULL
8846 };
8847
8848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8850 if (!SWIG_IsOK(res1)) {
8851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8852 }
8853 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8854 {
8855 arg2 = &temp2;
8856 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8857 }
8858 {
8859 {
8860 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8861 result = (wxPoint2D *) &_result_ref;
8862 }
8863 if (PyErr_Occurred()) SWIG_fail;
8864 }
8865 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8866 return resultobj;
8867 fail:
8868 return NULL;
8869 }
8870
8871
8872 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8873 PyObject *resultobj = 0;
8874 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8875 PyObject *arg2 = (PyObject *) 0 ;
8876 bool result;
8877 void *argp1 = 0 ;
8878 int res1 = 0 ;
8879 PyObject * obj0 = 0 ;
8880 PyObject * obj1 = 0 ;
8881 char * kwnames[] = {
8882 (char *) "self",(char *) "other", NULL
8883 };
8884
8885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8887 if (!SWIG_IsOK(res1)) {
8888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8889 }
8890 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8891 arg2 = obj1;
8892 {
8893 result = (bool)wxPoint2D___eq__(arg1,arg2);
8894 if (PyErr_Occurred()) SWIG_fail;
8895 }
8896 {
8897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8898 }
8899 return resultobj;
8900 fail:
8901 return NULL;
8902 }
8903
8904
8905 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8906 PyObject *resultobj = 0;
8907 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8908 PyObject *arg2 = (PyObject *) 0 ;
8909 bool result;
8910 void *argp1 = 0 ;
8911 int res1 = 0 ;
8912 PyObject * obj0 = 0 ;
8913 PyObject * obj1 = 0 ;
8914 char * kwnames[] = {
8915 (char *) "self",(char *) "other", NULL
8916 };
8917
8918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8920 if (!SWIG_IsOK(res1)) {
8921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8922 }
8923 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8924 arg2 = obj1;
8925 {
8926 result = (bool)wxPoint2D___ne__(arg1,arg2);
8927 if (PyErr_Occurred()) SWIG_fail;
8928 }
8929 {
8930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8931 }
8932 return resultobj;
8933 fail:
8934 return NULL;
8935 }
8936
8937
8938 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8939 PyObject *resultobj = 0;
8940 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8941 double arg2 ;
8942 void *argp1 = 0 ;
8943 int res1 = 0 ;
8944 double val2 ;
8945 int ecode2 = 0 ;
8946 PyObject *swig_obj[2] ;
8947
8948 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8950 if (!SWIG_IsOK(res1)) {
8951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8952 }
8953 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8954 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8955 if (!SWIG_IsOK(ecode2)) {
8956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8957 }
8958 arg2 = static_cast< double >(val2);
8959 if (arg1) (arg1)->m_x = arg2;
8960
8961 resultobj = SWIG_Py_Void();
8962 return resultobj;
8963 fail:
8964 return NULL;
8965 }
8966
8967
8968 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8969 PyObject *resultobj = 0;
8970 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8971 double result;
8972 void *argp1 = 0 ;
8973 int res1 = 0 ;
8974 PyObject *swig_obj[1] ;
8975
8976 if (!args) SWIG_fail;
8977 swig_obj[0] = args;
8978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8979 if (!SWIG_IsOK(res1)) {
8980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8981 }
8982 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8983 result = (double) ((arg1)->m_x);
8984 resultobj = SWIG_From_double(static_cast< double >(result));
8985 return resultobj;
8986 fail:
8987 return NULL;
8988 }
8989
8990
8991 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8992 PyObject *resultobj = 0;
8993 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8994 double arg2 ;
8995 void *argp1 = 0 ;
8996 int res1 = 0 ;
8997 double val2 ;
8998 int ecode2 = 0 ;
8999 PyObject *swig_obj[2] ;
9000
9001 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9003 if (!SWIG_IsOK(res1)) {
9004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9005 }
9006 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9007 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9008 if (!SWIG_IsOK(ecode2)) {
9009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9010 }
9011 arg2 = static_cast< double >(val2);
9012 if (arg1) (arg1)->m_y = arg2;
9013
9014 resultobj = SWIG_Py_Void();
9015 return resultobj;
9016 fail:
9017 return NULL;
9018 }
9019
9020
9021 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9022 PyObject *resultobj = 0;
9023 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9024 double result;
9025 void *argp1 = 0 ;
9026 int res1 = 0 ;
9027 PyObject *swig_obj[1] ;
9028
9029 if (!args) SWIG_fail;
9030 swig_obj[0] = args;
9031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9032 if (!SWIG_IsOK(res1)) {
9033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9034 }
9035 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9036 result = (double) ((arg1)->m_y);
9037 resultobj = SWIG_From_double(static_cast< double >(result));
9038 return resultobj;
9039 fail:
9040 return NULL;
9041 }
9042
9043
9044 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9045 PyObject *resultobj = 0;
9046 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9047 double arg2 = (double) 0 ;
9048 double arg3 = (double) 0 ;
9049 void *argp1 = 0 ;
9050 int res1 = 0 ;
9051 double val2 ;
9052 int ecode2 = 0 ;
9053 double val3 ;
9054 int ecode3 = 0 ;
9055 PyObject * obj0 = 0 ;
9056 PyObject * obj1 = 0 ;
9057 PyObject * obj2 = 0 ;
9058 char * kwnames[] = {
9059 (char *) "self",(char *) "x",(char *) "y", NULL
9060 };
9061
9062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9064 if (!SWIG_IsOK(res1)) {
9065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9066 }
9067 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9068 if (obj1) {
9069 ecode2 = SWIG_AsVal_double(obj1, &val2);
9070 if (!SWIG_IsOK(ecode2)) {
9071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9072 }
9073 arg2 = static_cast< double >(val2);
9074 }
9075 if (obj2) {
9076 ecode3 = SWIG_AsVal_double(obj2, &val3);
9077 if (!SWIG_IsOK(ecode3)) {
9078 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9079 }
9080 arg3 = static_cast< double >(val3);
9081 }
9082 {
9083 wxPoint2D_Set(arg1,arg2,arg3);
9084 if (PyErr_Occurred()) SWIG_fail;
9085 }
9086 resultobj = SWIG_Py_Void();
9087 return resultobj;
9088 fail:
9089 return NULL;
9090 }
9091
9092
9093 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9094 PyObject *resultobj = 0;
9095 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9096 PyObject *result = 0 ;
9097 void *argp1 = 0 ;
9098 int res1 = 0 ;
9099 PyObject *swig_obj[1] ;
9100
9101 if (!args) SWIG_fail;
9102 swig_obj[0] = args;
9103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9104 if (!SWIG_IsOK(res1)) {
9105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9106 }
9107 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9108 {
9109 result = (PyObject *)wxPoint2D_Get(arg1);
9110 if (PyErr_Occurred()) SWIG_fail;
9111 }
9112 resultobj = result;
9113 return resultobj;
9114 fail:
9115 return NULL;
9116 }
9117
9118
9119 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9120 PyObject *obj;
9121 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9122 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9123 return SWIG_Py_Void();
9124 }
9125
9126 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9127 return SWIG_Python_InitShadowInstance(args);
9128 }
9129
9130 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9131 PyObject *resultobj = 0;
9132 wxDouble arg1 = (wxDouble) 0.0 ;
9133 wxDouble arg2 = (wxDouble) 0.0 ;
9134 wxDouble arg3 = (wxDouble) 0.0 ;
9135 wxDouble arg4 = (wxDouble) 0.0 ;
9136 wxRect2D *result = 0 ;
9137 void *argp1 ;
9138 int res1 = 0 ;
9139 void *argp2 ;
9140 int res2 = 0 ;
9141 void *argp3 ;
9142 int res3 = 0 ;
9143 void *argp4 ;
9144 int res4 = 0 ;
9145 PyObject * obj0 = 0 ;
9146 PyObject * obj1 = 0 ;
9147 PyObject * obj2 = 0 ;
9148 PyObject * obj3 = 0 ;
9149 char * kwnames[] = {
9150 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9151 };
9152
9153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9154 if (obj0) {
9155 {
9156 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9157 if (!SWIG_IsOK(res1)) {
9158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9159 }
9160 if (!argp1) {
9161 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9162 } else {
9163 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9164 arg1 = *temp;
9165 if (SWIG_IsNewObj(res1)) delete temp;
9166 }
9167 }
9168 }
9169 if (obj1) {
9170 {
9171 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9172 if (!SWIG_IsOK(res2)) {
9173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9174 }
9175 if (!argp2) {
9176 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9177 } else {
9178 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9179 arg2 = *temp;
9180 if (SWIG_IsNewObj(res2)) delete temp;
9181 }
9182 }
9183 }
9184 if (obj2) {
9185 {
9186 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9187 if (!SWIG_IsOK(res3)) {
9188 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9189 }
9190 if (!argp3) {
9191 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9192 } else {
9193 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9194 arg3 = *temp;
9195 if (SWIG_IsNewObj(res3)) delete temp;
9196 }
9197 }
9198 }
9199 if (obj3) {
9200 {
9201 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9202 if (!SWIG_IsOK(res4)) {
9203 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9204 }
9205 if (!argp4) {
9206 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9207 } else {
9208 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9209 arg4 = *temp;
9210 if (SWIG_IsNewObj(res4)) delete temp;
9211 }
9212 }
9213 }
9214 {
9215 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9216 if (PyErr_Occurred()) SWIG_fail;
9217 }
9218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9219 return resultobj;
9220 fail:
9221 return NULL;
9222 }
9223
9224
9225 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9226 PyObject *resultobj = 0;
9227 wxRect2D *arg1 = (wxRect2D *) 0 ;
9228 void *argp1 = 0 ;
9229 int res1 = 0 ;
9230 PyObject *swig_obj[1] ;
9231
9232 if (!args) SWIG_fail;
9233 swig_obj[0] = args;
9234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9235 if (!SWIG_IsOK(res1)) {
9236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9237 }
9238 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9239 {
9240 delete arg1;
9241
9242 if (PyErr_Occurred()) SWIG_fail;
9243 }
9244 resultobj = SWIG_Py_Void();
9245 return resultobj;
9246 fail:
9247 return NULL;
9248 }
9249
9250
9251 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9252 PyObject *resultobj = 0;
9253 wxRect2D *arg1 = (wxRect2D *) 0 ;
9254 wxPoint2D result;
9255 void *argp1 = 0 ;
9256 int res1 = 0 ;
9257 PyObject *swig_obj[1] ;
9258
9259 if (!args) SWIG_fail;
9260 swig_obj[0] = args;
9261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9262 if (!SWIG_IsOK(res1)) {
9263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9264 }
9265 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9266 {
9267 result = (arg1)->GetPosition();
9268 if (PyErr_Occurred()) SWIG_fail;
9269 }
9270 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9271 return resultobj;
9272 fail:
9273 return NULL;
9274 }
9275
9276
9277 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9278 PyObject *resultobj = 0;
9279 wxRect2D *arg1 = (wxRect2D *) 0 ;
9280 wxSize result;
9281 void *argp1 = 0 ;
9282 int res1 = 0 ;
9283 PyObject *swig_obj[1] ;
9284
9285 if (!args) SWIG_fail;
9286 swig_obj[0] = args;
9287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9288 if (!SWIG_IsOK(res1)) {
9289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9290 }
9291 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9292 {
9293 result = (arg1)->GetSize();
9294 if (PyErr_Occurred()) SWIG_fail;
9295 }
9296 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9297 return resultobj;
9298 fail:
9299 return NULL;
9300 }
9301
9302
9303 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9304 PyObject *resultobj = 0;
9305 wxRect2D *arg1 = (wxRect2D *) 0 ;
9306 wxDouble result;
9307 void *argp1 = 0 ;
9308 int res1 = 0 ;
9309 PyObject *swig_obj[1] ;
9310
9311 if (!args) SWIG_fail;
9312 swig_obj[0] = args;
9313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9314 if (!SWIG_IsOK(res1)) {
9315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9316 }
9317 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9318 {
9319 result = ((wxRect2D const *)arg1)->GetLeft();
9320 if (PyErr_Occurred()) SWIG_fail;
9321 }
9322 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9323 return resultobj;
9324 fail:
9325 return NULL;
9326 }
9327
9328
9329 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9330 PyObject *resultobj = 0;
9331 wxRect2D *arg1 = (wxRect2D *) 0 ;
9332 wxDouble arg2 ;
9333 void *argp1 = 0 ;
9334 int res1 = 0 ;
9335 void *argp2 ;
9336 int res2 = 0 ;
9337 PyObject * obj0 = 0 ;
9338 PyObject * obj1 = 0 ;
9339 char * kwnames[] = {
9340 (char *) "self",(char *) "n", NULL
9341 };
9342
9343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9345 if (!SWIG_IsOK(res1)) {
9346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9347 }
9348 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9349 {
9350 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9351 if (!SWIG_IsOK(res2)) {
9352 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9353 }
9354 if (!argp2) {
9355 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9356 } else {
9357 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9358 arg2 = *temp;
9359 if (SWIG_IsNewObj(res2)) delete temp;
9360 }
9361 }
9362 {
9363 (arg1)->SetLeft(arg2);
9364 if (PyErr_Occurred()) SWIG_fail;
9365 }
9366 resultobj = SWIG_Py_Void();
9367 return resultobj;
9368 fail:
9369 return NULL;
9370 }
9371
9372
9373 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9374 PyObject *resultobj = 0;
9375 wxRect2D *arg1 = (wxRect2D *) 0 ;
9376 wxDouble arg2 ;
9377 void *argp1 = 0 ;
9378 int res1 = 0 ;
9379 void *argp2 ;
9380 int res2 = 0 ;
9381 PyObject * obj0 = 0 ;
9382 PyObject * obj1 = 0 ;
9383 char * kwnames[] = {
9384 (char *) "self",(char *) "n", NULL
9385 };
9386
9387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9389 if (!SWIG_IsOK(res1)) {
9390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9391 }
9392 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9393 {
9394 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9395 if (!SWIG_IsOK(res2)) {
9396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9397 }
9398 if (!argp2) {
9399 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9400 } else {
9401 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9402 arg2 = *temp;
9403 if (SWIG_IsNewObj(res2)) delete temp;
9404 }
9405 }
9406 {
9407 (arg1)->MoveLeftTo(arg2);
9408 if (PyErr_Occurred()) SWIG_fail;
9409 }
9410 resultobj = SWIG_Py_Void();
9411 return resultobj;
9412 fail:
9413 return NULL;
9414 }
9415
9416
9417 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9418 PyObject *resultobj = 0;
9419 wxRect2D *arg1 = (wxRect2D *) 0 ;
9420 wxDouble result;
9421 void *argp1 = 0 ;
9422 int res1 = 0 ;
9423 PyObject *swig_obj[1] ;
9424
9425 if (!args) SWIG_fail;
9426 swig_obj[0] = args;
9427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9428 if (!SWIG_IsOK(res1)) {
9429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9430 }
9431 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9432 {
9433 result = ((wxRect2D const *)arg1)->GetTop();
9434 if (PyErr_Occurred()) SWIG_fail;
9435 }
9436 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9437 return resultobj;
9438 fail:
9439 return NULL;
9440 }
9441
9442
9443 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9444 PyObject *resultobj = 0;
9445 wxRect2D *arg1 = (wxRect2D *) 0 ;
9446 wxDouble arg2 ;
9447 void *argp1 = 0 ;
9448 int res1 = 0 ;
9449 void *argp2 ;
9450 int res2 = 0 ;
9451 PyObject * obj0 = 0 ;
9452 PyObject * obj1 = 0 ;
9453 char * kwnames[] = {
9454 (char *) "self",(char *) "n", NULL
9455 };
9456
9457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9459 if (!SWIG_IsOK(res1)) {
9460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9461 }
9462 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9463 {
9464 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9465 if (!SWIG_IsOK(res2)) {
9466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9467 }
9468 if (!argp2) {
9469 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9470 } else {
9471 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9472 arg2 = *temp;
9473 if (SWIG_IsNewObj(res2)) delete temp;
9474 }
9475 }
9476 {
9477 (arg1)->SetTop(arg2);
9478 if (PyErr_Occurred()) SWIG_fail;
9479 }
9480 resultobj = SWIG_Py_Void();
9481 return resultobj;
9482 fail:
9483 return NULL;
9484 }
9485
9486
9487 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9488 PyObject *resultobj = 0;
9489 wxRect2D *arg1 = (wxRect2D *) 0 ;
9490 wxDouble arg2 ;
9491 void *argp1 = 0 ;
9492 int res1 = 0 ;
9493 void *argp2 ;
9494 int res2 = 0 ;
9495 PyObject * obj0 = 0 ;
9496 PyObject * obj1 = 0 ;
9497 char * kwnames[] = {
9498 (char *) "self",(char *) "n", NULL
9499 };
9500
9501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9503 if (!SWIG_IsOK(res1)) {
9504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9505 }
9506 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9507 {
9508 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9509 if (!SWIG_IsOK(res2)) {
9510 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9511 }
9512 if (!argp2) {
9513 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9514 } else {
9515 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9516 arg2 = *temp;
9517 if (SWIG_IsNewObj(res2)) delete temp;
9518 }
9519 }
9520 {
9521 (arg1)->MoveTopTo(arg2);
9522 if (PyErr_Occurred()) SWIG_fail;
9523 }
9524 resultobj = SWIG_Py_Void();
9525 return resultobj;
9526 fail:
9527 return NULL;
9528 }
9529
9530
9531 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9532 PyObject *resultobj = 0;
9533 wxRect2D *arg1 = (wxRect2D *) 0 ;
9534 wxDouble result;
9535 void *argp1 = 0 ;
9536 int res1 = 0 ;
9537 PyObject *swig_obj[1] ;
9538
9539 if (!args) SWIG_fail;
9540 swig_obj[0] = args;
9541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9542 if (!SWIG_IsOK(res1)) {
9543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9544 }
9545 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9546 {
9547 result = ((wxRect2D const *)arg1)->GetBottom();
9548 if (PyErr_Occurred()) SWIG_fail;
9549 }
9550 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9551 return resultobj;
9552 fail:
9553 return NULL;
9554 }
9555
9556
9557 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9558 PyObject *resultobj = 0;
9559 wxRect2D *arg1 = (wxRect2D *) 0 ;
9560 wxDouble arg2 ;
9561 void *argp1 = 0 ;
9562 int res1 = 0 ;
9563 void *argp2 ;
9564 int res2 = 0 ;
9565 PyObject * obj0 = 0 ;
9566 PyObject * obj1 = 0 ;
9567 char * kwnames[] = {
9568 (char *) "self",(char *) "n", NULL
9569 };
9570
9571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9573 if (!SWIG_IsOK(res1)) {
9574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9575 }
9576 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9577 {
9578 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9579 if (!SWIG_IsOK(res2)) {
9580 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9581 }
9582 if (!argp2) {
9583 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9584 } else {
9585 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9586 arg2 = *temp;
9587 if (SWIG_IsNewObj(res2)) delete temp;
9588 }
9589 }
9590 {
9591 (arg1)->SetBottom(arg2);
9592 if (PyErr_Occurred()) SWIG_fail;
9593 }
9594 resultobj = SWIG_Py_Void();
9595 return resultobj;
9596 fail:
9597 return NULL;
9598 }
9599
9600
9601 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9602 PyObject *resultobj = 0;
9603 wxRect2D *arg1 = (wxRect2D *) 0 ;
9604 wxDouble arg2 ;
9605 void *argp1 = 0 ;
9606 int res1 = 0 ;
9607 void *argp2 ;
9608 int res2 = 0 ;
9609 PyObject * obj0 = 0 ;
9610 PyObject * obj1 = 0 ;
9611 char * kwnames[] = {
9612 (char *) "self",(char *) "n", NULL
9613 };
9614
9615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9617 if (!SWIG_IsOK(res1)) {
9618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9619 }
9620 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9621 {
9622 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9623 if (!SWIG_IsOK(res2)) {
9624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9625 }
9626 if (!argp2) {
9627 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9628 } else {
9629 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9630 arg2 = *temp;
9631 if (SWIG_IsNewObj(res2)) delete temp;
9632 }
9633 }
9634 {
9635 (arg1)->MoveBottomTo(arg2);
9636 if (PyErr_Occurred()) SWIG_fail;
9637 }
9638 resultobj = SWIG_Py_Void();
9639 return resultobj;
9640 fail:
9641 return NULL;
9642 }
9643
9644
9645 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9646 PyObject *resultobj = 0;
9647 wxRect2D *arg1 = (wxRect2D *) 0 ;
9648 wxDouble result;
9649 void *argp1 = 0 ;
9650 int res1 = 0 ;
9651 PyObject *swig_obj[1] ;
9652
9653 if (!args) SWIG_fail;
9654 swig_obj[0] = args;
9655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9656 if (!SWIG_IsOK(res1)) {
9657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9658 }
9659 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9660 {
9661 result = ((wxRect2D const *)arg1)->GetRight();
9662 if (PyErr_Occurred()) SWIG_fail;
9663 }
9664 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9665 return resultobj;
9666 fail:
9667 return NULL;
9668 }
9669
9670
9671 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9672 PyObject *resultobj = 0;
9673 wxRect2D *arg1 = (wxRect2D *) 0 ;
9674 wxDouble arg2 ;
9675 void *argp1 = 0 ;
9676 int res1 = 0 ;
9677 void *argp2 ;
9678 int res2 = 0 ;
9679 PyObject * obj0 = 0 ;
9680 PyObject * obj1 = 0 ;
9681 char * kwnames[] = {
9682 (char *) "self",(char *) "n", NULL
9683 };
9684
9685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9687 if (!SWIG_IsOK(res1)) {
9688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9689 }
9690 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9691 {
9692 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9693 if (!SWIG_IsOK(res2)) {
9694 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9695 }
9696 if (!argp2) {
9697 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9698 } else {
9699 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9700 arg2 = *temp;
9701 if (SWIG_IsNewObj(res2)) delete temp;
9702 }
9703 }
9704 {
9705 (arg1)->SetRight(arg2);
9706 if (PyErr_Occurred()) SWIG_fail;
9707 }
9708 resultobj = SWIG_Py_Void();
9709 return resultobj;
9710 fail:
9711 return NULL;
9712 }
9713
9714
9715 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9716 PyObject *resultobj = 0;
9717 wxRect2D *arg1 = (wxRect2D *) 0 ;
9718 wxDouble arg2 ;
9719 void *argp1 = 0 ;
9720 int res1 = 0 ;
9721 void *argp2 ;
9722 int res2 = 0 ;
9723 PyObject * obj0 = 0 ;
9724 PyObject * obj1 = 0 ;
9725 char * kwnames[] = {
9726 (char *) "self",(char *) "n", NULL
9727 };
9728
9729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9731 if (!SWIG_IsOK(res1)) {
9732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9733 }
9734 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9735 {
9736 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9737 if (!SWIG_IsOK(res2)) {
9738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9739 }
9740 if (!argp2) {
9741 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9742 } else {
9743 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9744 arg2 = *temp;
9745 if (SWIG_IsNewObj(res2)) delete temp;
9746 }
9747 }
9748 {
9749 (arg1)->MoveRightTo(arg2);
9750 if (PyErr_Occurred()) SWIG_fail;
9751 }
9752 resultobj = SWIG_Py_Void();
9753 return resultobj;
9754 fail:
9755 return NULL;
9756 }
9757
9758
9759 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9760 PyObject *resultobj = 0;
9761 wxRect2D *arg1 = (wxRect2D *) 0 ;
9762 wxPoint2D result;
9763 void *argp1 = 0 ;
9764 int res1 = 0 ;
9765 PyObject *swig_obj[1] ;
9766
9767 if (!args) SWIG_fail;
9768 swig_obj[0] = args;
9769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9770 if (!SWIG_IsOK(res1)) {
9771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9772 }
9773 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9774 {
9775 result = ((wxRect2D const *)arg1)->GetLeftTop();
9776 if (PyErr_Occurred()) SWIG_fail;
9777 }
9778 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9779 return resultobj;
9780 fail:
9781 return NULL;
9782 }
9783
9784
9785 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9786 PyObject *resultobj = 0;
9787 wxRect2D *arg1 = (wxRect2D *) 0 ;
9788 wxPoint2D *arg2 = 0 ;
9789 void *argp1 = 0 ;
9790 int res1 = 0 ;
9791 wxPoint2D temp2 ;
9792 PyObject * obj0 = 0 ;
9793 PyObject * obj1 = 0 ;
9794 char * kwnames[] = {
9795 (char *) "self",(char *) "pt", NULL
9796 };
9797
9798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9800 if (!SWIG_IsOK(res1)) {
9801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9802 }
9803 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9804 {
9805 arg2 = &temp2;
9806 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9807 }
9808 {
9809 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9810 if (PyErr_Occurred()) SWIG_fail;
9811 }
9812 resultobj = SWIG_Py_Void();
9813 return resultobj;
9814 fail:
9815 return NULL;
9816 }
9817
9818
9819 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9820 PyObject *resultobj = 0;
9821 wxRect2D *arg1 = (wxRect2D *) 0 ;
9822 wxPoint2D *arg2 = 0 ;
9823 void *argp1 = 0 ;
9824 int res1 = 0 ;
9825 wxPoint2D temp2 ;
9826 PyObject * obj0 = 0 ;
9827 PyObject * obj1 = 0 ;
9828 char * kwnames[] = {
9829 (char *) "self",(char *) "pt", NULL
9830 };
9831
9832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9834 if (!SWIG_IsOK(res1)) {
9835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9836 }
9837 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9838 {
9839 arg2 = &temp2;
9840 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9841 }
9842 {
9843 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9844 if (PyErr_Occurred()) SWIG_fail;
9845 }
9846 resultobj = SWIG_Py_Void();
9847 return resultobj;
9848 fail:
9849 return NULL;
9850 }
9851
9852
9853 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9854 PyObject *resultobj = 0;
9855 wxRect2D *arg1 = (wxRect2D *) 0 ;
9856 wxPoint2D result;
9857 void *argp1 = 0 ;
9858 int res1 = 0 ;
9859 PyObject *swig_obj[1] ;
9860
9861 if (!args) SWIG_fail;
9862 swig_obj[0] = args;
9863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9864 if (!SWIG_IsOK(res1)) {
9865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9866 }
9867 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9868 {
9869 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9870 if (PyErr_Occurred()) SWIG_fail;
9871 }
9872 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9873 return resultobj;
9874 fail:
9875 return NULL;
9876 }
9877
9878
9879 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9880 PyObject *resultobj = 0;
9881 wxRect2D *arg1 = (wxRect2D *) 0 ;
9882 wxPoint2D *arg2 = 0 ;
9883 void *argp1 = 0 ;
9884 int res1 = 0 ;
9885 wxPoint2D temp2 ;
9886 PyObject * obj0 = 0 ;
9887 PyObject * obj1 = 0 ;
9888 char * kwnames[] = {
9889 (char *) "self",(char *) "pt", NULL
9890 };
9891
9892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9894 if (!SWIG_IsOK(res1)) {
9895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9896 }
9897 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9898 {
9899 arg2 = &temp2;
9900 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9901 }
9902 {
9903 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9904 if (PyErr_Occurred()) SWIG_fail;
9905 }
9906 resultobj = SWIG_Py_Void();
9907 return resultobj;
9908 fail:
9909 return NULL;
9910 }
9911
9912
9913 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9914 PyObject *resultobj = 0;
9915 wxRect2D *arg1 = (wxRect2D *) 0 ;
9916 wxPoint2D *arg2 = 0 ;
9917 void *argp1 = 0 ;
9918 int res1 = 0 ;
9919 wxPoint2D temp2 ;
9920 PyObject * obj0 = 0 ;
9921 PyObject * obj1 = 0 ;
9922 char * kwnames[] = {
9923 (char *) "self",(char *) "pt", NULL
9924 };
9925
9926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9928 if (!SWIG_IsOK(res1)) {
9929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9930 }
9931 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9932 {
9933 arg2 = &temp2;
9934 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9935 }
9936 {
9937 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
9938 if (PyErr_Occurred()) SWIG_fail;
9939 }
9940 resultobj = SWIG_Py_Void();
9941 return resultobj;
9942 fail:
9943 return NULL;
9944 }
9945
9946
9947 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9948 PyObject *resultobj = 0;
9949 wxRect2D *arg1 = (wxRect2D *) 0 ;
9950 wxPoint2D result;
9951 void *argp1 = 0 ;
9952 int res1 = 0 ;
9953 PyObject *swig_obj[1] ;
9954
9955 if (!args) SWIG_fail;
9956 swig_obj[0] = args;
9957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9958 if (!SWIG_IsOK(res1)) {
9959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9960 }
9961 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9962 {
9963 result = ((wxRect2D const *)arg1)->GetRightTop();
9964 if (PyErr_Occurred()) SWIG_fail;
9965 }
9966 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9967 return resultobj;
9968 fail:
9969 return NULL;
9970 }
9971
9972
9973 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9974 PyObject *resultobj = 0;
9975 wxRect2D *arg1 = (wxRect2D *) 0 ;
9976 wxPoint2D *arg2 = 0 ;
9977 void *argp1 = 0 ;
9978 int res1 = 0 ;
9979 wxPoint2D temp2 ;
9980 PyObject * obj0 = 0 ;
9981 PyObject * obj1 = 0 ;
9982 char * kwnames[] = {
9983 (char *) "self",(char *) "pt", NULL
9984 };
9985
9986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
9987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9988 if (!SWIG_IsOK(res1)) {
9989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9990 }
9991 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9992 {
9993 arg2 = &temp2;
9994 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9995 }
9996 {
9997 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
9998 if (PyErr_Occurred()) SWIG_fail;
9999 }
10000 resultobj = SWIG_Py_Void();
10001 return resultobj;
10002 fail:
10003 return NULL;
10004 }
10005
10006
10007 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10008 PyObject *resultobj = 0;
10009 wxRect2D *arg1 = (wxRect2D *) 0 ;
10010 wxPoint2D *arg2 = 0 ;
10011 void *argp1 = 0 ;
10012 int res1 = 0 ;
10013 wxPoint2D temp2 ;
10014 PyObject * obj0 = 0 ;
10015 PyObject * obj1 = 0 ;
10016 char * kwnames[] = {
10017 (char *) "self",(char *) "pt", NULL
10018 };
10019
10020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10022 if (!SWIG_IsOK(res1)) {
10023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10024 }
10025 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10026 {
10027 arg2 = &temp2;
10028 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10029 }
10030 {
10031 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10032 if (PyErr_Occurred()) SWIG_fail;
10033 }
10034 resultobj = SWIG_Py_Void();
10035 return resultobj;
10036 fail:
10037 return NULL;
10038 }
10039
10040
10041 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10042 PyObject *resultobj = 0;
10043 wxRect2D *arg1 = (wxRect2D *) 0 ;
10044 wxPoint2D result;
10045 void *argp1 = 0 ;
10046 int res1 = 0 ;
10047 PyObject *swig_obj[1] ;
10048
10049 if (!args) SWIG_fail;
10050 swig_obj[0] = args;
10051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10052 if (!SWIG_IsOK(res1)) {
10053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10054 }
10055 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10056 {
10057 result = ((wxRect2D const *)arg1)->GetRightBottom();
10058 if (PyErr_Occurred()) SWIG_fail;
10059 }
10060 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10061 return resultobj;
10062 fail:
10063 return NULL;
10064 }
10065
10066
10067 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10068 PyObject *resultobj = 0;
10069 wxRect2D *arg1 = (wxRect2D *) 0 ;
10070 wxPoint2D *arg2 = 0 ;
10071 void *argp1 = 0 ;
10072 int res1 = 0 ;
10073 wxPoint2D temp2 ;
10074 PyObject * obj0 = 0 ;
10075 PyObject * obj1 = 0 ;
10076 char * kwnames[] = {
10077 (char *) "self",(char *) "pt", NULL
10078 };
10079
10080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10082 if (!SWIG_IsOK(res1)) {
10083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10084 }
10085 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10086 {
10087 arg2 = &temp2;
10088 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10089 }
10090 {
10091 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10092 if (PyErr_Occurred()) SWIG_fail;
10093 }
10094 resultobj = SWIG_Py_Void();
10095 return resultobj;
10096 fail:
10097 return NULL;
10098 }
10099
10100
10101 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10102 PyObject *resultobj = 0;
10103 wxRect2D *arg1 = (wxRect2D *) 0 ;
10104 wxPoint2D *arg2 = 0 ;
10105 void *argp1 = 0 ;
10106 int res1 = 0 ;
10107 wxPoint2D temp2 ;
10108 PyObject * obj0 = 0 ;
10109 PyObject * obj1 = 0 ;
10110 char * kwnames[] = {
10111 (char *) "self",(char *) "pt", NULL
10112 };
10113
10114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10116 if (!SWIG_IsOK(res1)) {
10117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10118 }
10119 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10120 {
10121 arg2 = &temp2;
10122 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10123 }
10124 {
10125 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10126 if (PyErr_Occurred()) SWIG_fail;
10127 }
10128 resultobj = SWIG_Py_Void();
10129 return resultobj;
10130 fail:
10131 return NULL;
10132 }
10133
10134
10135 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10136 PyObject *resultobj = 0;
10137 wxRect2D *arg1 = (wxRect2D *) 0 ;
10138 wxPoint2D result;
10139 void *argp1 = 0 ;
10140 int res1 = 0 ;
10141 PyObject *swig_obj[1] ;
10142
10143 if (!args) SWIG_fail;
10144 swig_obj[0] = args;
10145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10146 if (!SWIG_IsOK(res1)) {
10147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10148 }
10149 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10150 {
10151 result = ((wxRect2D const *)arg1)->GetCentre();
10152 if (PyErr_Occurred()) SWIG_fail;
10153 }
10154 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10155 return resultobj;
10156 fail:
10157 return NULL;
10158 }
10159
10160
10161 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10162 PyObject *resultobj = 0;
10163 wxRect2D *arg1 = (wxRect2D *) 0 ;
10164 wxPoint2D *arg2 = 0 ;
10165 void *argp1 = 0 ;
10166 int res1 = 0 ;
10167 wxPoint2D temp2 ;
10168 PyObject * obj0 = 0 ;
10169 PyObject * obj1 = 0 ;
10170 char * kwnames[] = {
10171 (char *) "self",(char *) "pt", NULL
10172 };
10173
10174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10176 if (!SWIG_IsOK(res1)) {
10177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10178 }
10179 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10180 {
10181 arg2 = &temp2;
10182 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10183 }
10184 {
10185 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10186 if (PyErr_Occurred()) SWIG_fail;
10187 }
10188 resultobj = SWIG_Py_Void();
10189 return resultobj;
10190 fail:
10191 return NULL;
10192 }
10193
10194
10195 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10196 PyObject *resultobj = 0;
10197 wxRect2D *arg1 = (wxRect2D *) 0 ;
10198 wxPoint2D *arg2 = 0 ;
10199 void *argp1 = 0 ;
10200 int res1 = 0 ;
10201 wxPoint2D temp2 ;
10202 PyObject * obj0 = 0 ;
10203 PyObject * obj1 = 0 ;
10204 char * kwnames[] = {
10205 (char *) "self",(char *) "pt", NULL
10206 };
10207
10208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10210 if (!SWIG_IsOK(res1)) {
10211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10212 }
10213 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10214 {
10215 arg2 = &temp2;
10216 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10217 }
10218 {
10219 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10220 if (PyErr_Occurred()) SWIG_fail;
10221 }
10222 resultobj = SWIG_Py_Void();
10223 return resultobj;
10224 fail:
10225 return NULL;
10226 }
10227
10228
10229 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10230 PyObject *resultobj = 0;
10231 wxRect2D *arg1 = (wxRect2D *) 0 ;
10232 wxPoint2D *arg2 = 0 ;
10233 wxOutCode result;
10234 void *argp1 = 0 ;
10235 int res1 = 0 ;
10236 wxPoint2D temp2 ;
10237 PyObject * obj0 = 0 ;
10238 PyObject * obj1 = 0 ;
10239 char * kwnames[] = {
10240 (char *) "self",(char *) "pt", NULL
10241 };
10242
10243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10245 if (!SWIG_IsOK(res1)) {
10246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10247 }
10248 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10249 {
10250 arg2 = &temp2;
10251 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10252 }
10253 {
10254 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10255 if (PyErr_Occurred()) SWIG_fail;
10256 }
10257 resultobj = SWIG_From_int(static_cast< int >(result));
10258 return resultobj;
10259 fail:
10260 return NULL;
10261 }
10262
10263
10264 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10265 PyObject *resultobj = 0;
10266 wxRect2D *arg1 = (wxRect2D *) 0 ;
10267 wxPoint2D *arg2 = 0 ;
10268 bool result;
10269 void *argp1 = 0 ;
10270 int res1 = 0 ;
10271 wxPoint2D temp2 ;
10272 PyObject * obj0 = 0 ;
10273 PyObject * obj1 = 0 ;
10274 char * kwnames[] = {
10275 (char *) "self",(char *) "pt", NULL
10276 };
10277
10278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10280 if (!SWIG_IsOK(res1)) {
10281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10282 }
10283 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10284 {
10285 arg2 = &temp2;
10286 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10287 }
10288 {
10289 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10290 if (PyErr_Occurred()) SWIG_fail;
10291 }
10292 {
10293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10294 }
10295 return resultobj;
10296 fail:
10297 return NULL;
10298 }
10299
10300
10301 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10302 PyObject *resultobj = 0;
10303 wxRect2D *arg1 = (wxRect2D *) 0 ;
10304 wxRect2D *arg2 = 0 ;
10305 bool result;
10306 void *argp1 = 0 ;
10307 int res1 = 0 ;
10308 wxRect2D temp2 ;
10309 PyObject * obj0 = 0 ;
10310 PyObject * obj1 = 0 ;
10311 char * kwnames[] = {
10312 (char *) "self",(char *) "rect", NULL
10313 };
10314
10315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10317 if (!SWIG_IsOK(res1)) {
10318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10319 }
10320 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10321 {
10322 arg2 = &temp2;
10323 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10324 }
10325 {
10326 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10327 if (PyErr_Occurred()) SWIG_fail;
10328 }
10329 {
10330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10331 }
10332 return resultobj;
10333 fail:
10334 return NULL;
10335 }
10336
10337
10338 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10339 PyObject *resultobj = 0;
10340 wxRect2D *arg1 = (wxRect2D *) 0 ;
10341 bool result;
10342 void *argp1 = 0 ;
10343 int res1 = 0 ;
10344 PyObject *swig_obj[1] ;
10345
10346 if (!args) SWIG_fail;
10347 swig_obj[0] = args;
10348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10349 if (!SWIG_IsOK(res1)) {
10350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10351 }
10352 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10353 {
10354 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10355 if (PyErr_Occurred()) SWIG_fail;
10356 }
10357 {
10358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10359 }
10360 return resultobj;
10361 fail:
10362 return NULL;
10363 }
10364
10365
10366 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10367 PyObject *resultobj = 0;
10368 wxRect2D *arg1 = (wxRect2D *) 0 ;
10369 wxRect2D *arg2 = 0 ;
10370 bool result;
10371 void *argp1 = 0 ;
10372 int res1 = 0 ;
10373 wxRect2D temp2 ;
10374 PyObject * obj0 = 0 ;
10375 PyObject * obj1 = 0 ;
10376 char * kwnames[] = {
10377 (char *) "self",(char *) "rect", NULL
10378 };
10379
10380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10382 if (!SWIG_IsOK(res1)) {
10383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10384 }
10385 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10386 {
10387 arg2 = &temp2;
10388 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10389 }
10390 {
10391 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10392 if (PyErr_Occurred()) SWIG_fail;
10393 }
10394 {
10395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10396 }
10397 return resultobj;
10398 fail:
10399 return NULL;
10400 }
10401
10402
10403 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10404 PyObject *resultobj = 0;
10405 wxRect2D *arg1 = (wxRect2D *) 0 ;
10406 wxDouble arg2 ;
10407 wxDouble arg3 ;
10408 void *argp1 = 0 ;
10409 int res1 = 0 ;
10410 void *argp2 ;
10411 int res2 = 0 ;
10412 void *argp3 ;
10413 int res3 = 0 ;
10414
10415 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10417 if (!SWIG_IsOK(res1)) {
10418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10419 }
10420 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10421 {
10422 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10423 if (!SWIG_IsOK(res2)) {
10424 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10425 }
10426 if (!argp2) {
10427 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10428 } else {
10429 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10430 arg2 = *temp;
10431 if (SWIG_IsNewObj(res2)) delete temp;
10432 }
10433 }
10434 {
10435 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10436 if (!SWIG_IsOK(res3)) {
10437 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10438 }
10439 if (!argp3) {
10440 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10441 } else {
10442 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10443 arg3 = *temp;
10444 if (SWIG_IsNewObj(res3)) delete temp;
10445 }
10446 }
10447 {
10448 (arg1)->Inset(arg2,arg3);
10449 if (PyErr_Occurred()) SWIG_fail;
10450 }
10451 resultobj = SWIG_Py_Void();
10452 return resultobj;
10453 fail:
10454 return NULL;
10455 }
10456
10457
10458 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10459 PyObject *resultobj = 0;
10460 wxRect2D *arg1 = (wxRect2D *) 0 ;
10461 wxDouble arg2 ;
10462 wxDouble arg3 ;
10463 wxDouble arg4 ;
10464 wxDouble arg5 ;
10465 void *argp1 = 0 ;
10466 int res1 = 0 ;
10467 void *argp2 ;
10468 int res2 = 0 ;
10469 void *argp3 ;
10470 int res3 = 0 ;
10471 void *argp4 ;
10472 int res4 = 0 ;
10473 void *argp5 ;
10474 int res5 = 0 ;
10475
10476 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10478 if (!SWIG_IsOK(res1)) {
10479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10480 }
10481 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10482 {
10483 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10484 if (!SWIG_IsOK(res2)) {
10485 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10486 }
10487 if (!argp2) {
10488 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10489 } else {
10490 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10491 arg2 = *temp;
10492 if (SWIG_IsNewObj(res2)) delete temp;
10493 }
10494 }
10495 {
10496 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10497 if (!SWIG_IsOK(res3)) {
10498 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10499 }
10500 if (!argp3) {
10501 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10502 } else {
10503 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10504 arg3 = *temp;
10505 if (SWIG_IsNewObj(res3)) delete temp;
10506 }
10507 }
10508 {
10509 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10510 if (!SWIG_IsOK(res4)) {
10511 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10512 }
10513 if (!argp4) {
10514 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10515 } else {
10516 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10517 arg4 = *temp;
10518 if (SWIG_IsNewObj(res4)) delete temp;
10519 }
10520 }
10521 {
10522 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10523 if (!SWIG_IsOK(res5)) {
10524 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10525 }
10526 if (!argp5) {
10527 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10528 } else {
10529 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10530 arg5 = *temp;
10531 if (SWIG_IsNewObj(res5)) delete temp;
10532 }
10533 }
10534 {
10535 (arg1)->Inset(arg2,arg3,arg4,arg5);
10536 if (PyErr_Occurred()) SWIG_fail;
10537 }
10538 resultobj = SWIG_Py_Void();
10539 return resultobj;
10540 fail:
10541 return NULL;
10542 }
10543
10544
10545 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10546 int argc;
10547 PyObject *argv[6];
10548
10549 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10550 --argc;
10551 if (argc == 3) {
10552 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10553 }
10554 if (argc == 5) {
10555 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10556 }
10557
10558 fail:
10559 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10560 return NULL;
10561 }
10562
10563
10564 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10565 PyObject *resultobj = 0;
10566 wxRect2D *arg1 = (wxRect2D *) 0 ;
10567 wxPoint2D *arg2 = 0 ;
10568 void *argp1 = 0 ;
10569 int res1 = 0 ;
10570 wxPoint2D temp2 ;
10571 PyObject * obj0 = 0 ;
10572 PyObject * obj1 = 0 ;
10573 char * kwnames[] = {
10574 (char *) "self",(char *) "pt", NULL
10575 };
10576
10577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10579 if (!SWIG_IsOK(res1)) {
10580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10581 }
10582 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10583 {
10584 arg2 = &temp2;
10585 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10586 }
10587 {
10588 (arg1)->Offset((wxPoint2D const &)*arg2);
10589 if (PyErr_Occurred()) SWIG_fail;
10590 }
10591 resultobj = SWIG_Py_Void();
10592 return resultobj;
10593 fail:
10594 return NULL;
10595 }
10596
10597
10598 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10599 PyObject *resultobj = 0;
10600 wxRect2D *arg1 = (wxRect2D *) 0 ;
10601 wxRect2D *arg2 = 0 ;
10602 void *argp1 = 0 ;
10603 int res1 = 0 ;
10604 wxRect2D temp2 ;
10605 PyObject * obj0 = 0 ;
10606 PyObject * obj1 = 0 ;
10607 char * kwnames[] = {
10608 (char *) "self",(char *) "rect", NULL
10609 };
10610
10611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10613 if (!SWIG_IsOK(res1)) {
10614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10615 }
10616 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10617 {
10618 arg2 = &temp2;
10619 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10620 }
10621 {
10622 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10623 if (PyErr_Occurred()) SWIG_fail;
10624 }
10625 resultobj = SWIG_Py_Void();
10626 return resultobj;
10627 fail:
10628 return NULL;
10629 }
10630
10631
10632 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10633 PyObject *resultobj = 0;
10634 wxRect2D *arg1 = (wxRect2D *) 0 ;
10635 int arg2 ;
10636 int arg3 ;
10637 wxPoint2D result;
10638 void *argp1 = 0 ;
10639 int res1 = 0 ;
10640 int val2 ;
10641 int ecode2 = 0 ;
10642 int val3 ;
10643 int ecode3 = 0 ;
10644 PyObject * obj0 = 0 ;
10645 PyObject * obj1 = 0 ;
10646 PyObject * obj2 = 0 ;
10647 char * kwnames[] = {
10648 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10649 };
10650
10651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10653 if (!SWIG_IsOK(res1)) {
10654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10655 }
10656 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10657 ecode2 = SWIG_AsVal_int(obj1, &val2);
10658 if (!SWIG_IsOK(ecode2)) {
10659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10660 }
10661 arg2 = static_cast< int >(val2);
10662 ecode3 = SWIG_AsVal_int(obj2, &val3);
10663 if (!SWIG_IsOK(ecode3)) {
10664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10665 }
10666 arg3 = static_cast< int >(val3);
10667 {
10668 result = (arg1)->Interpolate(arg2,arg3);
10669 if (PyErr_Occurred()) SWIG_fail;
10670 }
10671 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10672 return resultobj;
10673 fail:
10674 return NULL;
10675 }
10676
10677
10678 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10679 PyObject *resultobj = 0;
10680 wxRect2D *arg1 = (wxRect2D *) 0 ;
10681 wxRect2D *arg2 = 0 ;
10682 void *argp1 = 0 ;
10683 int res1 = 0 ;
10684 wxRect2D temp2 ;
10685 PyObject * obj0 = 0 ;
10686 PyObject * obj1 = 0 ;
10687 char * kwnames[] = {
10688 (char *) "self",(char *) "otherRect", NULL
10689 };
10690
10691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10693 if (!SWIG_IsOK(res1)) {
10694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10695 }
10696 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10697 {
10698 arg2 = &temp2;
10699 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10700 }
10701 {
10702 (arg1)->Intersect((wxRect2D const &)*arg2);
10703 if (PyErr_Occurred()) SWIG_fail;
10704 }
10705 resultobj = SWIG_Py_Void();
10706 return resultobj;
10707 fail:
10708 return NULL;
10709 }
10710
10711
10712 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10713 PyObject *resultobj = 0;
10714 wxRect2D *arg1 = (wxRect2D *) 0 ;
10715 wxRect2D *arg2 = 0 ;
10716 wxRect2D result;
10717 void *argp1 = 0 ;
10718 int res1 = 0 ;
10719 wxRect2D temp2 ;
10720 PyObject * obj0 = 0 ;
10721 PyObject * obj1 = 0 ;
10722 char * kwnames[] = {
10723 (char *) "self",(char *) "otherRect", NULL
10724 };
10725
10726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10728 if (!SWIG_IsOK(res1)) {
10729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10730 }
10731 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10732 {
10733 arg2 = &temp2;
10734 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10735 }
10736 {
10737 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10738 if (PyErr_Occurred()) SWIG_fail;
10739 }
10740 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10741 return resultobj;
10742 fail:
10743 return NULL;
10744 }
10745
10746
10747 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10748 PyObject *resultobj = 0;
10749 wxRect2D *arg1 = (wxRect2D *) 0 ;
10750 wxRect2D *arg2 = 0 ;
10751 bool result;
10752 void *argp1 = 0 ;
10753 int res1 = 0 ;
10754 wxRect2D temp2 ;
10755 PyObject * obj0 = 0 ;
10756 PyObject * obj1 = 0 ;
10757 char * kwnames[] = {
10758 (char *) "self",(char *) "rect", NULL
10759 };
10760
10761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10763 if (!SWIG_IsOK(res1)) {
10764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10765 }
10766 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10767 {
10768 arg2 = &temp2;
10769 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10770 }
10771 {
10772 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10773 if (PyErr_Occurred()) SWIG_fail;
10774 }
10775 {
10776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10777 }
10778 return resultobj;
10779 fail:
10780 return NULL;
10781 }
10782
10783
10784 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10785 PyObject *resultobj = 0;
10786 wxRect2D *arg1 = (wxRect2D *) 0 ;
10787 wxRect2D *arg2 = 0 ;
10788 void *argp1 = 0 ;
10789 int res1 = 0 ;
10790 wxRect2D temp2 ;
10791 PyObject * obj0 = 0 ;
10792 PyObject * obj1 = 0 ;
10793 char * kwnames[] = {
10794 (char *) "self",(char *) "otherRect", NULL
10795 };
10796
10797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10799 if (!SWIG_IsOK(res1)) {
10800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10801 }
10802 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10803 {
10804 arg2 = &temp2;
10805 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10806 }
10807 {
10808 (arg1)->Union((wxRect2D const &)*arg2);
10809 if (PyErr_Occurred()) SWIG_fail;
10810 }
10811 resultobj = SWIG_Py_Void();
10812 return resultobj;
10813 fail:
10814 return NULL;
10815 }
10816
10817
10818 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10819 PyObject *resultobj = 0;
10820 wxRect2D *arg1 = (wxRect2D *) 0 ;
10821 wxRect2D *arg2 = 0 ;
10822 wxRect2D result;
10823 void *argp1 = 0 ;
10824 int res1 = 0 ;
10825 wxRect2D temp2 ;
10826 PyObject * obj0 = 0 ;
10827 PyObject * obj1 = 0 ;
10828 char * kwnames[] = {
10829 (char *) "self",(char *) "otherRect", NULL
10830 };
10831
10832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10834 if (!SWIG_IsOK(res1)) {
10835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10836 }
10837 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10838 {
10839 arg2 = &temp2;
10840 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10841 }
10842 {
10843 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10844 if (PyErr_Occurred()) SWIG_fail;
10845 }
10846 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10847 return resultobj;
10848 fail:
10849 return NULL;
10850 }
10851
10852
10853 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10854 PyObject *resultobj = 0;
10855 wxRect2D *arg1 = (wxRect2D *) 0 ;
10856 wxDouble arg2 ;
10857 void *argp1 = 0 ;
10858 int res1 = 0 ;
10859 void *argp2 ;
10860 int res2 = 0 ;
10861
10862 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10864 if (!SWIG_IsOK(res1)) {
10865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10866 }
10867 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10868 {
10869 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10870 if (!SWIG_IsOK(res2)) {
10871 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10872 }
10873 if (!argp2) {
10874 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10875 } else {
10876 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10877 arg2 = *temp;
10878 if (SWIG_IsNewObj(res2)) delete temp;
10879 }
10880 }
10881 {
10882 (arg1)->Scale(arg2);
10883 if (PyErr_Occurred()) SWIG_fail;
10884 }
10885 resultobj = SWIG_Py_Void();
10886 return resultobj;
10887 fail:
10888 return NULL;
10889 }
10890
10891
10892 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10893 PyObject *resultobj = 0;
10894 wxRect2D *arg1 = (wxRect2D *) 0 ;
10895 int arg2 ;
10896 int arg3 ;
10897 void *argp1 = 0 ;
10898 int res1 = 0 ;
10899 int val2 ;
10900 int ecode2 = 0 ;
10901 int val3 ;
10902 int ecode3 = 0 ;
10903
10904 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10906 if (!SWIG_IsOK(res1)) {
10907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10908 }
10909 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10910 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10911 if (!SWIG_IsOK(ecode2)) {
10912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10913 }
10914 arg2 = static_cast< int >(val2);
10915 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10916 if (!SWIG_IsOK(ecode3)) {
10917 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10918 }
10919 arg3 = static_cast< int >(val3);
10920 {
10921 (arg1)->Scale(arg2,arg3);
10922 if (PyErr_Occurred()) SWIG_fail;
10923 }
10924 resultobj = SWIG_Py_Void();
10925 return resultobj;
10926 fail:
10927 return NULL;
10928 }
10929
10930
10931 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
10932 int argc;
10933 PyObject *argv[4];
10934
10935 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
10936 --argc;
10937 if (argc == 2) {
10938 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
10939 }
10940 if (argc == 3) {
10941 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
10942 }
10943
10944 fail:
10945 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
10946 return NULL;
10947 }
10948
10949
10950 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10951 PyObject *resultobj = 0;
10952 wxRect2D *arg1 = (wxRect2D *) 0 ;
10953 PyObject *arg2 = (PyObject *) 0 ;
10954 bool result;
10955 void *argp1 = 0 ;
10956 int res1 = 0 ;
10957 PyObject * obj0 = 0 ;
10958 PyObject * obj1 = 0 ;
10959 char * kwnames[] = {
10960 (char *) "self",(char *) "other", NULL
10961 };
10962
10963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10965 if (!SWIG_IsOK(res1)) {
10966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10967 }
10968 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10969 arg2 = obj1;
10970 {
10971 result = (bool)wxRect2D___eq__(arg1,arg2);
10972 if (PyErr_Occurred()) SWIG_fail;
10973 }
10974 {
10975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10976 }
10977 return resultobj;
10978 fail:
10979 return NULL;
10980 }
10981
10982
10983 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10984 PyObject *resultobj = 0;
10985 wxRect2D *arg1 = (wxRect2D *) 0 ;
10986 PyObject *arg2 = (PyObject *) 0 ;
10987 bool result;
10988 void *argp1 = 0 ;
10989 int res1 = 0 ;
10990 PyObject * obj0 = 0 ;
10991 PyObject * obj1 = 0 ;
10992 char * kwnames[] = {
10993 (char *) "self",(char *) "other", NULL
10994 };
10995
10996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10998 if (!SWIG_IsOK(res1)) {
10999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11000 }
11001 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11002 arg2 = obj1;
11003 {
11004 result = (bool)wxRect2D___ne__(arg1,arg2);
11005 if (PyErr_Occurred()) SWIG_fail;
11006 }
11007 {
11008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11009 }
11010 return resultobj;
11011 fail:
11012 return NULL;
11013 }
11014
11015
11016 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11017 PyObject *resultobj = 0;
11018 wxRect2D *arg1 = (wxRect2D *) 0 ;
11019 wxDouble arg2 ;
11020 void *argp1 = 0 ;
11021 int res1 = 0 ;
11022 void *argp2 ;
11023 int res2 = 0 ;
11024 PyObject *swig_obj[2] ;
11025
11026 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11028 if (!SWIG_IsOK(res1)) {
11029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11030 }
11031 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11032 {
11033 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11034 if (!SWIG_IsOK(res2)) {
11035 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11036 }
11037 if (!argp2) {
11038 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11039 } else {
11040 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11041 arg2 = *temp;
11042 if (SWIG_IsNewObj(res2)) delete temp;
11043 }
11044 }
11045 if (arg1) (arg1)->m_x = arg2;
11046
11047 resultobj = SWIG_Py_Void();
11048 return resultobj;
11049 fail:
11050 return NULL;
11051 }
11052
11053
11054 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11055 PyObject *resultobj = 0;
11056 wxRect2D *arg1 = (wxRect2D *) 0 ;
11057 wxDouble result;
11058 void *argp1 = 0 ;
11059 int res1 = 0 ;
11060 PyObject *swig_obj[1] ;
11061
11062 if (!args) SWIG_fail;
11063 swig_obj[0] = args;
11064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11065 if (!SWIG_IsOK(res1)) {
11066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11067 }
11068 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11069 result = ((arg1)->m_x);
11070 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11071 return resultobj;
11072 fail:
11073 return NULL;
11074 }
11075
11076
11077 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11078 PyObject *resultobj = 0;
11079 wxRect2D *arg1 = (wxRect2D *) 0 ;
11080 wxDouble arg2 ;
11081 void *argp1 = 0 ;
11082 int res1 = 0 ;
11083 void *argp2 ;
11084 int res2 = 0 ;
11085 PyObject *swig_obj[2] ;
11086
11087 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11089 if (!SWIG_IsOK(res1)) {
11090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11091 }
11092 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11093 {
11094 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11095 if (!SWIG_IsOK(res2)) {
11096 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11097 }
11098 if (!argp2) {
11099 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11100 } else {
11101 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11102 arg2 = *temp;
11103 if (SWIG_IsNewObj(res2)) delete temp;
11104 }
11105 }
11106 if (arg1) (arg1)->m_y = arg2;
11107
11108 resultobj = SWIG_Py_Void();
11109 return resultobj;
11110 fail:
11111 return NULL;
11112 }
11113
11114
11115 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11116 PyObject *resultobj = 0;
11117 wxRect2D *arg1 = (wxRect2D *) 0 ;
11118 wxDouble result;
11119 void *argp1 = 0 ;
11120 int res1 = 0 ;
11121 PyObject *swig_obj[1] ;
11122
11123 if (!args) SWIG_fail;
11124 swig_obj[0] = args;
11125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11126 if (!SWIG_IsOK(res1)) {
11127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11128 }
11129 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11130 result = ((arg1)->m_y);
11131 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11132 return resultobj;
11133 fail:
11134 return NULL;
11135 }
11136
11137
11138 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11139 PyObject *resultobj = 0;
11140 wxRect2D *arg1 = (wxRect2D *) 0 ;
11141 wxDouble arg2 ;
11142 void *argp1 = 0 ;
11143 int res1 = 0 ;
11144 void *argp2 ;
11145 int res2 = 0 ;
11146 PyObject *swig_obj[2] ;
11147
11148 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11150 if (!SWIG_IsOK(res1)) {
11151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11152 }
11153 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11154 {
11155 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11156 if (!SWIG_IsOK(res2)) {
11157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11158 }
11159 if (!argp2) {
11160 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11161 } else {
11162 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11163 arg2 = *temp;
11164 if (SWIG_IsNewObj(res2)) delete temp;
11165 }
11166 }
11167 if (arg1) (arg1)->m_width = arg2;
11168
11169 resultobj = SWIG_Py_Void();
11170 return resultobj;
11171 fail:
11172 return NULL;
11173 }
11174
11175
11176 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11177 PyObject *resultobj = 0;
11178 wxRect2D *arg1 = (wxRect2D *) 0 ;
11179 wxDouble result;
11180 void *argp1 = 0 ;
11181 int res1 = 0 ;
11182 PyObject *swig_obj[1] ;
11183
11184 if (!args) SWIG_fail;
11185 swig_obj[0] = args;
11186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11187 if (!SWIG_IsOK(res1)) {
11188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11189 }
11190 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11191 result = ((arg1)->m_width);
11192 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11193 return resultobj;
11194 fail:
11195 return NULL;
11196 }
11197
11198
11199 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11200 PyObject *resultobj = 0;
11201 wxRect2D *arg1 = (wxRect2D *) 0 ;
11202 wxDouble arg2 ;
11203 void *argp1 = 0 ;
11204 int res1 = 0 ;
11205 void *argp2 ;
11206 int res2 = 0 ;
11207 PyObject *swig_obj[2] ;
11208
11209 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11211 if (!SWIG_IsOK(res1)) {
11212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11213 }
11214 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11215 {
11216 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11217 if (!SWIG_IsOK(res2)) {
11218 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11219 }
11220 if (!argp2) {
11221 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11222 } else {
11223 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11224 arg2 = *temp;
11225 if (SWIG_IsNewObj(res2)) delete temp;
11226 }
11227 }
11228 if (arg1) (arg1)->m_height = arg2;
11229
11230 resultobj = SWIG_Py_Void();
11231 return resultobj;
11232 fail:
11233 return NULL;
11234 }
11235
11236
11237 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11238 PyObject *resultobj = 0;
11239 wxRect2D *arg1 = (wxRect2D *) 0 ;
11240 wxDouble result;
11241 void *argp1 = 0 ;
11242 int res1 = 0 ;
11243 PyObject *swig_obj[1] ;
11244
11245 if (!args) SWIG_fail;
11246 swig_obj[0] = args;
11247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11248 if (!SWIG_IsOK(res1)) {
11249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11250 }
11251 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11252 result = ((arg1)->m_height);
11253 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11254 return resultobj;
11255 fail:
11256 return NULL;
11257 }
11258
11259
11260 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11261 PyObject *resultobj = 0;
11262 wxRect2D *arg1 = (wxRect2D *) 0 ;
11263 wxDouble arg2 = (wxDouble) 0 ;
11264 wxDouble arg3 = (wxDouble) 0 ;
11265 wxDouble arg4 = (wxDouble) 0 ;
11266 wxDouble arg5 = (wxDouble) 0 ;
11267 void *argp1 = 0 ;
11268 int res1 = 0 ;
11269 void *argp2 ;
11270 int res2 = 0 ;
11271 void *argp3 ;
11272 int res3 = 0 ;
11273 void *argp4 ;
11274 int res4 = 0 ;
11275 void *argp5 ;
11276 int res5 = 0 ;
11277 PyObject * obj0 = 0 ;
11278 PyObject * obj1 = 0 ;
11279 PyObject * obj2 = 0 ;
11280 PyObject * obj3 = 0 ;
11281 PyObject * obj4 = 0 ;
11282 char * kwnames[] = {
11283 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11284 };
11285
11286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11288 if (!SWIG_IsOK(res1)) {
11289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11290 }
11291 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11292 if (obj1) {
11293 {
11294 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11295 if (!SWIG_IsOK(res2)) {
11296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11297 }
11298 if (!argp2) {
11299 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11300 } else {
11301 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11302 arg2 = *temp;
11303 if (SWIG_IsNewObj(res2)) delete temp;
11304 }
11305 }
11306 }
11307 if (obj2) {
11308 {
11309 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11310 if (!SWIG_IsOK(res3)) {
11311 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11312 }
11313 if (!argp3) {
11314 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11315 } else {
11316 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11317 arg3 = *temp;
11318 if (SWIG_IsNewObj(res3)) delete temp;
11319 }
11320 }
11321 }
11322 if (obj3) {
11323 {
11324 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11325 if (!SWIG_IsOK(res4)) {
11326 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11327 }
11328 if (!argp4) {
11329 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11330 } else {
11331 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11332 arg4 = *temp;
11333 if (SWIG_IsNewObj(res4)) delete temp;
11334 }
11335 }
11336 }
11337 if (obj4) {
11338 {
11339 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11340 if (!SWIG_IsOK(res5)) {
11341 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11342 }
11343 if (!argp5) {
11344 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11345 } else {
11346 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11347 arg5 = *temp;
11348 if (SWIG_IsNewObj(res5)) delete temp;
11349 }
11350 }
11351 }
11352 {
11353 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11354 if (PyErr_Occurred()) SWIG_fail;
11355 }
11356 resultobj = SWIG_Py_Void();
11357 return resultobj;
11358 fail:
11359 return NULL;
11360 }
11361
11362
11363 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11364 PyObject *resultobj = 0;
11365 wxRect2D *arg1 = (wxRect2D *) 0 ;
11366 PyObject *result = 0 ;
11367 void *argp1 = 0 ;
11368 int res1 = 0 ;
11369 PyObject *swig_obj[1] ;
11370
11371 if (!args) SWIG_fail;
11372 swig_obj[0] = args;
11373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11374 if (!SWIG_IsOK(res1)) {
11375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11376 }
11377 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11378 {
11379 result = (PyObject *)wxRect2D_Get(arg1);
11380 if (PyErr_Occurred()) SWIG_fail;
11381 }
11382 resultobj = result;
11383 return resultobj;
11384 fail:
11385 return NULL;
11386 }
11387
11388
11389 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11390 PyObject *obj;
11391 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11392 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11393 return SWIG_Py_Void();
11394 }
11395
11396 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11397 return SWIG_Python_InitShadowInstance(args);
11398 }
11399
11400 SWIGINTERN int DefaultPosition_set(PyObject *) {
11401 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11402 return 1;
11403 }
11404
11405
11406 SWIGINTERN PyObject *DefaultPosition_get(void) {
11407 PyObject *pyobj = 0;
11408
11409 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11410 return pyobj;
11411 }
11412
11413
11414 SWIGINTERN int DefaultSize_set(PyObject *) {
11415 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11416 return 1;
11417 }
11418
11419
11420 SWIGINTERN PyObject *DefaultSize_get(void) {
11421 PyObject *pyobj = 0;
11422
11423 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11424 return pyobj;
11425 }
11426
11427
11428 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11429 PyObject *resultobj = 0;
11430 PyObject *arg1 = (PyObject *) 0 ;
11431 wxPyInputStream *result = 0 ;
11432 PyObject * obj0 = 0 ;
11433 char * kwnames[] = {
11434 (char *) "p", NULL
11435 };
11436
11437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11438 arg1 = obj0;
11439 {
11440 PyThreadState* __tstate = wxPyBeginAllowThreads();
11441 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11442 wxPyEndAllowThreads(__tstate);
11443 if (PyErr_Occurred()) SWIG_fail;
11444 }
11445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11446 return resultobj;
11447 fail:
11448 return NULL;
11449 }
11450
11451
11452 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11453 PyObject *resultobj = 0;
11454 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11455 void *argp1 = 0 ;
11456 int res1 = 0 ;
11457 PyObject *swig_obj[1] ;
11458
11459 if (!args) SWIG_fail;
11460 swig_obj[0] = args;
11461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
11462 if (!SWIG_IsOK(res1)) {
11463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11464 }
11465 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11466 {
11467 PyThreadState* __tstate = wxPyBeginAllowThreads();
11468 delete arg1;
11469
11470 wxPyEndAllowThreads(__tstate);
11471 if (PyErr_Occurred()) SWIG_fail;
11472 }
11473 resultobj = SWIG_Py_Void();
11474 return resultobj;
11475 fail:
11476 return NULL;
11477 }
11478
11479
11480 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11481 PyObject *resultobj = 0;
11482 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11483 void *argp1 = 0 ;
11484 int res1 = 0 ;
11485 PyObject *swig_obj[1] ;
11486
11487 if (!args) SWIG_fail;
11488 swig_obj[0] = args;
11489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11490 if (!SWIG_IsOK(res1)) {
11491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11492 }
11493 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11494 {
11495 PyThreadState* __tstate = wxPyBeginAllowThreads();
11496 (arg1)->close();
11497 wxPyEndAllowThreads(__tstate);
11498 if (PyErr_Occurred()) SWIG_fail;
11499 }
11500 resultobj = SWIG_Py_Void();
11501 return resultobj;
11502 fail:
11503 return NULL;
11504 }
11505
11506
11507 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11508 PyObject *resultobj = 0;
11509 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11510 void *argp1 = 0 ;
11511 int res1 = 0 ;
11512 PyObject *swig_obj[1] ;
11513
11514 if (!args) SWIG_fail;
11515 swig_obj[0] = args;
11516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11517 if (!SWIG_IsOK(res1)) {
11518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11519 }
11520 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11521 {
11522 PyThreadState* __tstate = wxPyBeginAllowThreads();
11523 (arg1)->flush();
11524 wxPyEndAllowThreads(__tstate);
11525 if (PyErr_Occurred()) SWIG_fail;
11526 }
11527 resultobj = SWIG_Py_Void();
11528 return resultobj;
11529 fail:
11530 return NULL;
11531 }
11532
11533
11534 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11535 PyObject *resultobj = 0;
11536 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11537 bool result;
11538 void *argp1 = 0 ;
11539 int res1 = 0 ;
11540 PyObject *swig_obj[1] ;
11541
11542 if (!args) SWIG_fail;
11543 swig_obj[0] = args;
11544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11545 if (!SWIG_IsOK(res1)) {
11546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11547 }
11548 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11549 {
11550 PyThreadState* __tstate = wxPyBeginAllowThreads();
11551 result = (bool)(arg1)->eof();
11552 wxPyEndAllowThreads(__tstate);
11553 if (PyErr_Occurred()) SWIG_fail;
11554 }
11555 {
11556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11557 }
11558 return resultobj;
11559 fail:
11560 return NULL;
11561 }
11562
11563
11564 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11565 PyObject *resultobj = 0;
11566 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11567 int arg2 = (int) -1 ;
11568 PyObject *result = 0 ;
11569 void *argp1 = 0 ;
11570 int res1 = 0 ;
11571 int val2 ;
11572 int ecode2 = 0 ;
11573 PyObject * obj0 = 0 ;
11574 PyObject * obj1 = 0 ;
11575 char * kwnames[] = {
11576 (char *) "self",(char *) "size", NULL
11577 };
11578
11579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11581 if (!SWIG_IsOK(res1)) {
11582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11583 }
11584 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11585 if (obj1) {
11586 ecode2 = SWIG_AsVal_int(obj1, &val2);
11587 if (!SWIG_IsOK(ecode2)) {
11588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11589 }
11590 arg2 = static_cast< int >(val2);
11591 }
11592 {
11593 PyThreadState* __tstate = wxPyBeginAllowThreads();
11594 result = (PyObject *)(arg1)->read(arg2);
11595 wxPyEndAllowThreads(__tstate);
11596 if (PyErr_Occurred()) SWIG_fail;
11597 }
11598 resultobj = result;
11599 return resultobj;
11600 fail:
11601 return NULL;
11602 }
11603
11604
11605 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11606 PyObject *resultobj = 0;
11607 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11608 int arg2 = (int) -1 ;
11609 PyObject *result = 0 ;
11610 void *argp1 = 0 ;
11611 int res1 = 0 ;
11612 int val2 ;
11613 int ecode2 = 0 ;
11614 PyObject * obj0 = 0 ;
11615 PyObject * obj1 = 0 ;
11616 char * kwnames[] = {
11617 (char *) "self",(char *) "size", NULL
11618 };
11619
11620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11622 if (!SWIG_IsOK(res1)) {
11623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11624 }
11625 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11626 if (obj1) {
11627 ecode2 = SWIG_AsVal_int(obj1, &val2);
11628 if (!SWIG_IsOK(ecode2)) {
11629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11630 }
11631 arg2 = static_cast< int >(val2);
11632 }
11633 {
11634 PyThreadState* __tstate = wxPyBeginAllowThreads();
11635 result = (PyObject *)(arg1)->readline(arg2);
11636 wxPyEndAllowThreads(__tstate);
11637 if (PyErr_Occurred()) SWIG_fail;
11638 }
11639 resultobj = result;
11640 return resultobj;
11641 fail:
11642 return NULL;
11643 }
11644
11645
11646 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11647 PyObject *resultobj = 0;
11648 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11649 int arg2 = (int) -1 ;
11650 PyObject *result = 0 ;
11651 void *argp1 = 0 ;
11652 int res1 = 0 ;
11653 int val2 ;
11654 int ecode2 = 0 ;
11655 PyObject * obj0 = 0 ;
11656 PyObject * obj1 = 0 ;
11657 char * kwnames[] = {
11658 (char *) "self",(char *) "sizehint", NULL
11659 };
11660
11661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11663 if (!SWIG_IsOK(res1)) {
11664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11665 }
11666 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11667 if (obj1) {
11668 ecode2 = SWIG_AsVal_int(obj1, &val2);
11669 if (!SWIG_IsOK(ecode2)) {
11670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11671 }
11672 arg2 = static_cast< int >(val2);
11673 }
11674 {
11675 PyThreadState* __tstate = wxPyBeginAllowThreads();
11676 result = (PyObject *)(arg1)->readlines(arg2);
11677 wxPyEndAllowThreads(__tstate);
11678 if (PyErr_Occurred()) SWIG_fail;
11679 }
11680 resultobj = result;
11681 return resultobj;
11682 fail:
11683 return NULL;
11684 }
11685
11686
11687 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11688 PyObject *resultobj = 0;
11689 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11690 int arg2 ;
11691 int arg3 = (int) 0 ;
11692 void *argp1 = 0 ;
11693 int res1 = 0 ;
11694 int val2 ;
11695 int ecode2 = 0 ;
11696 int val3 ;
11697 int ecode3 = 0 ;
11698 PyObject * obj0 = 0 ;
11699 PyObject * obj1 = 0 ;
11700 PyObject * obj2 = 0 ;
11701 char * kwnames[] = {
11702 (char *) "self",(char *) "offset",(char *) "whence", NULL
11703 };
11704
11705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11707 if (!SWIG_IsOK(res1)) {
11708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11709 }
11710 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11711 ecode2 = SWIG_AsVal_int(obj1, &val2);
11712 if (!SWIG_IsOK(ecode2)) {
11713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11714 }
11715 arg2 = static_cast< int >(val2);
11716 if (obj2) {
11717 ecode3 = SWIG_AsVal_int(obj2, &val3);
11718 if (!SWIG_IsOK(ecode3)) {
11719 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11720 }
11721 arg3 = static_cast< int >(val3);
11722 }
11723 {
11724 PyThreadState* __tstate = wxPyBeginAllowThreads();
11725 (arg1)->seek(arg2,arg3);
11726 wxPyEndAllowThreads(__tstate);
11727 if (PyErr_Occurred()) SWIG_fail;
11728 }
11729 resultobj = SWIG_Py_Void();
11730 return resultobj;
11731 fail:
11732 return NULL;
11733 }
11734
11735
11736 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11737 PyObject *resultobj = 0;
11738 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11739 int result;
11740 void *argp1 = 0 ;
11741 int res1 = 0 ;
11742 PyObject *swig_obj[1] ;
11743
11744 if (!args) SWIG_fail;
11745 swig_obj[0] = args;
11746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11747 if (!SWIG_IsOK(res1)) {
11748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11749 }
11750 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11751 {
11752 PyThreadState* __tstate = wxPyBeginAllowThreads();
11753 result = (int)(arg1)->tell();
11754 wxPyEndAllowThreads(__tstate);
11755 if (PyErr_Occurred()) SWIG_fail;
11756 }
11757 resultobj = SWIG_From_int(static_cast< int >(result));
11758 return resultobj;
11759 fail:
11760 return NULL;
11761 }
11762
11763
11764 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11765 PyObject *resultobj = 0;
11766 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11767 char result;
11768 void *argp1 = 0 ;
11769 int res1 = 0 ;
11770 PyObject *swig_obj[1] ;
11771
11772 if (!args) SWIG_fail;
11773 swig_obj[0] = args;
11774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11775 if (!SWIG_IsOK(res1)) {
11776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11777 }
11778 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11779 {
11780 PyThreadState* __tstate = wxPyBeginAllowThreads();
11781 result = (char)(arg1)->Peek();
11782 wxPyEndAllowThreads(__tstate);
11783 if (PyErr_Occurred()) SWIG_fail;
11784 }
11785 resultobj = SWIG_From_char(static_cast< char >(result));
11786 return resultobj;
11787 fail:
11788 return NULL;
11789 }
11790
11791
11792 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11793 PyObject *resultobj = 0;
11794 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11795 char result;
11796 void *argp1 = 0 ;
11797 int res1 = 0 ;
11798 PyObject *swig_obj[1] ;
11799
11800 if (!args) SWIG_fail;
11801 swig_obj[0] = args;
11802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11803 if (!SWIG_IsOK(res1)) {
11804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11805 }
11806 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11807 {
11808 PyThreadState* __tstate = wxPyBeginAllowThreads();
11809 result = (char)(arg1)->GetC();
11810 wxPyEndAllowThreads(__tstate);
11811 if (PyErr_Occurred()) SWIG_fail;
11812 }
11813 resultobj = SWIG_From_char(static_cast< char >(result));
11814 return resultobj;
11815 fail:
11816 return NULL;
11817 }
11818
11819
11820 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11821 PyObject *resultobj = 0;
11822 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11823 size_t result;
11824 void *argp1 = 0 ;
11825 int res1 = 0 ;
11826 PyObject *swig_obj[1] ;
11827
11828 if (!args) SWIG_fail;
11829 swig_obj[0] = args;
11830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11831 if (!SWIG_IsOK(res1)) {
11832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11833 }
11834 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11835 {
11836 PyThreadState* __tstate = wxPyBeginAllowThreads();
11837 result = (size_t)(arg1)->LastRead();
11838 wxPyEndAllowThreads(__tstate);
11839 if (PyErr_Occurred()) SWIG_fail;
11840 }
11841 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11842 return resultobj;
11843 fail:
11844 return NULL;
11845 }
11846
11847
11848 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11849 PyObject *resultobj = 0;
11850 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11851 bool result;
11852 void *argp1 = 0 ;
11853 int res1 = 0 ;
11854 PyObject *swig_obj[1] ;
11855
11856 if (!args) SWIG_fail;
11857 swig_obj[0] = args;
11858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11859 if (!SWIG_IsOK(res1)) {
11860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11861 }
11862 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11863 {
11864 PyThreadState* __tstate = wxPyBeginAllowThreads();
11865 result = (bool)(arg1)->CanRead();
11866 wxPyEndAllowThreads(__tstate);
11867 if (PyErr_Occurred()) SWIG_fail;
11868 }
11869 {
11870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11871 }
11872 return resultobj;
11873 fail:
11874 return NULL;
11875 }
11876
11877
11878 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11879 PyObject *resultobj = 0;
11880 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11881 bool result;
11882 void *argp1 = 0 ;
11883 int res1 = 0 ;
11884 PyObject *swig_obj[1] ;
11885
11886 if (!args) SWIG_fail;
11887 swig_obj[0] = args;
11888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11889 if (!SWIG_IsOK(res1)) {
11890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11891 }
11892 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11893 {
11894 PyThreadState* __tstate = wxPyBeginAllowThreads();
11895 result = (bool)(arg1)->Eof();
11896 wxPyEndAllowThreads(__tstate);
11897 if (PyErr_Occurred()) SWIG_fail;
11898 }
11899 {
11900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11901 }
11902 return resultobj;
11903 fail:
11904 return NULL;
11905 }
11906
11907
11908 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11909 PyObject *resultobj = 0;
11910 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11911 char arg2 ;
11912 bool result;
11913 void *argp1 = 0 ;
11914 int res1 = 0 ;
11915 char val2 ;
11916 int ecode2 = 0 ;
11917 PyObject * obj0 = 0 ;
11918 PyObject * obj1 = 0 ;
11919 char * kwnames[] = {
11920 (char *) "self",(char *) "c", NULL
11921 };
11922
11923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11925 if (!SWIG_IsOK(res1)) {
11926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11927 }
11928 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11929 ecode2 = SWIG_AsVal_char(obj1, &val2);
11930 if (!SWIG_IsOK(ecode2)) {
11931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
11932 }
11933 arg2 = static_cast< char >(val2);
11934 {
11935 PyThreadState* __tstate = wxPyBeginAllowThreads();
11936 result = (bool)(arg1)->Ungetch(arg2);
11937 wxPyEndAllowThreads(__tstate);
11938 if (PyErr_Occurred()) SWIG_fail;
11939 }
11940 {
11941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11942 }
11943 return resultobj;
11944 fail:
11945 return NULL;
11946 }
11947
11948
11949 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11950 PyObject *resultobj = 0;
11951 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11952 long arg2 ;
11953 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
11954 long result;
11955 void *argp1 = 0 ;
11956 int res1 = 0 ;
11957 long val2 ;
11958 int ecode2 = 0 ;
11959 int val3 ;
11960 int ecode3 = 0 ;
11961 PyObject * obj0 = 0 ;
11962 PyObject * obj1 = 0 ;
11963 PyObject * obj2 = 0 ;
11964 char * kwnames[] = {
11965 (char *) "self",(char *) "pos",(char *) "mode", NULL
11966 };
11967
11968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11970 if (!SWIG_IsOK(res1)) {
11971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11972 }
11973 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11974 ecode2 = SWIG_AsVal_long(obj1, &val2);
11975 if (!SWIG_IsOK(ecode2)) {
11976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
11977 }
11978 arg2 = static_cast< long >(val2);
11979 if (obj2) {
11980 ecode3 = SWIG_AsVal_int(obj2, &val3);
11981 if (!SWIG_IsOK(ecode3)) {
11982 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
11983 }
11984 arg3 = static_cast< wxSeekMode >(val3);
11985 }
11986 {
11987 PyThreadState* __tstate = wxPyBeginAllowThreads();
11988 result = (long)(arg1)->SeekI(arg2,arg3);
11989 wxPyEndAllowThreads(__tstate);
11990 if (PyErr_Occurred()) SWIG_fail;
11991 }
11992 resultobj = SWIG_From_long(static_cast< long >(result));
11993 return resultobj;
11994 fail:
11995 return NULL;
11996 }
11997
11998
11999 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12000 PyObject *resultobj = 0;
12001 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12002 long result;
12003 void *argp1 = 0 ;
12004 int res1 = 0 ;
12005 PyObject *swig_obj[1] ;
12006
12007 if (!args) SWIG_fail;
12008 swig_obj[0] = args;
12009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12010 if (!SWIG_IsOK(res1)) {
12011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12012 }
12013 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12014 {
12015 PyThreadState* __tstate = wxPyBeginAllowThreads();
12016 result = (long)(arg1)->TellI();
12017 wxPyEndAllowThreads(__tstate);
12018 if (PyErr_Occurred()) SWIG_fail;
12019 }
12020 resultobj = SWIG_From_long(static_cast< long >(result));
12021 return resultobj;
12022 fail:
12023 return NULL;
12024 }
12025
12026
12027 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12028 PyObject *obj;
12029 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12030 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12031 return SWIG_Py_Void();
12032 }
12033
12034 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12035 return SWIG_Python_InitShadowInstance(args);
12036 }
12037
12038 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12039 PyObject *resultobj = 0;
12040 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12041 PyObject *arg2 = (PyObject *) 0 ;
12042 void *argp1 = 0 ;
12043 int res1 = 0 ;
12044 PyObject * obj0 = 0 ;
12045 PyObject * obj1 = 0 ;
12046 char * kwnames[] = {
12047 (char *) "self",(char *) "obj", NULL
12048 };
12049
12050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12052 if (!SWIG_IsOK(res1)) {
12053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12054 }
12055 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12056 arg2 = obj1;
12057 {
12058 PyThreadState* __tstate = wxPyBeginAllowThreads();
12059 wxOutputStream_write(arg1,arg2);
12060 wxPyEndAllowThreads(__tstate);
12061 if (PyErr_Occurred()) SWIG_fail;
12062 }
12063 resultobj = SWIG_Py_Void();
12064 return resultobj;
12065 fail:
12066 return NULL;
12067 }
12068
12069
12070 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12071 PyObject *resultobj = 0;
12072 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12073 size_t result;
12074 void *argp1 = 0 ;
12075 int res1 = 0 ;
12076 PyObject *swig_obj[1] ;
12077
12078 if (!args) SWIG_fail;
12079 swig_obj[0] = args;
12080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12081 if (!SWIG_IsOK(res1)) {
12082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12083 }
12084 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12085 {
12086 PyThreadState* __tstate = wxPyBeginAllowThreads();
12087 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12088 wxPyEndAllowThreads(__tstate);
12089 if (PyErr_Occurred()) SWIG_fail;
12090 }
12091 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12092 return resultobj;
12093 fail:
12094 return NULL;
12095 }
12096
12097
12098 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12099 PyObject *obj;
12100 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12101 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12102 return SWIG_Py_Void();
12103 }
12104
12105 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12106 PyObject *resultobj = 0;
12107 wxInputStream *arg1 = (wxInputStream *) 0 ;
12108 wxString *arg2 = 0 ;
12109 wxString *arg3 = 0 ;
12110 wxString *arg4 = 0 ;
12111 wxDateTime arg5 ;
12112 wxFSFile *result = 0 ;
12113 wxPyInputStream *temp1 ;
12114 bool temp2 = false ;
12115 bool temp3 = false ;
12116 bool temp4 = false ;
12117 void *argp5 ;
12118 int res5 = 0 ;
12119 PyObject * obj0 = 0 ;
12120 PyObject * obj1 = 0 ;
12121 PyObject * obj2 = 0 ;
12122 PyObject * obj3 = 0 ;
12123 PyObject * obj4 = 0 ;
12124 char * kwnames[] = {
12125 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12126 };
12127
12128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12129 {
12130 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12131 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12132 } else {
12133 PyErr_Clear(); // clear the failure of the wxPyConvert above
12134 arg1 = wxPyCBInputStream_create(obj0, true);
12135 if (arg1 == NULL) {
12136 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12137 SWIG_fail;
12138 }
12139 }
12140 }
12141 {
12142 arg2 = wxString_in_helper(obj1);
12143 if (arg2 == NULL) SWIG_fail;
12144 temp2 = true;
12145 }
12146 {
12147 arg3 = wxString_in_helper(obj2);
12148 if (arg3 == NULL) SWIG_fail;
12149 temp3 = true;
12150 }
12151 {
12152 arg4 = wxString_in_helper(obj3);
12153 if (arg4 == NULL) SWIG_fail;
12154 temp4 = true;
12155 }
12156 {
12157 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12158 if (!SWIG_IsOK(res5)) {
12159 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12160 }
12161 if (!argp5) {
12162 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12163 } else {
12164 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12165 arg5 = *temp;
12166 if (SWIG_IsNewObj(res5)) delete temp;
12167 }
12168 }
12169 {
12170 PyThreadState* __tstate = wxPyBeginAllowThreads();
12171 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12172 wxPyEndAllowThreads(__tstate);
12173 if (PyErr_Occurred()) SWIG_fail;
12174 }
12175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12176 {
12177 if (temp2)
12178 delete arg2;
12179 }
12180 {
12181 if (temp3)
12182 delete arg3;
12183 }
12184 {
12185 if (temp4)
12186 delete arg4;
12187 }
12188 return resultobj;
12189 fail:
12190 {
12191 if (temp2)
12192 delete arg2;
12193 }
12194 {
12195 if (temp3)
12196 delete arg3;
12197 }
12198 {
12199 if (temp4)
12200 delete arg4;
12201 }
12202 return NULL;
12203 }
12204
12205
12206 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12207 PyObject *resultobj = 0;
12208 wxFSFile *arg1 = (wxFSFile *) 0 ;
12209 void *argp1 = 0 ;
12210 int res1 = 0 ;
12211 PyObject *swig_obj[1] ;
12212
12213 if (!args) SWIG_fail;
12214 swig_obj[0] = args;
12215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12216 if (!SWIG_IsOK(res1)) {
12217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12218 }
12219 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12220 {
12221 PyThreadState* __tstate = wxPyBeginAllowThreads();
12222 delete arg1;
12223
12224 wxPyEndAllowThreads(__tstate);
12225 if (PyErr_Occurred()) SWIG_fail;
12226 }
12227 resultobj = SWIG_Py_Void();
12228 return resultobj;
12229 fail:
12230 return NULL;
12231 }
12232
12233
12234 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12235 PyObject *resultobj = 0;
12236 wxFSFile *arg1 = (wxFSFile *) 0 ;
12237 wxInputStream *result = 0 ;
12238 void *argp1 = 0 ;
12239 int res1 = 0 ;
12240 PyObject *swig_obj[1] ;
12241
12242 if (!args) SWIG_fail;
12243 swig_obj[0] = args;
12244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12245 if (!SWIG_IsOK(res1)) {
12246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12247 }
12248 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12249 {
12250 PyThreadState* __tstate = wxPyBeginAllowThreads();
12251 result = (wxInputStream *)(arg1)->GetStream();
12252 wxPyEndAllowThreads(__tstate);
12253 if (PyErr_Occurred()) SWIG_fail;
12254 }
12255 {
12256 wxPyInputStream * _ptr = NULL;
12257
12258 if (result) {
12259 _ptr = new wxPyInputStream(result);
12260 }
12261 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12262 }
12263 return resultobj;
12264 fail:
12265 return NULL;
12266 }
12267
12268
12269 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12270 PyObject *resultobj = 0;
12271 wxFSFile *arg1 = (wxFSFile *) 0 ;
12272 void *argp1 = 0 ;
12273 int res1 = 0 ;
12274 PyObject *swig_obj[1] ;
12275
12276 if (!args) SWIG_fail;
12277 swig_obj[0] = args;
12278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12279 if (!SWIG_IsOK(res1)) {
12280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12281 }
12282 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12283 {
12284 PyThreadState* __tstate = wxPyBeginAllowThreads();
12285 (arg1)->DetachStream();
12286 wxPyEndAllowThreads(__tstate);
12287 if (PyErr_Occurred()) SWIG_fail;
12288 }
12289 resultobj = SWIG_Py_Void();
12290 return resultobj;
12291 fail:
12292 return NULL;
12293 }
12294
12295
12296 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12297 PyObject *resultobj = 0;
12298 wxFSFile *arg1 = (wxFSFile *) 0 ;
12299 wxString *result = 0 ;
12300 void *argp1 = 0 ;
12301 int res1 = 0 ;
12302 PyObject *swig_obj[1] ;
12303
12304 if (!args) SWIG_fail;
12305 swig_obj[0] = args;
12306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12307 if (!SWIG_IsOK(res1)) {
12308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12309 }
12310 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12311 {
12312 PyThreadState* __tstate = wxPyBeginAllowThreads();
12313 {
12314 wxString const &_result_ref = (arg1)->GetMimeType();
12315 result = (wxString *) &_result_ref;
12316 }
12317 wxPyEndAllowThreads(__tstate);
12318 if (PyErr_Occurred()) SWIG_fail;
12319 }
12320 {
12321 #if wxUSE_UNICODE
12322 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12323 #else
12324 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12325 #endif
12326 }
12327 return resultobj;
12328 fail:
12329 return NULL;
12330 }
12331
12332
12333 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12334 PyObject *resultobj = 0;
12335 wxFSFile *arg1 = (wxFSFile *) 0 ;
12336 wxString *result = 0 ;
12337 void *argp1 = 0 ;
12338 int res1 = 0 ;
12339 PyObject *swig_obj[1] ;
12340
12341 if (!args) SWIG_fail;
12342 swig_obj[0] = args;
12343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12344 if (!SWIG_IsOK(res1)) {
12345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12346 }
12347 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12348 {
12349 PyThreadState* __tstate = wxPyBeginAllowThreads();
12350 {
12351 wxString const &_result_ref = (arg1)->GetLocation();
12352 result = (wxString *) &_result_ref;
12353 }
12354 wxPyEndAllowThreads(__tstate);
12355 if (PyErr_Occurred()) SWIG_fail;
12356 }
12357 {
12358 #if wxUSE_UNICODE
12359 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12360 #else
12361 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12362 #endif
12363 }
12364 return resultobj;
12365 fail:
12366 return NULL;
12367 }
12368
12369
12370 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12371 PyObject *resultobj = 0;
12372 wxFSFile *arg1 = (wxFSFile *) 0 ;
12373 wxString *result = 0 ;
12374 void *argp1 = 0 ;
12375 int res1 = 0 ;
12376 PyObject *swig_obj[1] ;
12377
12378 if (!args) SWIG_fail;
12379 swig_obj[0] = args;
12380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12381 if (!SWIG_IsOK(res1)) {
12382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12383 }
12384 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12385 {
12386 PyThreadState* __tstate = wxPyBeginAllowThreads();
12387 {
12388 wxString const &_result_ref = (arg1)->GetAnchor();
12389 result = (wxString *) &_result_ref;
12390 }
12391 wxPyEndAllowThreads(__tstate);
12392 if (PyErr_Occurred()) SWIG_fail;
12393 }
12394 {
12395 #if wxUSE_UNICODE
12396 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12397 #else
12398 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12399 #endif
12400 }
12401 return resultobj;
12402 fail:
12403 return NULL;
12404 }
12405
12406
12407 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12408 PyObject *resultobj = 0;
12409 wxFSFile *arg1 = (wxFSFile *) 0 ;
12410 wxDateTime result;
12411 void *argp1 = 0 ;
12412 int res1 = 0 ;
12413 PyObject *swig_obj[1] ;
12414
12415 if (!args) SWIG_fail;
12416 swig_obj[0] = args;
12417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12418 if (!SWIG_IsOK(res1)) {
12419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12420 }
12421 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12422 {
12423 PyThreadState* __tstate = wxPyBeginAllowThreads();
12424 result = (arg1)->GetModificationTime();
12425 wxPyEndAllowThreads(__tstate);
12426 if (PyErr_Occurred()) SWIG_fail;
12427 }
12428 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12429 return resultobj;
12430 fail:
12431 return NULL;
12432 }
12433
12434
12435 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12436 PyObject *obj;
12437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12438 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12439 return SWIG_Py_Void();
12440 }
12441
12442 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12443 return SWIG_Python_InitShadowInstance(args);
12444 }
12445
12446 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12447 PyObject *resultobj = 0;
12448 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12449 void *argp1 = 0 ;
12450 int res1 = 0 ;
12451 PyObject *swig_obj[1] ;
12452
12453 if (!args) SWIG_fail;
12454 swig_obj[0] = args;
12455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12456 if (!SWIG_IsOK(res1)) {
12457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12458 }
12459 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12460 {
12461 PyThreadState* __tstate = wxPyBeginAllowThreads();
12462 delete arg1;
12463
12464 wxPyEndAllowThreads(__tstate);
12465 if (PyErr_Occurred()) SWIG_fail;
12466 }
12467 resultobj = SWIG_Py_Void();
12468 return resultobj;
12469 fail:
12470 return NULL;
12471 }
12472
12473
12474 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12475 PyObject *obj;
12476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12477 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12478 return SWIG_Py_Void();
12479 }
12480
12481 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12482 PyObject *resultobj = 0;
12483 wxPyFileSystemHandler *result = 0 ;
12484
12485 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12486 {
12487 PyThreadState* __tstate = wxPyBeginAllowThreads();
12488 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12489 wxPyEndAllowThreads(__tstate);
12490 if (PyErr_Occurred()) SWIG_fail;
12491 }
12492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12493 return resultobj;
12494 fail:
12495 return NULL;
12496 }
12497
12498
12499 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12500 PyObject *resultobj = 0;
12501 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12502 PyObject *arg2 = (PyObject *) 0 ;
12503 PyObject *arg3 = (PyObject *) 0 ;
12504 void *argp1 = 0 ;
12505 int res1 = 0 ;
12506 PyObject * obj0 = 0 ;
12507 PyObject * obj1 = 0 ;
12508 PyObject * obj2 = 0 ;
12509 char * kwnames[] = {
12510 (char *) "self",(char *) "self",(char *) "_class", NULL
12511 };
12512
12513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12515 if (!SWIG_IsOK(res1)) {
12516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12517 }
12518 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12519 arg2 = obj1;
12520 arg3 = obj2;
12521 {
12522 PyThreadState* __tstate = wxPyBeginAllowThreads();
12523 (arg1)->_setCallbackInfo(arg2,arg3);
12524 wxPyEndAllowThreads(__tstate);
12525 if (PyErr_Occurred()) SWIG_fail;
12526 }
12527 resultobj = SWIG_Py_Void();
12528 return resultobj;
12529 fail:
12530 return NULL;
12531 }
12532
12533
12534 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12535 PyObject *resultobj = 0;
12536 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12537 wxString *arg2 = 0 ;
12538 bool result;
12539 void *argp1 = 0 ;
12540 int res1 = 0 ;
12541 bool temp2 = false ;
12542 PyObject * obj0 = 0 ;
12543 PyObject * obj1 = 0 ;
12544 char * kwnames[] = {
12545 (char *) "self",(char *) "location", NULL
12546 };
12547
12548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12550 if (!SWIG_IsOK(res1)) {
12551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12552 }
12553 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12554 {
12555 arg2 = wxString_in_helper(obj1);
12556 if (arg2 == NULL) SWIG_fail;
12557 temp2 = true;
12558 }
12559 {
12560 PyThreadState* __tstate = wxPyBeginAllowThreads();
12561 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12562 wxPyEndAllowThreads(__tstate);
12563 if (PyErr_Occurred()) SWIG_fail;
12564 }
12565 {
12566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12567 }
12568 {
12569 if (temp2)
12570 delete arg2;
12571 }
12572 return resultobj;
12573 fail:
12574 {
12575 if (temp2)
12576 delete arg2;
12577 }
12578 return NULL;
12579 }
12580
12581
12582 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12583 PyObject *resultobj = 0;
12584 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12585 wxFileSystem *arg2 = 0 ;
12586 wxString *arg3 = 0 ;
12587 wxFSFile *result = 0 ;
12588 void *argp1 = 0 ;
12589 int res1 = 0 ;
12590 void *argp2 = 0 ;
12591 int res2 = 0 ;
12592 bool temp3 = false ;
12593 PyObject * obj0 = 0 ;
12594 PyObject * obj1 = 0 ;
12595 PyObject * obj2 = 0 ;
12596 char * kwnames[] = {
12597 (char *) "self",(char *) "fs",(char *) "location", NULL
12598 };
12599
12600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12602 if (!SWIG_IsOK(res1)) {
12603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12604 }
12605 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12606 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12607 if (!SWIG_IsOK(res2)) {
12608 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12609 }
12610 if (!argp2) {
12611 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12612 }
12613 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12614 {
12615 arg3 = wxString_in_helper(obj2);
12616 if (arg3 == NULL) SWIG_fail;
12617 temp3 = true;
12618 }
12619 {
12620 PyThreadState* __tstate = wxPyBeginAllowThreads();
12621 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12622 wxPyEndAllowThreads(__tstate);
12623 if (PyErr_Occurred()) SWIG_fail;
12624 }
12625 {
12626 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
12627 }
12628 {
12629 if (temp3)
12630 delete arg3;
12631 }
12632 return resultobj;
12633 fail:
12634 {
12635 if (temp3)
12636 delete arg3;
12637 }
12638 return NULL;
12639 }
12640
12641
12642 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12643 PyObject *resultobj = 0;
12644 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12645 wxString *arg2 = 0 ;
12646 int arg3 = (int) 0 ;
12647 wxString result;
12648 void *argp1 = 0 ;
12649 int res1 = 0 ;
12650 bool temp2 = false ;
12651 int val3 ;
12652 int ecode3 = 0 ;
12653 PyObject * obj0 = 0 ;
12654 PyObject * obj1 = 0 ;
12655 PyObject * obj2 = 0 ;
12656 char * kwnames[] = {
12657 (char *) "self",(char *) "spec",(char *) "flags", NULL
12658 };
12659
12660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12662 if (!SWIG_IsOK(res1)) {
12663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12664 }
12665 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12666 {
12667 arg2 = wxString_in_helper(obj1);
12668 if (arg2 == NULL) SWIG_fail;
12669 temp2 = true;
12670 }
12671 if (obj2) {
12672 ecode3 = SWIG_AsVal_int(obj2, &val3);
12673 if (!SWIG_IsOK(ecode3)) {
12674 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12675 }
12676 arg3 = static_cast< int >(val3);
12677 }
12678 {
12679 PyThreadState* __tstate = wxPyBeginAllowThreads();
12680 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12681 wxPyEndAllowThreads(__tstate);
12682 if (PyErr_Occurred()) SWIG_fail;
12683 }
12684 {
12685 #if wxUSE_UNICODE
12686 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12687 #else
12688 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12689 #endif
12690 }
12691 {
12692 if (temp2)
12693 delete arg2;
12694 }
12695 return resultobj;
12696 fail:
12697 {
12698 if (temp2)
12699 delete arg2;
12700 }
12701 return NULL;
12702 }
12703
12704
12705 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12706 PyObject *resultobj = 0;
12707 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12708 wxString result;
12709 void *argp1 = 0 ;
12710 int res1 = 0 ;
12711 PyObject *swig_obj[1] ;
12712
12713 if (!args) SWIG_fail;
12714 swig_obj[0] = args;
12715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12716 if (!SWIG_IsOK(res1)) {
12717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12718 }
12719 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12720 {
12721 PyThreadState* __tstate = wxPyBeginAllowThreads();
12722 result = (arg1)->FindNext();
12723 wxPyEndAllowThreads(__tstate);
12724 if (PyErr_Occurred()) SWIG_fail;
12725 }
12726 {
12727 #if wxUSE_UNICODE
12728 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12729 #else
12730 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12731 #endif
12732 }
12733 return resultobj;
12734 fail:
12735 return NULL;
12736 }
12737
12738
12739 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12740 PyObject *resultobj = 0;
12741 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12742 wxString *arg2 = 0 ;
12743 wxString result;
12744 void *argp1 = 0 ;
12745 int res1 = 0 ;
12746 bool temp2 = false ;
12747 PyObject * obj0 = 0 ;
12748 PyObject * obj1 = 0 ;
12749 char * kwnames[] = {
12750 (char *) "self",(char *) "location", NULL
12751 };
12752
12753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12755 if (!SWIG_IsOK(res1)) {
12756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12757 }
12758 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12759 {
12760 arg2 = wxString_in_helper(obj1);
12761 if (arg2 == NULL) SWIG_fail;
12762 temp2 = true;
12763 }
12764 {
12765 PyThreadState* __tstate = wxPyBeginAllowThreads();
12766 result = (arg1)->GetProtocol((wxString const &)*arg2);
12767 wxPyEndAllowThreads(__tstate);
12768 if (PyErr_Occurred()) SWIG_fail;
12769 }
12770 {
12771 #if wxUSE_UNICODE
12772 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12773 #else
12774 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12775 #endif
12776 }
12777 {
12778 if (temp2)
12779 delete arg2;
12780 }
12781 return resultobj;
12782 fail:
12783 {
12784 if (temp2)
12785 delete arg2;
12786 }
12787 return NULL;
12788 }
12789
12790
12791 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12792 PyObject *resultobj = 0;
12793 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12794 wxString *arg2 = 0 ;
12795 wxString result;
12796 void *argp1 = 0 ;
12797 int res1 = 0 ;
12798 bool temp2 = false ;
12799 PyObject * obj0 = 0 ;
12800 PyObject * obj1 = 0 ;
12801 char * kwnames[] = {
12802 (char *) "self",(char *) "location", NULL
12803 };
12804
12805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12807 if (!SWIG_IsOK(res1)) {
12808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12809 }
12810 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12811 {
12812 arg2 = wxString_in_helper(obj1);
12813 if (arg2 == NULL) SWIG_fail;
12814 temp2 = true;
12815 }
12816 {
12817 PyThreadState* __tstate = wxPyBeginAllowThreads();
12818 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12819 wxPyEndAllowThreads(__tstate);
12820 if (PyErr_Occurred()) SWIG_fail;
12821 }
12822 {
12823 #if wxUSE_UNICODE
12824 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12825 #else
12826 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12827 #endif
12828 }
12829 {
12830 if (temp2)
12831 delete arg2;
12832 }
12833 return resultobj;
12834 fail:
12835 {
12836 if (temp2)
12837 delete arg2;
12838 }
12839 return NULL;
12840 }
12841
12842
12843 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12844 PyObject *resultobj = 0;
12845 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12846 wxString *arg2 = 0 ;
12847 wxString result;
12848 void *argp1 = 0 ;
12849 int res1 = 0 ;
12850 bool temp2 = false ;
12851 PyObject * obj0 = 0 ;
12852 PyObject * obj1 = 0 ;
12853 char * kwnames[] = {
12854 (char *) "self",(char *) "location", NULL
12855 };
12856
12857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12859 if (!SWIG_IsOK(res1)) {
12860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12861 }
12862 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12863 {
12864 arg2 = wxString_in_helper(obj1);
12865 if (arg2 == NULL) SWIG_fail;
12866 temp2 = true;
12867 }
12868 {
12869 PyThreadState* __tstate = wxPyBeginAllowThreads();
12870 result = (arg1)->GetAnchor((wxString const &)*arg2);
12871 wxPyEndAllowThreads(__tstate);
12872 if (PyErr_Occurred()) SWIG_fail;
12873 }
12874 {
12875 #if wxUSE_UNICODE
12876 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12877 #else
12878 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12879 #endif
12880 }
12881 {
12882 if (temp2)
12883 delete arg2;
12884 }
12885 return resultobj;
12886 fail:
12887 {
12888 if (temp2)
12889 delete arg2;
12890 }
12891 return NULL;
12892 }
12893
12894
12895 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12896 PyObject *resultobj = 0;
12897 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12898 wxString *arg2 = 0 ;
12899 wxString result;
12900 void *argp1 = 0 ;
12901 int res1 = 0 ;
12902 bool temp2 = false ;
12903 PyObject * obj0 = 0 ;
12904 PyObject * obj1 = 0 ;
12905 char * kwnames[] = {
12906 (char *) "self",(char *) "location", NULL
12907 };
12908
12909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12911 if (!SWIG_IsOK(res1)) {
12912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12913 }
12914 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12915 {
12916 arg2 = wxString_in_helper(obj1);
12917 if (arg2 == NULL) SWIG_fail;
12918 temp2 = true;
12919 }
12920 {
12921 PyThreadState* __tstate = wxPyBeginAllowThreads();
12922 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12923 wxPyEndAllowThreads(__tstate);
12924 if (PyErr_Occurred()) SWIG_fail;
12925 }
12926 {
12927 #if wxUSE_UNICODE
12928 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12929 #else
12930 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12931 #endif
12932 }
12933 {
12934 if (temp2)
12935 delete arg2;
12936 }
12937 return resultobj;
12938 fail:
12939 {
12940 if (temp2)
12941 delete arg2;
12942 }
12943 return NULL;
12944 }
12945
12946
12947 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12948 PyObject *resultobj = 0;
12949 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12950 wxString *arg2 = 0 ;
12951 wxString result;
12952 void *argp1 = 0 ;
12953 int res1 = 0 ;
12954 bool temp2 = false ;
12955 PyObject * obj0 = 0 ;
12956 PyObject * obj1 = 0 ;
12957 char * kwnames[] = {
12958 (char *) "self",(char *) "location", NULL
12959 };
12960
12961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
12962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12963 if (!SWIG_IsOK(res1)) {
12964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12965 }
12966 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12967 {
12968 arg2 = wxString_in_helper(obj1);
12969 if (arg2 == NULL) SWIG_fail;
12970 temp2 = true;
12971 }
12972 {
12973 PyThreadState* __tstate = wxPyBeginAllowThreads();
12974 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
12975 wxPyEndAllowThreads(__tstate);
12976 if (PyErr_Occurred()) SWIG_fail;
12977 }
12978 {
12979 #if wxUSE_UNICODE
12980 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12981 #else
12982 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12983 #endif
12984 }
12985 {
12986 if (temp2)
12987 delete arg2;
12988 }
12989 return resultobj;
12990 fail:
12991 {
12992 if (temp2)
12993 delete arg2;
12994 }
12995 return NULL;
12996 }
12997
12998
12999 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13000 PyObject *obj;
13001 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13002 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
13003 return SWIG_Py_Void();
13004 }
13005
13006 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13007 return SWIG_Python_InitShadowInstance(args);
13008 }
13009
13010 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13011 PyObject *resultobj = 0;
13012 wxFileSystem *result = 0 ;
13013
13014 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13015 {
13016 PyThreadState* __tstate = wxPyBeginAllowThreads();
13017 result = (wxFileSystem *)new wxFileSystem();
13018 wxPyEndAllowThreads(__tstate);
13019 if (PyErr_Occurred()) SWIG_fail;
13020 }
13021 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13022 return resultobj;
13023 fail:
13024 return NULL;
13025 }
13026
13027
13028 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13029 PyObject *resultobj = 0;
13030 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13031 void *argp1 = 0 ;
13032 int res1 = 0 ;
13033 PyObject *swig_obj[1] ;
13034
13035 if (!args) SWIG_fail;
13036 swig_obj[0] = args;
13037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13038 if (!SWIG_IsOK(res1)) {
13039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13040 }
13041 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13042 {
13043 PyThreadState* __tstate = wxPyBeginAllowThreads();
13044 delete arg1;
13045
13046 wxPyEndAllowThreads(__tstate);
13047 if (PyErr_Occurred()) SWIG_fail;
13048 }
13049 resultobj = SWIG_Py_Void();
13050 return resultobj;
13051 fail:
13052 return NULL;
13053 }
13054
13055
13056 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13057 PyObject *resultobj = 0;
13058 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13059 wxString *arg2 = 0 ;
13060 bool arg3 = (bool) false ;
13061 void *argp1 = 0 ;
13062 int res1 = 0 ;
13063 bool temp2 = false ;
13064 bool val3 ;
13065 int ecode3 = 0 ;
13066 PyObject * obj0 = 0 ;
13067 PyObject * obj1 = 0 ;
13068 PyObject * obj2 = 0 ;
13069 char * kwnames[] = {
13070 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13071 };
13072
13073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13075 if (!SWIG_IsOK(res1)) {
13076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13077 }
13078 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13079 {
13080 arg2 = wxString_in_helper(obj1);
13081 if (arg2 == NULL) SWIG_fail;
13082 temp2 = true;
13083 }
13084 if (obj2) {
13085 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13086 if (!SWIG_IsOK(ecode3)) {
13087 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13088 }
13089 arg3 = static_cast< bool >(val3);
13090 }
13091 {
13092 PyThreadState* __tstate = wxPyBeginAllowThreads();
13093 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13094 wxPyEndAllowThreads(__tstate);
13095 if (PyErr_Occurred()) SWIG_fail;
13096 }
13097 resultobj = SWIG_Py_Void();
13098 {
13099 if (temp2)
13100 delete arg2;
13101 }
13102 return resultobj;
13103 fail:
13104 {
13105 if (temp2)
13106 delete arg2;
13107 }
13108 return NULL;
13109 }
13110
13111
13112 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13113 PyObject *resultobj = 0;
13114 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13115 wxString result;
13116 void *argp1 = 0 ;
13117 int res1 = 0 ;
13118 PyObject *swig_obj[1] ;
13119
13120 if (!args) SWIG_fail;
13121 swig_obj[0] = args;
13122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13123 if (!SWIG_IsOK(res1)) {
13124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13125 }
13126 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13127 {
13128 PyThreadState* __tstate = wxPyBeginAllowThreads();
13129 result = (arg1)->GetPath();
13130 wxPyEndAllowThreads(__tstate);
13131 if (PyErr_Occurred()) SWIG_fail;
13132 }
13133 {
13134 #if wxUSE_UNICODE
13135 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13136 #else
13137 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13138 #endif
13139 }
13140 return resultobj;
13141 fail:
13142 return NULL;
13143 }
13144
13145
13146 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13147 PyObject *resultobj = 0;
13148 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13149 wxString *arg2 = 0 ;
13150 wxFSFile *result = 0 ;
13151 void *argp1 = 0 ;
13152 int res1 = 0 ;
13153 bool temp2 = false ;
13154 PyObject * obj0 = 0 ;
13155 PyObject * obj1 = 0 ;
13156 char * kwnames[] = {
13157 (char *) "self",(char *) "location", NULL
13158 };
13159
13160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13162 if (!SWIG_IsOK(res1)) {
13163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13164 }
13165 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13166 {
13167 arg2 = wxString_in_helper(obj1);
13168 if (arg2 == NULL) SWIG_fail;
13169 temp2 = true;
13170 }
13171 {
13172 PyThreadState* __tstate = wxPyBeginAllowThreads();
13173 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13174 wxPyEndAllowThreads(__tstate);
13175 if (PyErr_Occurred()) SWIG_fail;
13176 }
13177 {
13178 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13179 }
13180 {
13181 if (temp2)
13182 delete arg2;
13183 }
13184 return resultobj;
13185 fail:
13186 {
13187 if (temp2)
13188 delete arg2;
13189 }
13190 return NULL;
13191 }
13192
13193
13194 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13195 PyObject *resultobj = 0;
13196 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13197 wxString *arg2 = 0 ;
13198 int arg3 = (int) 0 ;
13199 wxString result;
13200 void *argp1 = 0 ;
13201 int res1 = 0 ;
13202 bool temp2 = false ;
13203 int val3 ;
13204 int ecode3 = 0 ;
13205 PyObject * obj0 = 0 ;
13206 PyObject * obj1 = 0 ;
13207 PyObject * obj2 = 0 ;
13208 char * kwnames[] = {
13209 (char *) "self",(char *) "spec",(char *) "flags", NULL
13210 };
13211
13212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13214 if (!SWIG_IsOK(res1)) {
13215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13216 }
13217 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13218 {
13219 arg2 = wxString_in_helper(obj1);
13220 if (arg2 == NULL) SWIG_fail;
13221 temp2 = true;
13222 }
13223 if (obj2) {
13224 ecode3 = SWIG_AsVal_int(obj2, &val3);
13225 if (!SWIG_IsOK(ecode3)) {
13226 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13227 }
13228 arg3 = static_cast< int >(val3);
13229 }
13230 {
13231 PyThreadState* __tstate = wxPyBeginAllowThreads();
13232 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13233 wxPyEndAllowThreads(__tstate);
13234 if (PyErr_Occurred()) SWIG_fail;
13235 }
13236 {
13237 #if wxUSE_UNICODE
13238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13239 #else
13240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13241 #endif
13242 }
13243 {
13244 if (temp2)
13245 delete arg2;
13246 }
13247 return resultobj;
13248 fail:
13249 {
13250 if (temp2)
13251 delete arg2;
13252 }
13253 return NULL;
13254 }
13255
13256
13257 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13258 PyObject *resultobj = 0;
13259 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13260 wxString result;
13261 void *argp1 = 0 ;
13262 int res1 = 0 ;
13263 PyObject *swig_obj[1] ;
13264
13265 if (!args) SWIG_fail;
13266 swig_obj[0] = args;
13267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13268 if (!SWIG_IsOK(res1)) {
13269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13270 }
13271 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13272 {
13273 PyThreadState* __tstate = wxPyBeginAllowThreads();
13274 result = (arg1)->FindNext();
13275 wxPyEndAllowThreads(__tstate);
13276 if (PyErr_Occurred()) SWIG_fail;
13277 }
13278 {
13279 #if wxUSE_UNICODE
13280 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13281 #else
13282 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13283 #endif
13284 }
13285 return resultobj;
13286 fail:
13287 return NULL;
13288 }
13289
13290
13291 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13292 PyObject *resultobj = 0;
13293 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13294 int res1 = 0 ;
13295 PyObject * obj0 = 0 ;
13296 char * kwnames[] = {
13297 (char *) "handler", NULL
13298 };
13299
13300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13301 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13302 if (!SWIG_IsOK(res1)) {
13303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13304 }
13305 {
13306 PyThreadState* __tstate = wxPyBeginAllowThreads();
13307 wxFileSystem::AddHandler(arg1);
13308 wxPyEndAllowThreads(__tstate);
13309 if (PyErr_Occurred()) SWIG_fail;
13310 }
13311 resultobj = SWIG_Py_Void();
13312 return resultobj;
13313 fail:
13314 return NULL;
13315 }
13316
13317
13318 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13319 PyObject *resultobj = 0;
13320 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13321 wxFileSystemHandler *result = 0 ;
13322 void *argp1 = 0 ;
13323 int res1 = 0 ;
13324 PyObject * obj0 = 0 ;
13325 char * kwnames[] = {
13326 (char *) "handler", NULL
13327 };
13328
13329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13331 if (!SWIG_IsOK(res1)) {
13332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13333 }
13334 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13335 {
13336 PyThreadState* __tstate = wxPyBeginAllowThreads();
13337 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13338 wxPyEndAllowThreads(__tstate);
13339 if (PyErr_Occurred()) SWIG_fail;
13340 }
13341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13342 return resultobj;
13343 fail:
13344 return NULL;
13345 }
13346
13347
13348 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13349 PyObject *resultobj = 0;
13350
13351 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13352 {
13353 PyThreadState* __tstate = wxPyBeginAllowThreads();
13354 wxFileSystem::CleanUpHandlers();
13355 wxPyEndAllowThreads(__tstate);
13356 if (PyErr_Occurred()) SWIG_fail;
13357 }
13358 resultobj = SWIG_Py_Void();
13359 return resultobj;
13360 fail:
13361 return NULL;
13362 }
13363
13364
13365 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13366 PyObject *resultobj = 0;
13367 wxString *arg1 = 0 ;
13368 wxString result;
13369 bool temp1 = false ;
13370 PyObject * obj0 = 0 ;
13371 char * kwnames[] = {
13372 (char *) "filename", NULL
13373 };
13374
13375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13376 {
13377 arg1 = wxString_in_helper(obj0);
13378 if (arg1 == NULL) SWIG_fail;
13379 temp1 = true;
13380 }
13381 {
13382 PyThreadState* __tstate = wxPyBeginAllowThreads();
13383 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13384 wxPyEndAllowThreads(__tstate);
13385 if (PyErr_Occurred()) SWIG_fail;
13386 }
13387 {
13388 #if wxUSE_UNICODE
13389 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13390 #else
13391 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13392 #endif
13393 }
13394 {
13395 if (temp1)
13396 delete arg1;
13397 }
13398 return resultobj;
13399 fail:
13400 {
13401 if (temp1)
13402 delete arg1;
13403 }
13404 return NULL;
13405 }
13406
13407
13408 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13409 PyObject *resultobj = 0;
13410 wxString *arg1 = 0 ;
13411 wxString result;
13412 bool temp1 = false ;
13413 PyObject * obj0 = 0 ;
13414 char * kwnames[] = {
13415 (char *) "url", NULL
13416 };
13417
13418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13419 {
13420 arg1 = wxString_in_helper(obj0);
13421 if (arg1 == NULL) SWIG_fail;
13422 temp1 = true;
13423 }
13424 {
13425 PyThreadState* __tstate = wxPyBeginAllowThreads();
13426 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
13427 wxPyEndAllowThreads(__tstate);
13428 if (PyErr_Occurred()) SWIG_fail;
13429 }
13430 {
13431 #if wxUSE_UNICODE
13432 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13433 #else
13434 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13435 #endif
13436 }
13437 {
13438 if (temp1)
13439 delete arg1;
13440 }
13441 return resultobj;
13442 fail:
13443 {
13444 if (temp1)
13445 delete arg1;
13446 }
13447 return NULL;
13448 }
13449
13450
13451 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13452 PyObject *obj;
13453 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13454 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13455 return SWIG_Py_Void();
13456 }
13457
13458 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13459 return SWIG_Python_InitShadowInstance(args);
13460 }
13461
13462 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13463 PyObject *resultobj = 0;
13464 wxInternetFSHandler *result = 0 ;
13465
13466 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13467 {
13468 PyThreadState* __tstate = wxPyBeginAllowThreads();
13469 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13470 wxPyEndAllowThreads(__tstate);
13471 if (PyErr_Occurred()) SWIG_fail;
13472 }
13473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13474 return resultobj;
13475 fail:
13476 return NULL;
13477 }
13478
13479
13480 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13481 PyObject *resultobj = 0;
13482 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13483 wxString *arg2 = 0 ;
13484 bool result;
13485 void *argp1 = 0 ;
13486 int res1 = 0 ;
13487 bool temp2 = false ;
13488 PyObject * obj0 = 0 ;
13489 PyObject * obj1 = 0 ;
13490 char * kwnames[] = {
13491 (char *) "self",(char *) "location", NULL
13492 };
13493
13494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13496 if (!SWIG_IsOK(res1)) {
13497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13498 }
13499 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13500 {
13501 arg2 = wxString_in_helper(obj1);
13502 if (arg2 == NULL) SWIG_fail;
13503 temp2 = true;
13504 }
13505 {
13506 PyThreadState* __tstate = wxPyBeginAllowThreads();
13507 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13508 wxPyEndAllowThreads(__tstate);
13509 if (PyErr_Occurred()) SWIG_fail;
13510 }
13511 {
13512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13513 }
13514 {
13515 if (temp2)
13516 delete arg2;
13517 }
13518 return resultobj;
13519 fail:
13520 {
13521 if (temp2)
13522 delete arg2;
13523 }
13524 return NULL;
13525 }
13526
13527
13528 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13529 PyObject *resultobj = 0;
13530 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13531 wxFileSystem *arg2 = 0 ;
13532 wxString *arg3 = 0 ;
13533 wxFSFile *result = 0 ;
13534 void *argp1 = 0 ;
13535 int res1 = 0 ;
13536 void *argp2 = 0 ;
13537 int res2 = 0 ;
13538 bool temp3 = false ;
13539 PyObject * obj0 = 0 ;
13540 PyObject * obj1 = 0 ;
13541 PyObject * obj2 = 0 ;
13542 char * kwnames[] = {
13543 (char *) "self",(char *) "fs",(char *) "location", NULL
13544 };
13545
13546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13548 if (!SWIG_IsOK(res1)) {
13549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13550 }
13551 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13552 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13553 if (!SWIG_IsOK(res2)) {
13554 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13555 }
13556 if (!argp2) {
13557 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13558 }
13559 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13560 {
13561 arg3 = wxString_in_helper(obj2);
13562 if (arg3 == NULL) SWIG_fail;
13563 temp3 = true;
13564 }
13565 {
13566 PyThreadState* __tstate = wxPyBeginAllowThreads();
13567 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13568 wxPyEndAllowThreads(__tstate);
13569 if (PyErr_Occurred()) SWIG_fail;
13570 }
13571 {
13572 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13573 }
13574 {
13575 if (temp3)
13576 delete arg3;
13577 }
13578 return resultobj;
13579 fail:
13580 {
13581 if (temp3)
13582 delete arg3;
13583 }
13584 return NULL;
13585 }
13586
13587
13588 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13589 PyObject *obj;
13590 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13591 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13592 return SWIG_Py_Void();
13593 }
13594
13595 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13596 return SWIG_Python_InitShadowInstance(args);
13597 }
13598
13599 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13600 PyObject *resultobj = 0;
13601 wxZipFSHandler *result = 0 ;
13602
13603 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13604 {
13605 PyThreadState* __tstate = wxPyBeginAllowThreads();
13606 result = (wxZipFSHandler *)new wxZipFSHandler();
13607 wxPyEndAllowThreads(__tstate);
13608 if (PyErr_Occurred()) SWIG_fail;
13609 }
13610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13611 return resultobj;
13612 fail:
13613 return NULL;
13614 }
13615
13616
13617 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13618 PyObject *resultobj = 0;
13619 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13620 wxString *arg2 = 0 ;
13621 bool result;
13622 void *argp1 = 0 ;
13623 int res1 = 0 ;
13624 bool temp2 = false ;
13625 PyObject * obj0 = 0 ;
13626 PyObject * obj1 = 0 ;
13627 char * kwnames[] = {
13628 (char *) "self",(char *) "location", NULL
13629 };
13630
13631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13633 if (!SWIG_IsOK(res1)) {
13634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13635 }
13636 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13637 {
13638 arg2 = wxString_in_helper(obj1);
13639 if (arg2 == NULL) SWIG_fail;
13640 temp2 = true;
13641 }
13642 {
13643 PyThreadState* __tstate = wxPyBeginAllowThreads();
13644 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13645 wxPyEndAllowThreads(__tstate);
13646 if (PyErr_Occurred()) SWIG_fail;
13647 }
13648 {
13649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13650 }
13651 {
13652 if (temp2)
13653 delete arg2;
13654 }
13655 return resultobj;
13656 fail:
13657 {
13658 if (temp2)
13659 delete arg2;
13660 }
13661 return NULL;
13662 }
13663
13664
13665 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13666 PyObject *resultobj = 0;
13667 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13668 wxFileSystem *arg2 = 0 ;
13669 wxString *arg3 = 0 ;
13670 wxFSFile *result = 0 ;
13671 void *argp1 = 0 ;
13672 int res1 = 0 ;
13673 void *argp2 = 0 ;
13674 int res2 = 0 ;
13675 bool temp3 = false ;
13676 PyObject * obj0 = 0 ;
13677 PyObject * obj1 = 0 ;
13678 PyObject * obj2 = 0 ;
13679 char * kwnames[] = {
13680 (char *) "self",(char *) "fs",(char *) "location", NULL
13681 };
13682
13683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13685 if (!SWIG_IsOK(res1)) {
13686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13687 }
13688 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13689 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13690 if (!SWIG_IsOK(res2)) {
13691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13692 }
13693 if (!argp2) {
13694 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13695 }
13696 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13697 {
13698 arg3 = wxString_in_helper(obj2);
13699 if (arg3 == NULL) SWIG_fail;
13700 temp3 = true;
13701 }
13702 {
13703 PyThreadState* __tstate = wxPyBeginAllowThreads();
13704 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13705 wxPyEndAllowThreads(__tstate);
13706 if (PyErr_Occurred()) SWIG_fail;
13707 }
13708 {
13709 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13710 }
13711 {
13712 if (temp3)
13713 delete arg3;
13714 }
13715 return resultobj;
13716 fail:
13717 {
13718 if (temp3)
13719 delete arg3;
13720 }
13721 return NULL;
13722 }
13723
13724
13725 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13726 PyObject *resultobj = 0;
13727 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13728 wxString *arg2 = 0 ;
13729 int arg3 = (int) 0 ;
13730 wxString result;
13731 void *argp1 = 0 ;
13732 int res1 = 0 ;
13733 bool temp2 = false ;
13734 int val3 ;
13735 int ecode3 = 0 ;
13736 PyObject * obj0 = 0 ;
13737 PyObject * obj1 = 0 ;
13738 PyObject * obj2 = 0 ;
13739 char * kwnames[] = {
13740 (char *) "self",(char *) "spec",(char *) "flags", NULL
13741 };
13742
13743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13745 if (!SWIG_IsOK(res1)) {
13746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13747 }
13748 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13749 {
13750 arg2 = wxString_in_helper(obj1);
13751 if (arg2 == NULL) SWIG_fail;
13752 temp2 = true;
13753 }
13754 if (obj2) {
13755 ecode3 = SWIG_AsVal_int(obj2, &val3);
13756 if (!SWIG_IsOK(ecode3)) {
13757 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13758 }
13759 arg3 = static_cast< int >(val3);
13760 }
13761 {
13762 PyThreadState* __tstate = wxPyBeginAllowThreads();
13763 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13764 wxPyEndAllowThreads(__tstate);
13765 if (PyErr_Occurred()) SWIG_fail;
13766 }
13767 {
13768 #if wxUSE_UNICODE
13769 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13770 #else
13771 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13772 #endif
13773 }
13774 {
13775 if (temp2)
13776 delete arg2;
13777 }
13778 return resultobj;
13779 fail:
13780 {
13781 if (temp2)
13782 delete arg2;
13783 }
13784 return NULL;
13785 }
13786
13787
13788 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13789 PyObject *resultobj = 0;
13790 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13791 wxString result;
13792 void *argp1 = 0 ;
13793 int res1 = 0 ;
13794 PyObject *swig_obj[1] ;
13795
13796 if (!args) SWIG_fail;
13797 swig_obj[0] = args;
13798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13799 if (!SWIG_IsOK(res1)) {
13800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13801 }
13802 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13803 {
13804 PyThreadState* __tstate = wxPyBeginAllowThreads();
13805 result = (arg1)->FindNext();
13806 wxPyEndAllowThreads(__tstate);
13807 if (PyErr_Occurred()) SWIG_fail;
13808 }
13809 {
13810 #if wxUSE_UNICODE
13811 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13812 #else
13813 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13814 #endif
13815 }
13816 return resultobj;
13817 fail:
13818 return NULL;
13819 }
13820
13821
13822 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13823 PyObject *obj;
13824 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13825 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13826 return SWIG_Py_Void();
13827 }
13828
13829 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13830 return SWIG_Python_InitShadowInstance(args);
13831 }
13832
13833 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13834 PyObject *resultobj = 0;
13835 wxString *arg1 = 0 ;
13836 wxImage *arg2 = 0 ;
13837 long arg3 ;
13838 bool temp1 = false ;
13839 void *argp2 = 0 ;
13840 int res2 = 0 ;
13841 long val3 ;
13842 int ecode3 = 0 ;
13843 PyObject * obj0 = 0 ;
13844 PyObject * obj1 = 0 ;
13845 PyObject * obj2 = 0 ;
13846 char * kwnames[] = {
13847 (char *) "filename",(char *) "image",(char *) "type", NULL
13848 };
13849
13850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13851 {
13852 arg1 = wxString_in_helper(obj0);
13853 if (arg1 == NULL) SWIG_fail;
13854 temp1 = true;
13855 }
13856 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13857 if (!SWIG_IsOK(res2)) {
13858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13859 }
13860 if (!argp2) {
13861 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13862 }
13863 arg2 = reinterpret_cast< wxImage * >(argp2);
13864 ecode3 = SWIG_AsVal_long(obj2, &val3);
13865 if (!SWIG_IsOK(ecode3)) {
13866 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13867 }
13868 arg3 = static_cast< long >(val3);
13869 {
13870 PyThreadState* __tstate = wxPyBeginAllowThreads();
13871 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13872 wxPyEndAllowThreads(__tstate);
13873 if (PyErr_Occurred()) SWIG_fail;
13874 }
13875 resultobj = SWIG_Py_Void();
13876 {
13877 if (temp1)
13878 delete arg1;
13879 }
13880 return resultobj;
13881 fail:
13882 {
13883 if (temp1)
13884 delete arg1;
13885 }
13886 return NULL;
13887 }
13888
13889
13890 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13891 PyObject *resultobj = 0;
13892 wxString *arg1 = 0 ;
13893 wxBitmap *arg2 = 0 ;
13894 long arg3 ;
13895 bool temp1 = false ;
13896 void *argp2 = 0 ;
13897 int res2 = 0 ;
13898 long val3 ;
13899 int ecode3 = 0 ;
13900 PyObject * obj0 = 0 ;
13901 PyObject * obj1 = 0 ;
13902 PyObject * obj2 = 0 ;
13903 char * kwnames[] = {
13904 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13905 };
13906
13907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13908 {
13909 arg1 = wxString_in_helper(obj0);
13910 if (arg1 == NULL) SWIG_fail;
13911 temp1 = true;
13912 }
13913 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13914 if (!SWIG_IsOK(res2)) {
13915 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13916 }
13917 if (!argp2) {
13918 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13919 }
13920 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13921 ecode3 = SWIG_AsVal_long(obj2, &val3);
13922 if (!SWIG_IsOK(ecode3)) {
13923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13924 }
13925 arg3 = static_cast< long >(val3);
13926 {
13927 PyThreadState* __tstate = wxPyBeginAllowThreads();
13928 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
13929 wxPyEndAllowThreads(__tstate);
13930 if (PyErr_Occurred()) SWIG_fail;
13931 }
13932 resultobj = SWIG_Py_Void();
13933 {
13934 if (temp1)
13935 delete arg1;
13936 }
13937 return resultobj;
13938 fail:
13939 {
13940 if (temp1)
13941 delete arg1;
13942 }
13943 return NULL;
13944 }
13945
13946
13947 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13948 PyObject *resultobj = 0;
13949 wxString *arg1 = 0 ;
13950 PyObject *arg2 = (PyObject *) 0 ;
13951 bool temp1 = false ;
13952 PyObject * obj0 = 0 ;
13953 PyObject * obj1 = 0 ;
13954 char * kwnames[] = {
13955 (char *) "filename",(char *) "data", NULL
13956 };
13957
13958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
13959 {
13960 arg1 = wxString_in_helper(obj0);
13961 if (arg1 == NULL) SWIG_fail;
13962 temp1 = true;
13963 }
13964 arg2 = obj1;
13965 {
13966 PyThreadState* __tstate = wxPyBeginAllowThreads();
13967 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
13968 wxPyEndAllowThreads(__tstate);
13969 if (PyErr_Occurred()) SWIG_fail;
13970 }
13971 resultobj = SWIG_Py_Void();
13972 {
13973 if (temp1)
13974 delete arg1;
13975 }
13976 return resultobj;
13977 fail:
13978 {
13979 if (temp1)
13980 delete arg1;
13981 }
13982 return NULL;
13983 }
13984
13985
13986 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13987 PyObject *resultobj = 0;
13988 wxMemoryFSHandler *result = 0 ;
13989
13990 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
13991 {
13992 PyThreadState* __tstate = wxPyBeginAllowThreads();
13993 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
13994 wxPyEndAllowThreads(__tstate);
13995 if (PyErr_Occurred()) SWIG_fail;
13996 }
13997 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
13998 return resultobj;
13999 fail:
14000 return NULL;
14001 }
14002
14003
14004 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14005 PyObject *resultobj = 0;
14006 wxString *arg1 = 0 ;
14007 bool temp1 = false ;
14008 PyObject * obj0 = 0 ;
14009 char * kwnames[] = {
14010 (char *) "filename", NULL
14011 };
14012
14013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14014 {
14015 arg1 = wxString_in_helper(obj0);
14016 if (arg1 == NULL) SWIG_fail;
14017 temp1 = true;
14018 }
14019 {
14020 PyThreadState* __tstate = wxPyBeginAllowThreads();
14021 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14022 wxPyEndAllowThreads(__tstate);
14023 if (PyErr_Occurred()) SWIG_fail;
14024 }
14025 resultobj = SWIG_Py_Void();
14026 {
14027 if (temp1)
14028 delete arg1;
14029 }
14030 return resultobj;
14031 fail:
14032 {
14033 if (temp1)
14034 delete arg1;
14035 }
14036 return NULL;
14037 }
14038
14039
14040 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14041 PyObject *resultobj = 0;
14042 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14043 wxString *arg2 = 0 ;
14044 bool result;
14045 void *argp1 = 0 ;
14046 int res1 = 0 ;
14047 bool temp2 = false ;
14048 PyObject * obj0 = 0 ;
14049 PyObject * obj1 = 0 ;
14050 char * kwnames[] = {
14051 (char *) "self",(char *) "location", NULL
14052 };
14053
14054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14056 if (!SWIG_IsOK(res1)) {
14057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14058 }
14059 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14060 {
14061 arg2 = wxString_in_helper(obj1);
14062 if (arg2 == NULL) SWIG_fail;
14063 temp2 = true;
14064 }
14065 {
14066 PyThreadState* __tstate = wxPyBeginAllowThreads();
14067 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14068 wxPyEndAllowThreads(__tstate);
14069 if (PyErr_Occurred()) SWIG_fail;
14070 }
14071 {
14072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14073 }
14074 {
14075 if (temp2)
14076 delete arg2;
14077 }
14078 return resultobj;
14079 fail:
14080 {
14081 if (temp2)
14082 delete arg2;
14083 }
14084 return NULL;
14085 }
14086
14087
14088 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14089 PyObject *resultobj = 0;
14090 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14091 wxFileSystem *arg2 = 0 ;
14092 wxString *arg3 = 0 ;
14093 wxFSFile *result = 0 ;
14094 void *argp1 = 0 ;
14095 int res1 = 0 ;
14096 void *argp2 = 0 ;
14097 int res2 = 0 ;
14098 bool temp3 = false ;
14099 PyObject * obj0 = 0 ;
14100 PyObject * obj1 = 0 ;
14101 PyObject * obj2 = 0 ;
14102 char * kwnames[] = {
14103 (char *) "self",(char *) "fs",(char *) "location", NULL
14104 };
14105
14106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14108 if (!SWIG_IsOK(res1)) {
14109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14110 }
14111 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14112 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14113 if (!SWIG_IsOK(res2)) {
14114 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14115 }
14116 if (!argp2) {
14117 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14118 }
14119 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14120 {
14121 arg3 = wxString_in_helper(obj2);
14122 if (arg3 == NULL) SWIG_fail;
14123 temp3 = true;
14124 }
14125 {
14126 PyThreadState* __tstate = wxPyBeginAllowThreads();
14127 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14128 wxPyEndAllowThreads(__tstate);
14129 if (PyErr_Occurred()) SWIG_fail;
14130 }
14131 {
14132 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14133 }
14134 {
14135 if (temp3)
14136 delete arg3;
14137 }
14138 return resultobj;
14139 fail:
14140 {
14141 if (temp3)
14142 delete arg3;
14143 }
14144 return NULL;
14145 }
14146
14147
14148 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14149 PyObject *resultobj = 0;
14150 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14151 wxString *arg2 = 0 ;
14152 int arg3 = (int) 0 ;
14153 wxString result;
14154 void *argp1 = 0 ;
14155 int res1 = 0 ;
14156 bool temp2 = false ;
14157 int val3 ;
14158 int ecode3 = 0 ;
14159 PyObject * obj0 = 0 ;
14160 PyObject * obj1 = 0 ;
14161 PyObject * obj2 = 0 ;
14162 char * kwnames[] = {
14163 (char *) "self",(char *) "spec",(char *) "flags", NULL
14164 };
14165
14166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14168 if (!SWIG_IsOK(res1)) {
14169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14170 }
14171 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14172 {
14173 arg2 = wxString_in_helper(obj1);
14174 if (arg2 == NULL) SWIG_fail;
14175 temp2 = true;
14176 }
14177 if (obj2) {
14178 ecode3 = SWIG_AsVal_int(obj2, &val3);
14179 if (!SWIG_IsOK(ecode3)) {
14180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14181 }
14182 arg3 = static_cast< int >(val3);
14183 }
14184 {
14185 PyThreadState* __tstate = wxPyBeginAllowThreads();
14186 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14187 wxPyEndAllowThreads(__tstate);
14188 if (PyErr_Occurred()) SWIG_fail;
14189 }
14190 {
14191 #if wxUSE_UNICODE
14192 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14193 #else
14194 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14195 #endif
14196 }
14197 {
14198 if (temp2)
14199 delete arg2;
14200 }
14201 return resultobj;
14202 fail:
14203 {
14204 if (temp2)
14205 delete arg2;
14206 }
14207 return NULL;
14208 }
14209
14210
14211 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14212 PyObject *resultobj = 0;
14213 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14214 wxString result;
14215 void *argp1 = 0 ;
14216 int res1 = 0 ;
14217 PyObject *swig_obj[1] ;
14218
14219 if (!args) SWIG_fail;
14220 swig_obj[0] = args;
14221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14222 if (!SWIG_IsOK(res1)) {
14223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14224 }
14225 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14226 {
14227 PyThreadState* __tstate = wxPyBeginAllowThreads();
14228 result = (arg1)->FindNext();
14229 wxPyEndAllowThreads(__tstate);
14230 if (PyErr_Occurred()) SWIG_fail;
14231 }
14232 {
14233 #if wxUSE_UNICODE
14234 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14235 #else
14236 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14237 #endif
14238 }
14239 return resultobj;
14240 fail:
14241 return NULL;
14242 }
14243
14244
14245 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14246 PyObject *obj;
14247 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14248 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14249 return SWIG_Py_Void();
14250 }
14251
14252 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14253 return SWIG_Python_InitShadowInstance(args);
14254 }
14255
14256 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14257 PyObject *resultobj = 0;
14258 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14259 wxString result;
14260 void *argp1 = 0 ;
14261 int res1 = 0 ;
14262 PyObject *swig_obj[1] ;
14263
14264 if (!args) SWIG_fail;
14265 swig_obj[0] = args;
14266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14267 if (!SWIG_IsOK(res1)) {
14268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14269 }
14270 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14271 {
14272 PyThreadState* __tstate = wxPyBeginAllowThreads();
14273 result = (arg1)->GetName();
14274 wxPyEndAllowThreads(__tstate);
14275 if (PyErr_Occurred()) SWIG_fail;
14276 }
14277 {
14278 #if wxUSE_UNICODE
14279 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14280 #else
14281 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14282 #endif
14283 }
14284 return resultobj;
14285 fail:
14286 return NULL;
14287 }
14288
14289
14290 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14291 PyObject *resultobj = 0;
14292 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14293 wxString result;
14294 void *argp1 = 0 ;
14295 int res1 = 0 ;
14296 PyObject *swig_obj[1] ;
14297
14298 if (!args) SWIG_fail;
14299 swig_obj[0] = args;
14300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14301 if (!SWIG_IsOK(res1)) {
14302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14303 }
14304 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14305 {
14306 PyThreadState* __tstate = wxPyBeginAllowThreads();
14307 result = (arg1)->GetExtension();
14308 wxPyEndAllowThreads(__tstate);
14309 if (PyErr_Occurred()) SWIG_fail;
14310 }
14311 {
14312 #if wxUSE_UNICODE
14313 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14314 #else
14315 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14316 #endif
14317 }
14318 return resultobj;
14319 fail:
14320 return NULL;
14321 }
14322
14323
14324 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14325 PyObject *resultobj = 0;
14326 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14327 long result;
14328 void *argp1 = 0 ;
14329 int res1 = 0 ;
14330 PyObject *swig_obj[1] ;
14331
14332 if (!args) SWIG_fail;
14333 swig_obj[0] = args;
14334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14335 if (!SWIG_IsOK(res1)) {
14336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14337 }
14338 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14339 {
14340 PyThreadState* __tstate = wxPyBeginAllowThreads();
14341 result = (long)(arg1)->GetType();
14342 wxPyEndAllowThreads(__tstate);
14343 if (PyErr_Occurred()) SWIG_fail;
14344 }
14345 resultobj = SWIG_From_long(static_cast< long >(result));
14346 return resultobj;
14347 fail:
14348 return NULL;
14349 }
14350
14351
14352 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14353 PyObject *resultobj = 0;
14354 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14355 wxString result;
14356 void *argp1 = 0 ;
14357 int res1 = 0 ;
14358 PyObject *swig_obj[1] ;
14359
14360 if (!args) SWIG_fail;
14361 swig_obj[0] = args;
14362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14363 if (!SWIG_IsOK(res1)) {
14364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14365 }
14366 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14367 {
14368 PyThreadState* __tstate = wxPyBeginAllowThreads();
14369 result = (arg1)->GetMimeType();
14370 wxPyEndAllowThreads(__tstate);
14371 if (PyErr_Occurred()) SWIG_fail;
14372 }
14373 {
14374 #if wxUSE_UNICODE
14375 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14376 #else
14377 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14378 #endif
14379 }
14380 return resultobj;
14381 fail:
14382 return NULL;
14383 }
14384
14385
14386 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14387 PyObject *resultobj = 0;
14388 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14389 wxString *arg2 = 0 ;
14390 bool result;
14391 void *argp1 = 0 ;
14392 int res1 = 0 ;
14393 bool temp2 = false ;
14394 PyObject * obj0 = 0 ;
14395 PyObject * obj1 = 0 ;
14396 char * kwnames[] = {
14397 (char *) "self",(char *) "name", NULL
14398 };
14399
14400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14402 if (!SWIG_IsOK(res1)) {
14403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14404 }
14405 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14406 {
14407 arg2 = wxString_in_helper(obj1);
14408 if (arg2 == NULL) SWIG_fail;
14409 temp2 = true;
14410 }
14411 {
14412 PyThreadState* __tstate = wxPyBeginAllowThreads();
14413 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14414 wxPyEndAllowThreads(__tstate);
14415 if (PyErr_Occurred()) SWIG_fail;
14416 }
14417 {
14418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14419 }
14420 {
14421 if (temp2)
14422 delete arg2;
14423 }
14424 return resultobj;
14425 fail:
14426 {
14427 if (temp2)
14428 delete arg2;
14429 }
14430 return NULL;
14431 }
14432
14433
14434 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14435 PyObject *resultobj = 0;
14436 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14437 wxInputStream *arg2 = 0 ;
14438 bool result;
14439 void *argp1 = 0 ;
14440 int res1 = 0 ;
14441 wxPyInputStream *temp2 ;
14442 bool created2 ;
14443 PyObject * obj0 = 0 ;
14444 PyObject * obj1 = 0 ;
14445 char * kwnames[] = {
14446 (char *) "self",(char *) "stream", NULL
14447 };
14448
14449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14451 if (!SWIG_IsOK(res1)) {
14452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14453 }
14454 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14455 {
14456 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14457 arg2 = temp2->m_wxis;
14458 created2 = false;
14459 } else {
14460 PyErr_Clear(); // clear the failure of the wxPyConvert above
14461 arg2 = wxPyCBInputStream_create(obj1, false);
14462 if (arg2 == NULL) {
14463 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14464 SWIG_fail;
14465 }
14466 created2 = true;
14467 }
14468 }
14469 {
14470 PyThreadState* __tstate = wxPyBeginAllowThreads();
14471 result = (bool)(arg1)->CanRead(*arg2);
14472 wxPyEndAllowThreads(__tstate);
14473 if (PyErr_Occurred()) SWIG_fail;
14474 }
14475 {
14476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14477 }
14478 {
14479 if (created2) delete arg2;
14480 }
14481 return resultobj;
14482 fail:
14483 {
14484 if (created2) delete arg2;
14485 }
14486 return NULL;
14487 }
14488
14489
14490 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14491 PyObject *resultobj = 0;
14492 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14493 wxString *arg2 = 0 ;
14494 void *argp1 = 0 ;
14495 int res1 = 0 ;
14496 bool temp2 = false ;
14497 PyObject * obj0 = 0 ;
14498 PyObject * obj1 = 0 ;
14499 char * kwnames[] = {
14500 (char *) "self",(char *) "name", NULL
14501 };
14502
14503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14505 if (!SWIG_IsOK(res1)) {
14506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14507 }
14508 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14509 {
14510 arg2 = wxString_in_helper(obj1);
14511 if (arg2 == NULL) SWIG_fail;
14512 temp2 = true;
14513 }
14514 {
14515 PyThreadState* __tstate = wxPyBeginAllowThreads();
14516 (arg1)->SetName((wxString const &)*arg2);
14517 wxPyEndAllowThreads(__tstate);
14518 if (PyErr_Occurred()) SWIG_fail;
14519 }
14520 resultobj = SWIG_Py_Void();
14521 {
14522 if (temp2)
14523 delete arg2;
14524 }
14525 return resultobj;
14526 fail:
14527 {
14528 if (temp2)
14529 delete arg2;
14530 }
14531 return NULL;
14532 }
14533
14534
14535 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14536 PyObject *resultobj = 0;
14537 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14538 wxString *arg2 = 0 ;
14539 void *argp1 = 0 ;
14540 int res1 = 0 ;
14541 bool temp2 = false ;
14542 PyObject * obj0 = 0 ;
14543 PyObject * obj1 = 0 ;
14544 char * kwnames[] = {
14545 (char *) "self",(char *) "extension", NULL
14546 };
14547
14548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",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_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14552 }
14553 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14554 {
14555 arg2 = wxString_in_helper(obj1);
14556 if (arg2 == NULL) SWIG_fail;
14557 temp2 = true;
14558 }
14559 {
14560 PyThreadState* __tstate = wxPyBeginAllowThreads();
14561 (arg1)->SetExtension((wxString const &)*arg2);
14562 wxPyEndAllowThreads(__tstate);
14563 if (PyErr_Occurred()) SWIG_fail;
14564 }
14565 resultobj = SWIG_Py_Void();
14566 {
14567 if (temp2)
14568 delete arg2;
14569 }
14570 return resultobj;
14571 fail:
14572 {
14573 if (temp2)
14574 delete arg2;
14575 }
14576 return NULL;
14577 }
14578
14579
14580 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14581 PyObject *resultobj = 0;
14582 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14583 long arg2 ;
14584 void *argp1 = 0 ;
14585 int res1 = 0 ;
14586 long val2 ;
14587 int ecode2 = 0 ;
14588 PyObject * obj0 = 0 ;
14589 PyObject * obj1 = 0 ;
14590 char * kwnames[] = {
14591 (char *) "self",(char *) "type", NULL
14592 };
14593
14594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14596 if (!SWIG_IsOK(res1)) {
14597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14598 }
14599 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14600 ecode2 = SWIG_AsVal_long(obj1, &val2);
14601 if (!SWIG_IsOK(ecode2)) {
14602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14603 }
14604 arg2 = static_cast< long >(val2);
14605 {
14606 PyThreadState* __tstate = wxPyBeginAllowThreads();
14607 (arg1)->SetType(arg2);
14608 wxPyEndAllowThreads(__tstate);
14609 if (PyErr_Occurred()) SWIG_fail;
14610 }
14611 resultobj = SWIG_Py_Void();
14612 return resultobj;
14613 fail:
14614 return NULL;
14615 }
14616
14617
14618 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14619 PyObject *resultobj = 0;
14620 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14621 wxString *arg2 = 0 ;
14622 void *argp1 = 0 ;
14623 int res1 = 0 ;
14624 bool temp2 = false ;
14625 PyObject * obj0 = 0 ;
14626 PyObject * obj1 = 0 ;
14627 char * kwnames[] = {
14628 (char *) "self",(char *) "mimetype", NULL
14629 };
14630
14631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14633 if (!SWIG_IsOK(res1)) {
14634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14635 }
14636 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14637 {
14638 arg2 = wxString_in_helper(obj1);
14639 if (arg2 == NULL) SWIG_fail;
14640 temp2 = true;
14641 }
14642 {
14643 PyThreadState* __tstate = wxPyBeginAllowThreads();
14644 (arg1)->SetMimeType((wxString const &)*arg2);
14645 wxPyEndAllowThreads(__tstate);
14646 if (PyErr_Occurred()) SWIG_fail;
14647 }
14648 resultobj = SWIG_Py_Void();
14649 {
14650 if (temp2)
14651 delete arg2;
14652 }
14653 return resultobj;
14654 fail:
14655 {
14656 if (temp2)
14657 delete arg2;
14658 }
14659 return NULL;
14660 }
14661
14662
14663 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14664 PyObject *obj;
14665 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14666 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14667 return SWIG_Py_Void();
14668 }
14669
14670 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14671 PyObject *resultobj = 0;
14672 wxPyImageHandler *result = 0 ;
14673
14674 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14675 {
14676 PyThreadState* __tstate = wxPyBeginAllowThreads();
14677 result = (wxPyImageHandler *)new wxPyImageHandler();
14678 wxPyEndAllowThreads(__tstate);
14679 if (PyErr_Occurred()) SWIG_fail;
14680 }
14681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14682 return resultobj;
14683 fail:
14684 return NULL;
14685 }
14686
14687
14688 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14689 PyObject *resultobj = 0;
14690 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14691 PyObject *arg2 = (PyObject *) 0 ;
14692 void *argp1 = 0 ;
14693 int res1 = 0 ;
14694 PyObject * obj0 = 0 ;
14695 PyObject * obj1 = 0 ;
14696 char * kwnames[] = {
14697 (char *) "self",(char *) "self", NULL
14698 };
14699
14700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14702 if (!SWIG_IsOK(res1)) {
14703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14704 }
14705 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14706 arg2 = obj1;
14707 {
14708 PyThreadState* __tstate = wxPyBeginAllowThreads();
14709 (arg1)->_SetSelf(arg2);
14710 wxPyEndAllowThreads(__tstate);
14711 if (PyErr_Occurred()) SWIG_fail;
14712 }
14713 resultobj = SWIG_Py_Void();
14714 return resultobj;
14715 fail:
14716 return NULL;
14717 }
14718
14719
14720 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14721 PyObject *obj;
14722 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14723 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14724 return SWIG_Py_Void();
14725 }
14726
14727 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14728 return SWIG_Python_InitShadowInstance(args);
14729 }
14730
14731 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14732 PyObject *resultobj = 0;
14733 wxImageHistogram *result = 0 ;
14734
14735 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14736 {
14737 PyThreadState* __tstate = wxPyBeginAllowThreads();
14738 result = (wxImageHistogram *)new wxImageHistogram();
14739 wxPyEndAllowThreads(__tstate);
14740 if (PyErr_Occurred()) SWIG_fail;
14741 }
14742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14743 return resultobj;
14744 fail:
14745 return NULL;
14746 }
14747
14748
14749 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14750 PyObject *resultobj = 0;
14751 byte arg1 ;
14752 byte arg2 ;
14753 byte arg3 ;
14754 unsigned long result;
14755 unsigned char val1 ;
14756 int ecode1 = 0 ;
14757 unsigned char val2 ;
14758 int ecode2 = 0 ;
14759 unsigned char val3 ;
14760 int ecode3 = 0 ;
14761 PyObject * obj0 = 0 ;
14762 PyObject * obj1 = 0 ;
14763 PyObject * obj2 = 0 ;
14764 char * kwnames[] = {
14765 (char *) "r",(char *) "g",(char *) "b", NULL
14766 };
14767
14768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14769 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14770 if (!SWIG_IsOK(ecode1)) {
14771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14772 }
14773 arg1 = static_cast< byte >(val1);
14774 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14775 if (!SWIG_IsOK(ecode2)) {
14776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14777 }
14778 arg2 = static_cast< byte >(val2);
14779 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14780 if (!SWIG_IsOK(ecode3)) {
14781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14782 }
14783 arg3 = static_cast< byte >(val3);
14784 {
14785 PyThreadState* __tstate = wxPyBeginAllowThreads();
14786 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14787 wxPyEndAllowThreads(__tstate);
14788 if (PyErr_Occurred()) SWIG_fail;
14789 }
14790 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14791 return resultobj;
14792 fail:
14793 return NULL;
14794 }
14795
14796
14797 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14798 PyObject *resultobj = 0;
14799 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14800 byte *arg2 = (byte *) 0 ;
14801 byte *arg3 = (byte *) 0 ;
14802 byte *arg4 = (byte *) 0 ;
14803 byte arg5 = (byte) 1 ;
14804 byte arg6 = (byte) 0 ;
14805 byte arg7 = (byte) 0 ;
14806 bool result;
14807 void *argp1 = 0 ;
14808 int res1 = 0 ;
14809 byte temp2 ;
14810 int res2 = SWIG_TMPOBJ ;
14811 byte temp3 ;
14812 int res3 = SWIG_TMPOBJ ;
14813 byte temp4 ;
14814 int res4 = SWIG_TMPOBJ ;
14815 unsigned char val5 ;
14816 int ecode5 = 0 ;
14817 unsigned char val6 ;
14818 int ecode6 = 0 ;
14819 unsigned char val7 ;
14820 int ecode7 = 0 ;
14821 PyObject * obj0 = 0 ;
14822 PyObject * obj1 = 0 ;
14823 PyObject * obj2 = 0 ;
14824 PyObject * obj3 = 0 ;
14825 char * kwnames[] = {
14826 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14827 };
14828
14829 arg2 = &temp2;
14830 arg3 = &temp3;
14831 arg4 = &temp4;
14832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14834 if (!SWIG_IsOK(res1)) {
14835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14836 }
14837 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14838 if (obj1) {
14839 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14840 if (!SWIG_IsOK(ecode5)) {
14841 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14842 }
14843 arg5 = static_cast< byte >(val5);
14844 }
14845 if (obj2) {
14846 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14847 if (!SWIG_IsOK(ecode6)) {
14848 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14849 }
14850 arg6 = static_cast< byte >(val6);
14851 }
14852 if (obj3) {
14853 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14854 if (!SWIG_IsOK(ecode7)) {
14855 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14856 }
14857 arg7 = static_cast< byte >(val7);
14858 }
14859 {
14860 PyThreadState* __tstate = wxPyBeginAllowThreads();
14861 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14862 wxPyEndAllowThreads(__tstate);
14863 if (PyErr_Occurred()) SWIG_fail;
14864 }
14865 {
14866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14867 }
14868 if (SWIG_IsTmpObj(res2)) {
14869 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14870 } else {
14871 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14872 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14873 }
14874 if (SWIG_IsTmpObj(res3)) {
14875 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14876 } else {
14877 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14878 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14879 }
14880 if (SWIG_IsTmpObj(res4)) {
14881 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14882 } else {
14883 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14884 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14885 }
14886 return resultobj;
14887 fail:
14888 return NULL;
14889 }
14890
14891
14892 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14893 PyObject *resultobj = 0;
14894 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14895 unsigned long arg2 ;
14896 unsigned long result;
14897 void *argp1 = 0 ;
14898 int res1 = 0 ;
14899 unsigned long val2 ;
14900 int ecode2 = 0 ;
14901 PyObject * obj0 = 0 ;
14902 PyObject * obj1 = 0 ;
14903 char * kwnames[] = {
14904 (char *) "self",(char *) "key", NULL
14905 };
14906
14907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14909 if (!SWIG_IsOK(res1)) {
14910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14911 }
14912 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14913 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14914 if (!SWIG_IsOK(ecode2)) {
14915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14916 }
14917 arg2 = static_cast< unsigned long >(val2);
14918 {
14919 PyThreadState* __tstate = wxPyBeginAllowThreads();
14920 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14921 wxPyEndAllowThreads(__tstate);
14922 if (PyErr_Occurred()) SWIG_fail;
14923 }
14924 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14925 return resultobj;
14926 fail:
14927 return NULL;
14928 }
14929
14930
14931 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14932 PyObject *resultobj = 0;
14933 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14934 byte arg2 ;
14935 byte arg3 ;
14936 byte arg4 ;
14937 unsigned long result;
14938 void *argp1 = 0 ;
14939 int res1 = 0 ;
14940 unsigned char val2 ;
14941 int ecode2 = 0 ;
14942 unsigned char val3 ;
14943 int ecode3 = 0 ;
14944 unsigned char val4 ;
14945 int ecode4 = 0 ;
14946 PyObject * obj0 = 0 ;
14947 PyObject * obj1 = 0 ;
14948 PyObject * obj2 = 0 ;
14949 PyObject * obj3 = 0 ;
14950 char * kwnames[] = {
14951 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14952 };
14953
14954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14956 if (!SWIG_IsOK(res1)) {
14957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14958 }
14959 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14960 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14961 if (!SWIG_IsOK(ecode2)) {
14962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
14963 }
14964 arg2 = static_cast< byte >(val2);
14965 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14966 if (!SWIG_IsOK(ecode3)) {
14967 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
14968 }
14969 arg3 = static_cast< byte >(val3);
14970 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14971 if (!SWIG_IsOK(ecode4)) {
14972 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
14973 }
14974 arg4 = static_cast< byte >(val4);
14975 {
14976 PyThreadState* __tstate = wxPyBeginAllowThreads();
14977 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
14978 wxPyEndAllowThreads(__tstate);
14979 if (PyErr_Occurred()) SWIG_fail;
14980 }
14981 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14982 return resultobj;
14983 fail:
14984 return NULL;
14985 }
14986
14987
14988 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14989 PyObject *resultobj = 0;
14990 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14991 wxColour *arg2 = 0 ;
14992 unsigned long result;
14993 void *argp1 = 0 ;
14994 int res1 = 0 ;
14995 wxColour temp2 ;
14996 PyObject * obj0 = 0 ;
14997 PyObject * obj1 = 0 ;
14998 char * kwnames[] = {
14999 (char *) "self",(char *) "colour", NULL
15000 };
15001
15002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
15003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15004 if (!SWIG_IsOK(res1)) {
15005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15006 }
15007 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15008 {
15009 arg2 = &temp2;
15010 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15011 }
15012 {
15013 PyThreadState* __tstate = wxPyBeginAllowThreads();
15014 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15015 wxPyEndAllowThreads(__tstate);
15016 if (PyErr_Occurred()) SWIG_fail;
15017 }
15018 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15019 return resultobj;
15020 fail:
15021 return NULL;
15022 }
15023
15024
15025 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15026 PyObject *obj;
15027 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15028 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15029 return SWIG_Py_Void();
15030 }
15031
15032 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15033 return SWIG_Python_InitShadowInstance(args);
15034 }
15035
15036 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15037 PyObject *resultobj = 0;
15038 byte arg1 = (byte) 0 ;
15039 byte arg2 = (byte) 0 ;
15040 byte arg3 = (byte) 0 ;
15041 wxImage_RGBValue *result = 0 ;
15042 unsigned char val1 ;
15043 int ecode1 = 0 ;
15044 unsigned char val2 ;
15045 int ecode2 = 0 ;
15046 unsigned char val3 ;
15047 int ecode3 = 0 ;
15048 PyObject * obj0 = 0 ;
15049 PyObject * obj1 = 0 ;
15050 PyObject * obj2 = 0 ;
15051 char * kwnames[] = {
15052 (char *) "r",(char *) "g",(char *) "b", NULL
15053 };
15054
15055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15056 if (obj0) {
15057 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15058 if (!SWIG_IsOK(ecode1)) {
15059 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15060 }
15061 arg1 = static_cast< byte >(val1);
15062 }
15063 if (obj1) {
15064 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15065 if (!SWIG_IsOK(ecode2)) {
15066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15067 }
15068 arg2 = static_cast< byte >(val2);
15069 }
15070 if (obj2) {
15071 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15072 if (!SWIG_IsOK(ecode3)) {
15073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15074 }
15075 arg3 = static_cast< byte >(val3);
15076 }
15077 {
15078 PyThreadState* __tstate = wxPyBeginAllowThreads();
15079 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15080 wxPyEndAllowThreads(__tstate);
15081 if (PyErr_Occurred()) SWIG_fail;
15082 }
15083 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15084 return resultobj;
15085 fail:
15086 return NULL;
15087 }
15088
15089
15090 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15091 PyObject *resultobj = 0;
15092 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15093 byte arg2 ;
15094 void *argp1 = 0 ;
15095 int res1 = 0 ;
15096 unsigned char val2 ;
15097 int ecode2 = 0 ;
15098 PyObject *swig_obj[2] ;
15099
15100 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15102 if (!SWIG_IsOK(res1)) {
15103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15104 }
15105 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15106 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15107 if (!SWIG_IsOK(ecode2)) {
15108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15109 }
15110 arg2 = static_cast< byte >(val2);
15111 if (arg1) (arg1)->red = arg2;
15112
15113 resultobj = SWIG_Py_Void();
15114 return resultobj;
15115 fail:
15116 return NULL;
15117 }
15118
15119
15120 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15121 PyObject *resultobj = 0;
15122 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15123 byte result;
15124 void *argp1 = 0 ;
15125 int res1 = 0 ;
15126 PyObject *swig_obj[1] ;
15127
15128 if (!args) SWIG_fail;
15129 swig_obj[0] = args;
15130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15131 if (!SWIG_IsOK(res1)) {
15132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15133 }
15134 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15135 result = (byte) ((arg1)->red);
15136 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15137 return resultobj;
15138 fail:
15139 return NULL;
15140 }
15141
15142
15143 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15144 PyObject *resultobj = 0;
15145 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15146 byte arg2 ;
15147 void *argp1 = 0 ;
15148 int res1 = 0 ;
15149 unsigned char val2 ;
15150 int ecode2 = 0 ;
15151 PyObject *swig_obj[2] ;
15152
15153 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15155 if (!SWIG_IsOK(res1)) {
15156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15157 }
15158 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15159 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15160 if (!SWIG_IsOK(ecode2)) {
15161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15162 }
15163 arg2 = static_cast< byte >(val2);
15164 if (arg1) (arg1)->green = arg2;
15165
15166 resultobj = SWIG_Py_Void();
15167 return resultobj;
15168 fail:
15169 return NULL;
15170 }
15171
15172
15173 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15174 PyObject *resultobj = 0;
15175 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15176 byte result;
15177 void *argp1 = 0 ;
15178 int res1 = 0 ;
15179 PyObject *swig_obj[1] ;
15180
15181 if (!args) SWIG_fail;
15182 swig_obj[0] = args;
15183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15184 if (!SWIG_IsOK(res1)) {
15185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15186 }
15187 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15188 result = (byte) ((arg1)->green);
15189 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15190 return resultobj;
15191 fail:
15192 return NULL;
15193 }
15194
15195
15196 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15197 PyObject *resultobj = 0;
15198 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15199 byte arg2 ;
15200 void *argp1 = 0 ;
15201 int res1 = 0 ;
15202 unsigned char val2 ;
15203 int ecode2 = 0 ;
15204 PyObject *swig_obj[2] ;
15205
15206 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15208 if (!SWIG_IsOK(res1)) {
15209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15210 }
15211 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15212 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15213 if (!SWIG_IsOK(ecode2)) {
15214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15215 }
15216 arg2 = static_cast< byte >(val2);
15217 if (arg1) (arg1)->blue = arg2;
15218
15219 resultobj = SWIG_Py_Void();
15220 return resultobj;
15221 fail:
15222 return NULL;
15223 }
15224
15225
15226 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15227 PyObject *resultobj = 0;
15228 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15229 byte result;
15230 void *argp1 = 0 ;
15231 int res1 = 0 ;
15232 PyObject *swig_obj[1] ;
15233
15234 if (!args) SWIG_fail;
15235 swig_obj[0] = args;
15236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15237 if (!SWIG_IsOK(res1)) {
15238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15239 }
15240 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15241 result = (byte) ((arg1)->blue);
15242 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15243 return resultobj;
15244 fail:
15245 return NULL;
15246 }
15247
15248
15249 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15250 PyObject *obj;
15251 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15252 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15253 return SWIG_Py_Void();
15254 }
15255
15256 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15257 return SWIG_Python_InitShadowInstance(args);
15258 }
15259
15260 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15261 PyObject *resultobj = 0;
15262 double arg1 = (double) 0.0 ;
15263 double arg2 = (double) 0.0 ;
15264 double arg3 = (double) 0.0 ;
15265 wxImage_HSVValue *result = 0 ;
15266 double val1 ;
15267 int ecode1 = 0 ;
15268 double val2 ;
15269 int ecode2 = 0 ;
15270 double val3 ;
15271 int ecode3 = 0 ;
15272 PyObject * obj0 = 0 ;
15273 PyObject * obj1 = 0 ;
15274 PyObject * obj2 = 0 ;
15275 char * kwnames[] = {
15276 (char *) "h",(char *) "s",(char *) "v", NULL
15277 };
15278
15279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15280 if (obj0) {
15281 ecode1 = SWIG_AsVal_double(obj0, &val1);
15282 if (!SWIG_IsOK(ecode1)) {
15283 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15284 }
15285 arg1 = static_cast< double >(val1);
15286 }
15287 if (obj1) {
15288 ecode2 = SWIG_AsVal_double(obj1, &val2);
15289 if (!SWIG_IsOK(ecode2)) {
15290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15291 }
15292 arg2 = static_cast< double >(val2);
15293 }
15294 if (obj2) {
15295 ecode3 = SWIG_AsVal_double(obj2, &val3);
15296 if (!SWIG_IsOK(ecode3)) {
15297 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15298 }
15299 arg3 = static_cast< double >(val3);
15300 }
15301 {
15302 PyThreadState* __tstate = wxPyBeginAllowThreads();
15303 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15304 wxPyEndAllowThreads(__tstate);
15305 if (PyErr_Occurred()) SWIG_fail;
15306 }
15307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15308 return resultobj;
15309 fail:
15310 return NULL;
15311 }
15312
15313
15314 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15315 PyObject *resultobj = 0;
15316 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15317 double arg2 ;
15318 void *argp1 = 0 ;
15319 int res1 = 0 ;
15320 double val2 ;
15321 int ecode2 = 0 ;
15322 PyObject *swig_obj[2] ;
15323
15324 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15326 if (!SWIG_IsOK(res1)) {
15327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15328 }
15329 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15330 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15331 if (!SWIG_IsOK(ecode2)) {
15332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15333 }
15334 arg2 = static_cast< double >(val2);
15335 if (arg1) (arg1)->hue = arg2;
15336
15337 resultobj = SWIG_Py_Void();
15338 return resultobj;
15339 fail:
15340 return NULL;
15341 }
15342
15343
15344 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15345 PyObject *resultobj = 0;
15346 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15347 double result;
15348 void *argp1 = 0 ;
15349 int res1 = 0 ;
15350 PyObject *swig_obj[1] ;
15351
15352 if (!args) SWIG_fail;
15353 swig_obj[0] = args;
15354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15355 if (!SWIG_IsOK(res1)) {
15356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15357 }
15358 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15359 result = (double) ((arg1)->hue);
15360 resultobj = SWIG_From_double(static_cast< double >(result));
15361 return resultobj;
15362 fail:
15363 return NULL;
15364 }
15365
15366
15367 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15368 PyObject *resultobj = 0;
15369 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15370 double arg2 ;
15371 void *argp1 = 0 ;
15372 int res1 = 0 ;
15373 double val2 ;
15374 int ecode2 = 0 ;
15375 PyObject *swig_obj[2] ;
15376
15377 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15379 if (!SWIG_IsOK(res1)) {
15380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15381 }
15382 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15383 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15384 if (!SWIG_IsOK(ecode2)) {
15385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15386 }
15387 arg2 = static_cast< double >(val2);
15388 if (arg1) (arg1)->saturation = arg2;
15389
15390 resultobj = SWIG_Py_Void();
15391 return resultobj;
15392 fail:
15393 return NULL;
15394 }
15395
15396
15397 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15398 PyObject *resultobj = 0;
15399 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15400 double result;
15401 void *argp1 = 0 ;
15402 int res1 = 0 ;
15403 PyObject *swig_obj[1] ;
15404
15405 if (!args) SWIG_fail;
15406 swig_obj[0] = args;
15407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15408 if (!SWIG_IsOK(res1)) {
15409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15410 }
15411 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15412 result = (double) ((arg1)->saturation);
15413 resultobj = SWIG_From_double(static_cast< double >(result));
15414 return resultobj;
15415 fail:
15416 return NULL;
15417 }
15418
15419
15420 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15421 PyObject *resultobj = 0;
15422 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15423 double arg2 ;
15424 void *argp1 = 0 ;
15425 int res1 = 0 ;
15426 double val2 ;
15427 int ecode2 = 0 ;
15428 PyObject *swig_obj[2] ;
15429
15430 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15432 if (!SWIG_IsOK(res1)) {
15433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15434 }
15435 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15436 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15437 if (!SWIG_IsOK(ecode2)) {
15438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15439 }
15440 arg2 = static_cast< double >(val2);
15441 if (arg1) (arg1)->value = arg2;
15442
15443 resultobj = SWIG_Py_Void();
15444 return resultobj;
15445 fail:
15446 return NULL;
15447 }
15448
15449
15450 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15451 PyObject *resultobj = 0;
15452 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15453 double result;
15454 void *argp1 = 0 ;
15455 int res1 = 0 ;
15456 PyObject *swig_obj[1] ;
15457
15458 if (!args) SWIG_fail;
15459 swig_obj[0] = args;
15460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15461 if (!SWIG_IsOK(res1)) {
15462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15463 }
15464 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15465 result = (double) ((arg1)->value);
15466 resultobj = SWIG_From_double(static_cast< double >(result));
15467 return resultobj;
15468 fail:
15469 return NULL;
15470 }
15471
15472
15473 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15474 PyObject *obj;
15475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15476 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15477 return SWIG_Py_Void();
15478 }
15479
15480 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15481 return SWIG_Python_InitShadowInstance(args);
15482 }
15483
15484 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15485 PyObject *resultobj = 0;
15486 wxString *arg1 = 0 ;
15487 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15488 int arg3 = (int) -1 ;
15489 wxImage *result = 0 ;
15490 bool temp1 = false ;
15491 long val2 ;
15492 int ecode2 = 0 ;
15493 int val3 ;
15494 int ecode3 = 0 ;
15495 PyObject * obj0 = 0 ;
15496 PyObject * obj1 = 0 ;
15497 PyObject * obj2 = 0 ;
15498 char * kwnames[] = {
15499 (char *) "name",(char *) "type",(char *) "index", NULL
15500 };
15501
15502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15503 {
15504 arg1 = wxString_in_helper(obj0);
15505 if (arg1 == NULL) SWIG_fail;
15506 temp1 = true;
15507 }
15508 if (obj1) {
15509 ecode2 = SWIG_AsVal_long(obj1, &val2);
15510 if (!SWIG_IsOK(ecode2)) {
15511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15512 }
15513 arg2 = static_cast< long >(val2);
15514 }
15515 if (obj2) {
15516 ecode3 = SWIG_AsVal_int(obj2, &val3);
15517 if (!SWIG_IsOK(ecode3)) {
15518 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15519 }
15520 arg3 = static_cast< int >(val3);
15521 }
15522 {
15523 PyThreadState* __tstate = wxPyBeginAllowThreads();
15524 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15525 wxPyEndAllowThreads(__tstate);
15526 if (PyErr_Occurred()) SWIG_fail;
15527 }
15528 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15529 {
15530 if (temp1)
15531 delete arg1;
15532 }
15533 return resultobj;
15534 fail:
15535 {
15536 if (temp1)
15537 delete arg1;
15538 }
15539 return NULL;
15540 }
15541
15542
15543 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15544 PyObject *resultobj = 0;
15545 wxImage *arg1 = (wxImage *) 0 ;
15546 void *argp1 = 0 ;
15547 int res1 = 0 ;
15548 PyObject *swig_obj[1] ;
15549
15550 if (!args) SWIG_fail;
15551 swig_obj[0] = args;
15552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15553 if (!SWIG_IsOK(res1)) {
15554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15555 }
15556 arg1 = reinterpret_cast< wxImage * >(argp1);
15557 {
15558 PyThreadState* __tstate = wxPyBeginAllowThreads();
15559 delete arg1;
15560
15561 wxPyEndAllowThreads(__tstate);
15562 if (PyErr_Occurred()) SWIG_fail;
15563 }
15564 resultobj = SWIG_Py_Void();
15565 return resultobj;
15566 fail:
15567 return NULL;
15568 }
15569
15570
15571 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15572 PyObject *resultobj = 0;
15573 wxString *arg1 = 0 ;
15574 wxString *arg2 = 0 ;
15575 int arg3 = (int) -1 ;
15576 wxImage *result = 0 ;
15577 bool temp1 = false ;
15578 bool temp2 = false ;
15579 int val3 ;
15580 int ecode3 = 0 ;
15581 PyObject * obj0 = 0 ;
15582 PyObject * obj1 = 0 ;
15583 PyObject * obj2 = 0 ;
15584 char * kwnames[] = {
15585 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15586 };
15587
15588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15589 {
15590 arg1 = wxString_in_helper(obj0);
15591 if (arg1 == NULL) SWIG_fail;
15592 temp1 = true;
15593 }
15594 {
15595 arg2 = wxString_in_helper(obj1);
15596 if (arg2 == NULL) SWIG_fail;
15597 temp2 = true;
15598 }
15599 if (obj2) {
15600 ecode3 = SWIG_AsVal_int(obj2, &val3);
15601 if (!SWIG_IsOK(ecode3)) {
15602 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15603 }
15604 arg3 = static_cast< int >(val3);
15605 }
15606 {
15607 PyThreadState* __tstate = wxPyBeginAllowThreads();
15608 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15609 wxPyEndAllowThreads(__tstate);
15610 if (PyErr_Occurred()) SWIG_fail;
15611 }
15612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15613 {
15614 if (temp1)
15615 delete arg1;
15616 }
15617 {
15618 if (temp2)
15619 delete arg2;
15620 }
15621 return resultobj;
15622 fail:
15623 {
15624 if (temp1)
15625 delete arg1;
15626 }
15627 {
15628 if (temp2)
15629 delete arg2;
15630 }
15631 return NULL;
15632 }
15633
15634
15635 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15636 PyObject *resultobj = 0;
15637 wxInputStream *arg1 = 0 ;
15638 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15639 int arg3 = (int) -1 ;
15640 wxImage *result = 0 ;
15641 wxPyInputStream *temp1 ;
15642 bool created1 ;
15643 long val2 ;
15644 int ecode2 = 0 ;
15645 int val3 ;
15646 int ecode3 = 0 ;
15647 PyObject * obj0 = 0 ;
15648 PyObject * obj1 = 0 ;
15649 PyObject * obj2 = 0 ;
15650 char * kwnames[] = {
15651 (char *) "stream",(char *) "type",(char *) "index", NULL
15652 };
15653
15654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15655 {
15656 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15657 arg1 = temp1->m_wxis;
15658 created1 = false;
15659 } else {
15660 PyErr_Clear(); // clear the failure of the wxPyConvert above
15661 arg1 = wxPyCBInputStream_create(obj0, false);
15662 if (arg1 == NULL) {
15663 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15664 SWIG_fail;
15665 }
15666 created1 = true;
15667 }
15668 }
15669 if (obj1) {
15670 ecode2 = SWIG_AsVal_long(obj1, &val2);
15671 if (!SWIG_IsOK(ecode2)) {
15672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15673 }
15674 arg2 = static_cast< long >(val2);
15675 }
15676 if (obj2) {
15677 ecode3 = SWIG_AsVal_int(obj2, &val3);
15678 if (!SWIG_IsOK(ecode3)) {
15679 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15680 }
15681 arg3 = static_cast< int >(val3);
15682 }
15683 {
15684 PyThreadState* __tstate = wxPyBeginAllowThreads();
15685 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15686 wxPyEndAllowThreads(__tstate);
15687 if (PyErr_Occurred()) SWIG_fail;
15688 }
15689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15690 {
15691 if (created1) delete arg1;
15692 }
15693 return resultobj;
15694 fail:
15695 {
15696 if (created1) delete arg1;
15697 }
15698 return NULL;
15699 }
15700
15701
15702 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15703 PyObject *resultobj = 0;
15704 wxInputStream *arg1 = 0 ;
15705 wxString *arg2 = 0 ;
15706 int arg3 = (int) -1 ;
15707 wxImage *result = 0 ;
15708 wxPyInputStream *temp1 ;
15709 bool created1 ;
15710 bool temp2 = false ;
15711 int val3 ;
15712 int ecode3 = 0 ;
15713 PyObject * obj0 = 0 ;
15714 PyObject * obj1 = 0 ;
15715 PyObject * obj2 = 0 ;
15716 char * kwnames[] = {
15717 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15718 };
15719
15720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15721 {
15722 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15723 arg1 = temp1->m_wxis;
15724 created1 = false;
15725 } else {
15726 PyErr_Clear(); // clear the failure of the wxPyConvert above
15727 arg1 = wxPyCBInputStream_create(obj0, false);
15728 if (arg1 == NULL) {
15729 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15730 SWIG_fail;
15731 }
15732 created1 = true;
15733 }
15734 }
15735 {
15736 arg2 = wxString_in_helper(obj1);
15737 if (arg2 == NULL) SWIG_fail;
15738 temp2 = true;
15739 }
15740 if (obj2) {
15741 ecode3 = SWIG_AsVal_int(obj2, &val3);
15742 if (!SWIG_IsOK(ecode3)) {
15743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15744 }
15745 arg3 = static_cast< int >(val3);
15746 }
15747 {
15748 PyThreadState* __tstate = wxPyBeginAllowThreads();
15749 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15750 wxPyEndAllowThreads(__tstate);
15751 if (PyErr_Occurred()) SWIG_fail;
15752 }
15753 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15754 {
15755 if (created1) delete arg1;
15756 }
15757 {
15758 if (temp2)
15759 delete arg2;
15760 }
15761 return resultobj;
15762 fail:
15763 {
15764 if (created1) delete arg1;
15765 }
15766 {
15767 if (temp2)
15768 delete arg2;
15769 }
15770 return NULL;
15771 }
15772
15773
15774 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15775 PyObject *resultobj = 0;
15776 int arg1 = (int) 0 ;
15777 int arg2 = (int) 0 ;
15778 bool arg3 = (bool) true ;
15779 wxImage *result = 0 ;
15780 int val1 ;
15781 int ecode1 = 0 ;
15782 int val2 ;
15783 int ecode2 = 0 ;
15784 bool val3 ;
15785 int ecode3 = 0 ;
15786 PyObject * obj0 = 0 ;
15787 PyObject * obj1 = 0 ;
15788 PyObject * obj2 = 0 ;
15789 char * kwnames[] = {
15790 (char *) "width",(char *) "height",(char *) "clear", NULL
15791 };
15792
15793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15794 if (obj0) {
15795 ecode1 = SWIG_AsVal_int(obj0, &val1);
15796 if (!SWIG_IsOK(ecode1)) {
15797 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15798 }
15799 arg1 = static_cast< int >(val1);
15800 }
15801 if (obj1) {
15802 ecode2 = SWIG_AsVal_int(obj1, &val2);
15803 if (!SWIG_IsOK(ecode2)) {
15804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15805 }
15806 arg2 = static_cast< int >(val2);
15807 }
15808 if (obj2) {
15809 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15810 if (!SWIG_IsOK(ecode3)) {
15811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15812 }
15813 arg3 = static_cast< bool >(val3);
15814 }
15815 {
15816 PyThreadState* __tstate = wxPyBeginAllowThreads();
15817 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15818 wxPyEndAllowThreads(__tstate);
15819 if (PyErr_Occurred()) SWIG_fail;
15820 }
15821 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15822 return resultobj;
15823 fail:
15824 return NULL;
15825 }
15826
15827
15828 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15829 PyObject *resultobj = 0;
15830 wxBitmap *arg1 = 0 ;
15831 wxImage *result = 0 ;
15832 void *argp1 = 0 ;
15833 int res1 = 0 ;
15834 PyObject * obj0 = 0 ;
15835 char * kwnames[] = {
15836 (char *) "bitmap", NULL
15837 };
15838
15839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15840 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15841 if (!SWIG_IsOK(res1)) {
15842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15843 }
15844 if (!argp1) {
15845 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15846 }
15847 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15848 {
15849 if (!wxPyCheckForApp()) SWIG_fail;
15850 PyThreadState* __tstate = wxPyBeginAllowThreads();
15851 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15852 wxPyEndAllowThreads(__tstate);
15853 if (PyErr_Occurred()) SWIG_fail;
15854 }
15855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15856 return resultobj;
15857 fail:
15858 return NULL;
15859 }
15860
15861
15862 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15863 PyObject *resultobj = 0;
15864 int arg1 ;
15865 int arg2 ;
15866 buffer arg3 ;
15867 int arg4 ;
15868 wxImage *result = 0 ;
15869 int val1 ;
15870 int ecode1 = 0 ;
15871 int val2 ;
15872 int ecode2 = 0 ;
15873 Py_ssize_t temp3 ;
15874 PyObject * obj0 = 0 ;
15875 PyObject * obj1 = 0 ;
15876 PyObject * obj2 = 0 ;
15877 char * kwnames[] = {
15878 (char *) "width",(char *) "height",(char *) "data", NULL
15879 };
15880
15881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15882 ecode1 = SWIG_AsVal_int(obj0, &val1);
15883 if (!SWIG_IsOK(ecode1)) {
15884 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15885 }
15886 arg1 = static_cast< int >(val1);
15887 ecode2 = SWIG_AsVal_int(obj1, &val2);
15888 if (!SWIG_IsOK(ecode2)) {
15889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15890 }
15891 arg2 = static_cast< int >(val2);
15892 {
15893 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15894 arg4 = (int)temp3;
15895 }
15896 {
15897 PyThreadState* __tstate = wxPyBeginAllowThreads();
15898 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
15899 wxPyEndAllowThreads(__tstate);
15900 if (PyErr_Occurred()) SWIG_fail;
15901 }
15902 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15903 return resultobj;
15904 fail:
15905 return NULL;
15906 }
15907
15908
15909 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15910 PyObject *resultobj = 0;
15911 int arg1 ;
15912 int arg2 ;
15913 buffer arg3 ;
15914 int arg4 ;
15915 buffer arg5 ;
15916 int arg6 ;
15917 wxImage *result = 0 ;
15918 int val1 ;
15919 int ecode1 = 0 ;
15920 int val2 ;
15921 int ecode2 = 0 ;
15922 Py_ssize_t temp3 ;
15923 Py_ssize_t temp5 ;
15924 PyObject * obj0 = 0 ;
15925 PyObject * obj1 = 0 ;
15926 PyObject * obj2 = 0 ;
15927 PyObject * obj3 = 0 ;
15928 char * kwnames[] = {
15929 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
15930 };
15931
15932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15933 ecode1 = SWIG_AsVal_int(obj0, &val1);
15934 if (!SWIG_IsOK(ecode1)) {
15935 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
15936 }
15937 arg1 = static_cast< int >(val1);
15938 ecode2 = SWIG_AsVal_int(obj1, &val2);
15939 if (!SWIG_IsOK(ecode2)) {
15940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
15941 }
15942 arg2 = static_cast< int >(val2);
15943 {
15944 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15945 arg4 = (int)temp3;
15946 }
15947 {
15948 if (obj3 != Py_None) {
15949 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
15950 arg6 = (int)temp5;
15951 }
15952 }
15953 {
15954 PyThreadState* __tstate = wxPyBeginAllowThreads();
15955 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
15956 wxPyEndAllowThreads(__tstate);
15957 if (PyErr_Occurred()) SWIG_fail;
15958 }
15959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15960 return resultobj;
15961 fail:
15962 return NULL;
15963 }
15964
15965
15966 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15967 PyObject *resultobj = 0;
15968 wxImage *arg1 = (wxImage *) 0 ;
15969 int arg2 ;
15970 int arg3 ;
15971 bool arg4 = (bool) true ;
15972 void *argp1 = 0 ;
15973 int res1 = 0 ;
15974 int val2 ;
15975 int ecode2 = 0 ;
15976 int val3 ;
15977 int ecode3 = 0 ;
15978 bool val4 ;
15979 int ecode4 = 0 ;
15980 PyObject * obj0 = 0 ;
15981 PyObject * obj1 = 0 ;
15982 PyObject * obj2 = 0 ;
15983 PyObject * obj3 = 0 ;
15984 char * kwnames[] = {
15985 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
15986 };
15987
15988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15990 if (!SWIG_IsOK(res1)) {
15991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
15992 }
15993 arg1 = reinterpret_cast< wxImage * >(argp1);
15994 ecode2 = SWIG_AsVal_int(obj1, &val2);
15995 if (!SWIG_IsOK(ecode2)) {
15996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
15997 }
15998 arg2 = static_cast< int >(val2);
15999 ecode3 = SWIG_AsVal_int(obj2, &val3);
16000 if (!SWIG_IsOK(ecode3)) {
16001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
16002 }
16003 arg3 = static_cast< int >(val3);
16004 if (obj3) {
16005 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16006 if (!SWIG_IsOK(ecode4)) {
16007 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
16008 }
16009 arg4 = static_cast< bool >(val4);
16010 }
16011 {
16012 PyThreadState* __tstate = wxPyBeginAllowThreads();
16013 (arg1)->Create(arg2,arg3,arg4);
16014 wxPyEndAllowThreads(__tstate);
16015 if (PyErr_Occurred()) SWIG_fail;
16016 }
16017 resultobj = SWIG_Py_Void();
16018 return resultobj;
16019 fail:
16020 return NULL;
16021 }
16022
16023
16024 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16025 PyObject *resultobj = 0;
16026 wxImage *arg1 = (wxImage *) 0 ;
16027 void *argp1 = 0 ;
16028 int res1 = 0 ;
16029 PyObject *swig_obj[1] ;
16030
16031 if (!args) SWIG_fail;
16032 swig_obj[0] = args;
16033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16034 if (!SWIG_IsOK(res1)) {
16035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16036 }
16037 arg1 = reinterpret_cast< wxImage * >(argp1);
16038 {
16039 PyThreadState* __tstate = wxPyBeginAllowThreads();
16040 (arg1)->Destroy();
16041 wxPyEndAllowThreads(__tstate);
16042 if (PyErr_Occurred()) SWIG_fail;
16043 }
16044 resultobj = SWIG_Py_Void();
16045 return resultobj;
16046 fail:
16047 return NULL;
16048 }
16049
16050
16051 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16052 PyObject *resultobj = 0;
16053 wxImage *arg1 = (wxImage *) 0 ;
16054 int arg2 ;
16055 int arg3 ;
16056 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16057 SwigValueWrapper<wxImage > result;
16058 void *argp1 = 0 ;
16059 int res1 = 0 ;
16060 int val2 ;
16061 int ecode2 = 0 ;
16062 int val3 ;
16063 int ecode3 = 0 ;
16064 int val4 ;
16065 int ecode4 = 0 ;
16066 PyObject * obj0 = 0 ;
16067 PyObject * obj1 = 0 ;
16068 PyObject * obj2 = 0 ;
16069 PyObject * obj3 = 0 ;
16070 char * kwnames[] = {
16071 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16072 };
16073
16074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16076 if (!SWIG_IsOK(res1)) {
16077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16078 }
16079 arg1 = reinterpret_cast< wxImage * >(argp1);
16080 ecode2 = SWIG_AsVal_int(obj1, &val2);
16081 if (!SWIG_IsOK(ecode2)) {
16082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16083 }
16084 arg2 = static_cast< int >(val2);
16085 ecode3 = SWIG_AsVal_int(obj2, &val3);
16086 if (!SWIG_IsOK(ecode3)) {
16087 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16088 }
16089 arg3 = static_cast< int >(val3);
16090 if (obj3) {
16091 ecode4 = SWIG_AsVal_int(obj3, &val4);
16092 if (!SWIG_IsOK(ecode4)) {
16093 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16094 }
16095 arg4 = static_cast< int >(val4);
16096 }
16097 {
16098 PyThreadState* __tstate = wxPyBeginAllowThreads();
16099 result = (arg1)->Scale(arg2,arg3,arg4);
16100 wxPyEndAllowThreads(__tstate);
16101 if (PyErr_Occurred()) SWIG_fail;
16102 }
16103 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16104 return resultobj;
16105 fail:
16106 return NULL;
16107 }
16108
16109
16110 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16111 PyObject *resultobj = 0;
16112 wxImage *arg1 = (wxImage *) 0 ;
16113 int arg2 ;
16114 int arg3 ;
16115 SwigValueWrapper<wxImage > result;
16116 void *argp1 = 0 ;
16117 int res1 = 0 ;
16118 int val2 ;
16119 int ecode2 = 0 ;
16120 int val3 ;
16121 int ecode3 = 0 ;
16122 PyObject * obj0 = 0 ;
16123 PyObject * obj1 = 0 ;
16124 PyObject * obj2 = 0 ;
16125 char * kwnames[] = {
16126 (char *) "self",(char *) "width",(char *) "height", NULL
16127 };
16128
16129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16131 if (!SWIG_IsOK(res1)) {
16132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16133 }
16134 arg1 = reinterpret_cast< wxImage * >(argp1);
16135 ecode2 = SWIG_AsVal_int(obj1, &val2);
16136 if (!SWIG_IsOK(ecode2)) {
16137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16138 }
16139 arg2 = static_cast< int >(val2);
16140 ecode3 = SWIG_AsVal_int(obj2, &val3);
16141 if (!SWIG_IsOK(ecode3)) {
16142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16143 }
16144 arg3 = static_cast< int >(val3);
16145 {
16146 PyThreadState* __tstate = wxPyBeginAllowThreads();
16147 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16148 wxPyEndAllowThreads(__tstate);
16149 if (PyErr_Occurred()) SWIG_fail;
16150 }
16151 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16152 return resultobj;
16153 fail:
16154 return NULL;
16155 }
16156
16157
16158 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16159 PyObject *resultobj = 0;
16160 wxImage *arg1 = (wxImage *) 0 ;
16161 int arg2 ;
16162 int arg3 ;
16163 SwigValueWrapper<wxImage > result;
16164 void *argp1 = 0 ;
16165 int res1 = 0 ;
16166 int val2 ;
16167 int ecode2 = 0 ;
16168 int val3 ;
16169 int ecode3 = 0 ;
16170 PyObject * obj0 = 0 ;
16171 PyObject * obj1 = 0 ;
16172 PyObject * obj2 = 0 ;
16173 char * kwnames[] = {
16174 (char *) "self",(char *) "width",(char *) "height", NULL
16175 };
16176
16177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16179 if (!SWIG_IsOK(res1)) {
16180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16181 }
16182 arg1 = reinterpret_cast< wxImage * >(argp1);
16183 ecode2 = SWIG_AsVal_int(obj1, &val2);
16184 if (!SWIG_IsOK(ecode2)) {
16185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16186 }
16187 arg2 = static_cast< int >(val2);
16188 ecode3 = SWIG_AsVal_int(obj2, &val3);
16189 if (!SWIG_IsOK(ecode3)) {
16190 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16191 }
16192 arg3 = static_cast< int >(val3);
16193 {
16194 PyThreadState* __tstate = wxPyBeginAllowThreads();
16195 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16196 wxPyEndAllowThreads(__tstate);
16197 if (PyErr_Occurred()) SWIG_fail;
16198 }
16199 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16200 return resultobj;
16201 fail:
16202 return NULL;
16203 }
16204
16205
16206 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16207 PyObject *resultobj = 0;
16208 wxImage *arg1 = (wxImage *) 0 ;
16209 int arg2 ;
16210 SwigValueWrapper<wxImage > result;
16211 void *argp1 = 0 ;
16212 int res1 = 0 ;
16213 int val2 ;
16214 int ecode2 = 0 ;
16215 PyObject * obj0 = 0 ;
16216 PyObject * obj1 = 0 ;
16217 char * kwnames[] = {
16218 (char *) "self",(char *) "radius", NULL
16219 };
16220
16221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16223 if (!SWIG_IsOK(res1)) {
16224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16225 }
16226 arg1 = reinterpret_cast< wxImage * >(argp1);
16227 ecode2 = SWIG_AsVal_int(obj1, &val2);
16228 if (!SWIG_IsOK(ecode2)) {
16229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16230 }
16231 arg2 = static_cast< int >(val2);
16232 {
16233 PyThreadState* __tstate = wxPyBeginAllowThreads();
16234 result = (arg1)->Blur(arg2);
16235 wxPyEndAllowThreads(__tstate);
16236 if (PyErr_Occurred()) SWIG_fail;
16237 }
16238 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16239 return resultobj;
16240 fail:
16241 return NULL;
16242 }
16243
16244
16245 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16246 PyObject *resultobj = 0;
16247 wxImage *arg1 = (wxImage *) 0 ;
16248 int arg2 ;
16249 SwigValueWrapper<wxImage > result;
16250 void *argp1 = 0 ;
16251 int res1 = 0 ;
16252 int val2 ;
16253 int ecode2 = 0 ;
16254 PyObject * obj0 = 0 ;
16255 PyObject * obj1 = 0 ;
16256 char * kwnames[] = {
16257 (char *) "self",(char *) "radius", NULL
16258 };
16259
16260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16262 if (!SWIG_IsOK(res1)) {
16263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16264 }
16265 arg1 = reinterpret_cast< wxImage * >(argp1);
16266 ecode2 = SWIG_AsVal_int(obj1, &val2);
16267 if (!SWIG_IsOK(ecode2)) {
16268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16269 }
16270 arg2 = static_cast< int >(val2);
16271 {
16272 PyThreadState* __tstate = wxPyBeginAllowThreads();
16273 result = (arg1)->BlurHorizontal(arg2);
16274 wxPyEndAllowThreads(__tstate);
16275 if (PyErr_Occurred()) SWIG_fail;
16276 }
16277 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16278 return resultobj;
16279 fail:
16280 return NULL;
16281 }
16282
16283
16284 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16285 PyObject *resultobj = 0;
16286 wxImage *arg1 = (wxImage *) 0 ;
16287 int arg2 ;
16288 SwigValueWrapper<wxImage > result;
16289 void *argp1 = 0 ;
16290 int res1 = 0 ;
16291 int val2 ;
16292 int ecode2 = 0 ;
16293 PyObject * obj0 = 0 ;
16294 PyObject * obj1 = 0 ;
16295 char * kwnames[] = {
16296 (char *) "self",(char *) "radius", NULL
16297 };
16298
16299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16301 if (!SWIG_IsOK(res1)) {
16302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16303 }
16304 arg1 = reinterpret_cast< wxImage * >(argp1);
16305 ecode2 = SWIG_AsVal_int(obj1, &val2);
16306 if (!SWIG_IsOK(ecode2)) {
16307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16308 }
16309 arg2 = static_cast< int >(val2);
16310 {
16311 PyThreadState* __tstate = wxPyBeginAllowThreads();
16312 result = (arg1)->BlurVertical(arg2);
16313 wxPyEndAllowThreads(__tstate);
16314 if (PyErr_Occurred()) SWIG_fail;
16315 }
16316 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16317 return resultobj;
16318 fail:
16319 return NULL;
16320 }
16321
16322
16323 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16324 PyObject *resultobj = 0;
16325 wxImage *arg1 = (wxImage *) 0 ;
16326 int arg2 ;
16327 int arg3 ;
16328 SwigValueWrapper<wxImage > result;
16329 void *argp1 = 0 ;
16330 int res1 = 0 ;
16331 int val2 ;
16332 int ecode2 = 0 ;
16333 int val3 ;
16334 int ecode3 = 0 ;
16335 PyObject * obj0 = 0 ;
16336 PyObject * obj1 = 0 ;
16337 PyObject * obj2 = 0 ;
16338 char * kwnames[] = {
16339 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16340 };
16341
16342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16344 if (!SWIG_IsOK(res1)) {
16345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16346 }
16347 arg1 = reinterpret_cast< wxImage * >(argp1);
16348 ecode2 = SWIG_AsVal_int(obj1, &val2);
16349 if (!SWIG_IsOK(ecode2)) {
16350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16351 }
16352 arg2 = static_cast< int >(val2);
16353 ecode3 = SWIG_AsVal_int(obj2, &val3);
16354 if (!SWIG_IsOK(ecode3)) {
16355 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16356 }
16357 arg3 = static_cast< int >(val3);
16358 {
16359 PyThreadState* __tstate = wxPyBeginAllowThreads();
16360 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16361 wxPyEndAllowThreads(__tstate);
16362 if (PyErr_Occurred()) SWIG_fail;
16363 }
16364 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16365 return resultobj;
16366 fail:
16367 return NULL;
16368 }
16369
16370
16371 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16372 PyObject *resultobj = 0;
16373 wxImage *arg1 = (wxImage *) 0 ;
16374 int arg2 ;
16375 int arg3 ;
16376 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16377 wxImage *result = 0 ;
16378 void *argp1 = 0 ;
16379 int res1 = 0 ;
16380 int val2 ;
16381 int ecode2 = 0 ;
16382 int val3 ;
16383 int ecode3 = 0 ;
16384 int val4 ;
16385 int ecode4 = 0 ;
16386 PyObject * obj0 = 0 ;
16387 PyObject * obj1 = 0 ;
16388 PyObject * obj2 = 0 ;
16389 PyObject * obj3 = 0 ;
16390 char * kwnames[] = {
16391 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16392 };
16393
16394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16396 if (!SWIG_IsOK(res1)) {
16397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16398 }
16399 arg1 = reinterpret_cast< wxImage * >(argp1);
16400 ecode2 = SWIG_AsVal_int(obj1, &val2);
16401 if (!SWIG_IsOK(ecode2)) {
16402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16403 }
16404 arg2 = static_cast< int >(val2);
16405 ecode3 = SWIG_AsVal_int(obj2, &val3);
16406 if (!SWIG_IsOK(ecode3)) {
16407 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16408 }
16409 arg3 = static_cast< int >(val3);
16410 if (obj3) {
16411 ecode4 = SWIG_AsVal_int(obj3, &val4);
16412 if (!SWIG_IsOK(ecode4)) {
16413 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16414 }
16415 arg4 = static_cast< int >(val4);
16416 }
16417 {
16418 PyThreadState* __tstate = wxPyBeginAllowThreads();
16419 {
16420 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
16421 result = (wxImage *) &_result_ref;
16422 }
16423 wxPyEndAllowThreads(__tstate);
16424 if (PyErr_Occurred()) SWIG_fail;
16425 }
16426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16427 return resultobj;
16428 fail:
16429 return NULL;
16430 }
16431
16432
16433 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16434 PyObject *resultobj = 0;
16435 wxImage *arg1 = (wxImage *) 0 ;
16436 wxSize *arg2 = 0 ;
16437 wxPoint *arg3 = 0 ;
16438 int arg4 = (int) -1 ;
16439 int arg5 = (int) -1 ;
16440 int arg6 = (int) -1 ;
16441 wxImage *result = 0 ;
16442 void *argp1 = 0 ;
16443 int res1 = 0 ;
16444 wxSize temp2 ;
16445 wxPoint temp3 ;
16446 int val4 ;
16447 int ecode4 = 0 ;
16448 int val5 ;
16449 int ecode5 = 0 ;
16450 int val6 ;
16451 int ecode6 = 0 ;
16452 PyObject * obj0 = 0 ;
16453 PyObject * obj1 = 0 ;
16454 PyObject * obj2 = 0 ;
16455 PyObject * obj3 = 0 ;
16456 PyObject * obj4 = 0 ;
16457 PyObject * obj5 = 0 ;
16458 char * kwnames[] = {
16459 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16460 };
16461
16462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16464 if (!SWIG_IsOK(res1)) {
16465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16466 }
16467 arg1 = reinterpret_cast< wxImage * >(argp1);
16468 {
16469 arg2 = &temp2;
16470 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16471 }
16472 {
16473 arg3 = &temp3;
16474 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16475 }
16476 if (obj3) {
16477 ecode4 = SWIG_AsVal_int(obj3, &val4);
16478 if (!SWIG_IsOK(ecode4)) {
16479 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16480 }
16481 arg4 = static_cast< int >(val4);
16482 }
16483 if (obj4) {
16484 ecode5 = SWIG_AsVal_int(obj4, &val5);
16485 if (!SWIG_IsOK(ecode5)) {
16486 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16487 }
16488 arg5 = static_cast< int >(val5);
16489 }
16490 if (obj5) {
16491 ecode6 = SWIG_AsVal_int(obj5, &val6);
16492 if (!SWIG_IsOK(ecode6)) {
16493 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16494 }
16495 arg6 = static_cast< int >(val6);
16496 }
16497 {
16498 PyThreadState* __tstate = wxPyBeginAllowThreads();
16499 {
16500 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16501 result = (wxImage *) &_result_ref;
16502 }
16503 wxPyEndAllowThreads(__tstate);
16504 if (PyErr_Occurred()) SWIG_fail;
16505 }
16506 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16507 return resultobj;
16508 fail:
16509 return NULL;
16510 }
16511
16512
16513 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16514 PyObject *resultobj = 0;
16515 wxImage *arg1 = (wxImage *) 0 ;
16516 int arg2 ;
16517 int arg3 ;
16518 byte arg4 ;
16519 byte arg5 ;
16520 byte arg6 ;
16521 void *argp1 = 0 ;
16522 int res1 = 0 ;
16523 int val2 ;
16524 int ecode2 = 0 ;
16525 int val3 ;
16526 int ecode3 = 0 ;
16527 unsigned char val4 ;
16528 int ecode4 = 0 ;
16529 unsigned char val5 ;
16530 int ecode5 = 0 ;
16531 unsigned char val6 ;
16532 int ecode6 = 0 ;
16533 PyObject * obj0 = 0 ;
16534 PyObject * obj1 = 0 ;
16535 PyObject * obj2 = 0 ;
16536 PyObject * obj3 = 0 ;
16537 PyObject * obj4 = 0 ;
16538 PyObject * obj5 = 0 ;
16539 char * kwnames[] = {
16540 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16541 };
16542
16543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16545 if (!SWIG_IsOK(res1)) {
16546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16547 }
16548 arg1 = reinterpret_cast< wxImage * >(argp1);
16549 ecode2 = SWIG_AsVal_int(obj1, &val2);
16550 if (!SWIG_IsOK(ecode2)) {
16551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16552 }
16553 arg2 = static_cast< int >(val2);
16554 ecode3 = SWIG_AsVal_int(obj2, &val3);
16555 if (!SWIG_IsOK(ecode3)) {
16556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16557 }
16558 arg3 = static_cast< int >(val3);
16559 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16560 if (!SWIG_IsOK(ecode4)) {
16561 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16562 }
16563 arg4 = static_cast< byte >(val4);
16564 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16565 if (!SWIG_IsOK(ecode5)) {
16566 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16567 }
16568 arg5 = static_cast< byte >(val5);
16569 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16570 if (!SWIG_IsOK(ecode6)) {
16571 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16572 }
16573 arg6 = static_cast< byte >(val6);
16574 {
16575 PyThreadState* __tstate = wxPyBeginAllowThreads();
16576 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16577 wxPyEndAllowThreads(__tstate);
16578 if (PyErr_Occurred()) SWIG_fail;
16579 }
16580 resultobj = SWIG_Py_Void();
16581 return resultobj;
16582 fail:
16583 return NULL;
16584 }
16585
16586
16587 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16588 PyObject *resultobj = 0;
16589 wxImage *arg1 = (wxImage *) 0 ;
16590 wxRect *arg2 = 0 ;
16591 byte arg3 ;
16592 byte arg4 ;
16593 byte arg5 ;
16594 void *argp1 = 0 ;
16595 int res1 = 0 ;
16596 wxRect temp2 ;
16597 unsigned char val3 ;
16598 int ecode3 = 0 ;
16599 unsigned char val4 ;
16600 int ecode4 = 0 ;
16601 unsigned char val5 ;
16602 int ecode5 = 0 ;
16603 PyObject * obj0 = 0 ;
16604 PyObject * obj1 = 0 ;
16605 PyObject * obj2 = 0 ;
16606 PyObject * obj3 = 0 ;
16607 PyObject * obj4 = 0 ;
16608 char * kwnames[] = {
16609 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16610 };
16611
16612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16614 if (!SWIG_IsOK(res1)) {
16615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16616 }
16617 arg1 = reinterpret_cast< wxImage * >(argp1);
16618 {
16619 arg2 = &temp2;
16620 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16621 }
16622 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16623 if (!SWIG_IsOK(ecode3)) {
16624 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16625 }
16626 arg3 = static_cast< byte >(val3);
16627 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16628 if (!SWIG_IsOK(ecode4)) {
16629 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16630 }
16631 arg4 = static_cast< byte >(val4);
16632 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16633 if (!SWIG_IsOK(ecode5)) {
16634 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16635 }
16636 arg5 = static_cast< byte >(val5);
16637 {
16638 PyThreadState* __tstate = wxPyBeginAllowThreads();
16639 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16640 wxPyEndAllowThreads(__tstate);
16641 if (PyErr_Occurred()) SWIG_fail;
16642 }
16643 resultobj = SWIG_Py_Void();
16644 return resultobj;
16645 fail:
16646 return NULL;
16647 }
16648
16649
16650 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16651 PyObject *resultobj = 0;
16652 wxImage *arg1 = (wxImage *) 0 ;
16653 int arg2 ;
16654 int arg3 ;
16655 byte result;
16656 void *argp1 = 0 ;
16657 int res1 = 0 ;
16658 int val2 ;
16659 int ecode2 = 0 ;
16660 int val3 ;
16661 int ecode3 = 0 ;
16662 PyObject * obj0 = 0 ;
16663 PyObject * obj1 = 0 ;
16664 PyObject * obj2 = 0 ;
16665 char * kwnames[] = {
16666 (char *) "self",(char *) "x",(char *) "y", NULL
16667 };
16668
16669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16671 if (!SWIG_IsOK(res1)) {
16672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
16673 }
16674 arg1 = reinterpret_cast< wxImage * >(argp1);
16675 ecode2 = SWIG_AsVal_int(obj1, &val2);
16676 if (!SWIG_IsOK(ecode2)) {
16677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
16678 }
16679 arg2 = static_cast< int >(val2);
16680 ecode3 = SWIG_AsVal_int(obj2, &val3);
16681 if (!SWIG_IsOK(ecode3)) {
16682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
16683 }
16684 arg3 = static_cast< int >(val3);
16685 {
16686 PyThreadState* __tstate = wxPyBeginAllowThreads();
16687 result = (byte)(arg1)->GetRed(arg2,arg3);
16688 wxPyEndAllowThreads(__tstate);
16689 if (PyErr_Occurred()) SWIG_fail;
16690 }
16691 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16692 return resultobj;
16693 fail:
16694 return NULL;
16695 }
16696
16697
16698 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16699 PyObject *resultobj = 0;
16700 wxImage *arg1 = (wxImage *) 0 ;
16701 int arg2 ;
16702 int arg3 ;
16703 byte result;
16704 void *argp1 = 0 ;
16705 int res1 = 0 ;
16706 int val2 ;
16707 int ecode2 = 0 ;
16708 int val3 ;
16709 int ecode3 = 0 ;
16710 PyObject * obj0 = 0 ;
16711 PyObject * obj1 = 0 ;
16712 PyObject * obj2 = 0 ;
16713 char * kwnames[] = {
16714 (char *) "self",(char *) "x",(char *) "y", NULL
16715 };
16716
16717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16719 if (!SWIG_IsOK(res1)) {
16720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16721 }
16722 arg1 = reinterpret_cast< wxImage * >(argp1);
16723 ecode2 = SWIG_AsVal_int(obj1, &val2);
16724 if (!SWIG_IsOK(ecode2)) {
16725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
16726 }
16727 arg2 = static_cast< int >(val2);
16728 ecode3 = SWIG_AsVal_int(obj2, &val3);
16729 if (!SWIG_IsOK(ecode3)) {
16730 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
16731 }
16732 arg3 = static_cast< int >(val3);
16733 {
16734 PyThreadState* __tstate = wxPyBeginAllowThreads();
16735 result = (byte)(arg1)->GetGreen(arg2,arg3);
16736 wxPyEndAllowThreads(__tstate);
16737 if (PyErr_Occurred()) SWIG_fail;
16738 }
16739 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16740 return resultobj;
16741 fail:
16742 return NULL;
16743 }
16744
16745
16746 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16747 PyObject *resultobj = 0;
16748 wxImage *arg1 = (wxImage *) 0 ;
16749 int arg2 ;
16750 int arg3 ;
16751 byte result;
16752 void *argp1 = 0 ;
16753 int res1 = 0 ;
16754 int val2 ;
16755 int ecode2 = 0 ;
16756 int val3 ;
16757 int ecode3 = 0 ;
16758 PyObject * obj0 = 0 ;
16759 PyObject * obj1 = 0 ;
16760 PyObject * obj2 = 0 ;
16761 char * kwnames[] = {
16762 (char *) "self",(char *) "x",(char *) "y", NULL
16763 };
16764
16765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16767 if (!SWIG_IsOK(res1)) {
16768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16769 }
16770 arg1 = reinterpret_cast< wxImage * >(argp1);
16771 ecode2 = SWIG_AsVal_int(obj1, &val2);
16772 if (!SWIG_IsOK(ecode2)) {
16773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16774 }
16775 arg2 = static_cast< int >(val2);
16776 ecode3 = SWIG_AsVal_int(obj2, &val3);
16777 if (!SWIG_IsOK(ecode3)) {
16778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16779 }
16780 arg3 = static_cast< int >(val3);
16781 {
16782 PyThreadState* __tstate = wxPyBeginAllowThreads();
16783 result = (byte)(arg1)->GetBlue(arg2,arg3);
16784 wxPyEndAllowThreads(__tstate);
16785 if (PyErr_Occurred()) SWIG_fail;
16786 }
16787 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16788 return resultobj;
16789 fail:
16790 return NULL;
16791 }
16792
16793
16794 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16795 PyObject *resultobj = 0;
16796 wxImage *arg1 = (wxImage *) 0 ;
16797 int arg2 ;
16798 int arg3 ;
16799 byte arg4 ;
16800 void *argp1 = 0 ;
16801 int res1 = 0 ;
16802 int val2 ;
16803 int ecode2 = 0 ;
16804 int val3 ;
16805 int ecode3 = 0 ;
16806 unsigned char val4 ;
16807 int ecode4 = 0 ;
16808 PyObject * obj0 = 0 ;
16809 PyObject * obj1 = 0 ;
16810 PyObject * obj2 = 0 ;
16811 PyObject * obj3 = 0 ;
16812 char * kwnames[] = {
16813 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16814 };
16815
16816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16818 if (!SWIG_IsOK(res1)) {
16819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16820 }
16821 arg1 = reinterpret_cast< wxImage * >(argp1);
16822 ecode2 = SWIG_AsVal_int(obj1, &val2);
16823 if (!SWIG_IsOK(ecode2)) {
16824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16825 }
16826 arg2 = static_cast< int >(val2);
16827 ecode3 = SWIG_AsVal_int(obj2, &val3);
16828 if (!SWIG_IsOK(ecode3)) {
16829 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16830 }
16831 arg3 = static_cast< int >(val3);
16832 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16833 if (!SWIG_IsOK(ecode4)) {
16834 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16835 }
16836 arg4 = static_cast< byte >(val4);
16837 {
16838 PyThreadState* __tstate = wxPyBeginAllowThreads();
16839 (arg1)->SetAlpha(arg2,arg3,arg4);
16840 wxPyEndAllowThreads(__tstate);
16841 if (PyErr_Occurred()) SWIG_fail;
16842 }
16843 resultobj = SWIG_Py_Void();
16844 return resultobj;
16845 fail:
16846 return NULL;
16847 }
16848
16849
16850 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16851 PyObject *resultobj = 0;
16852 wxImage *arg1 = (wxImage *) 0 ;
16853 int arg2 ;
16854 int arg3 ;
16855 byte result;
16856 void *argp1 = 0 ;
16857 int res1 = 0 ;
16858 int val2 ;
16859 int ecode2 = 0 ;
16860 int val3 ;
16861 int ecode3 = 0 ;
16862 PyObject * obj0 = 0 ;
16863 PyObject * obj1 = 0 ;
16864 PyObject * obj2 = 0 ;
16865 char * kwnames[] = {
16866 (char *) "self",(char *) "x",(char *) "y", NULL
16867 };
16868
16869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16871 if (!SWIG_IsOK(res1)) {
16872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16873 }
16874 arg1 = reinterpret_cast< wxImage * >(argp1);
16875 ecode2 = SWIG_AsVal_int(obj1, &val2);
16876 if (!SWIG_IsOK(ecode2)) {
16877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16878 }
16879 arg2 = static_cast< int >(val2);
16880 ecode3 = SWIG_AsVal_int(obj2, &val3);
16881 if (!SWIG_IsOK(ecode3)) {
16882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16883 }
16884 arg3 = static_cast< int >(val3);
16885 {
16886 PyThreadState* __tstate = wxPyBeginAllowThreads();
16887 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16888 wxPyEndAllowThreads(__tstate);
16889 if (PyErr_Occurred()) SWIG_fail;
16890 }
16891 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16892 return resultobj;
16893 fail:
16894 return NULL;
16895 }
16896
16897
16898 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16899 PyObject *resultobj = 0;
16900 wxImage *arg1 = (wxImage *) 0 ;
16901 bool result;
16902 void *argp1 = 0 ;
16903 int res1 = 0 ;
16904 PyObject *swig_obj[1] ;
16905
16906 if (!args) SWIG_fail;
16907 swig_obj[0] = args;
16908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16909 if (!SWIG_IsOK(res1)) {
16910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16911 }
16912 arg1 = reinterpret_cast< wxImage * >(argp1);
16913 {
16914 PyThreadState* __tstate = wxPyBeginAllowThreads();
16915 result = (bool)(arg1)->HasAlpha();
16916 wxPyEndAllowThreads(__tstate);
16917 if (PyErr_Occurred()) SWIG_fail;
16918 }
16919 {
16920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16921 }
16922 return resultobj;
16923 fail:
16924 return NULL;
16925 }
16926
16927
16928 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16929 PyObject *resultobj = 0;
16930 wxImage *arg1 = (wxImage *) 0 ;
16931 void *argp1 = 0 ;
16932 int res1 = 0 ;
16933 PyObject *swig_obj[1] ;
16934
16935 if (!args) SWIG_fail;
16936 swig_obj[0] = args;
16937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16938 if (!SWIG_IsOK(res1)) {
16939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16940 }
16941 arg1 = reinterpret_cast< wxImage * >(argp1);
16942 {
16943 PyThreadState* __tstate = wxPyBeginAllowThreads();
16944 (arg1)->InitAlpha();
16945 wxPyEndAllowThreads(__tstate);
16946 if (PyErr_Occurred()) SWIG_fail;
16947 }
16948 resultobj = SWIG_Py_Void();
16949 return resultobj;
16950 fail:
16951 return NULL;
16952 }
16953
16954
16955 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16956 PyObject *resultobj = 0;
16957 wxImage *arg1 = (wxImage *) 0 ;
16958 int arg2 ;
16959 int arg3 ;
16960 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
16961 bool result;
16962 void *argp1 = 0 ;
16963 int res1 = 0 ;
16964 int val2 ;
16965 int ecode2 = 0 ;
16966 int val3 ;
16967 int ecode3 = 0 ;
16968 unsigned char val4 ;
16969 int ecode4 = 0 ;
16970 PyObject * obj0 = 0 ;
16971 PyObject * obj1 = 0 ;
16972 PyObject * obj2 = 0 ;
16973 PyObject * obj3 = 0 ;
16974 char * kwnames[] = {
16975 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
16976 };
16977
16978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16980 if (!SWIG_IsOK(res1)) {
16981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
16982 }
16983 arg1 = reinterpret_cast< wxImage * >(argp1);
16984 ecode2 = SWIG_AsVal_int(obj1, &val2);
16985 if (!SWIG_IsOK(ecode2)) {
16986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
16987 }
16988 arg2 = static_cast< int >(val2);
16989 ecode3 = SWIG_AsVal_int(obj2, &val3);
16990 if (!SWIG_IsOK(ecode3)) {
16991 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
16992 }
16993 arg3 = static_cast< int >(val3);
16994 if (obj3) {
16995 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16996 if (!SWIG_IsOK(ecode4)) {
16997 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
16998 }
16999 arg4 = static_cast< byte >(val4);
17000 }
17001 {
17002 PyThreadState* __tstate = wxPyBeginAllowThreads();
17003 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
17004 wxPyEndAllowThreads(__tstate);
17005 if (PyErr_Occurred()) SWIG_fail;
17006 }
17007 {
17008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17009 }
17010 return resultobj;
17011 fail:
17012 return NULL;
17013 }
17014
17015
17016 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17017 PyObject *resultobj = 0;
17018 wxImage *arg1 = (wxImage *) 0 ;
17019 byte *arg2 = (byte *) 0 ;
17020 byte *arg3 = (byte *) 0 ;
17021 byte *arg4 = (byte *) 0 ;
17022 byte arg5 = (byte) 0 ;
17023 byte arg6 = (byte) 0 ;
17024 byte arg7 = (byte) 0 ;
17025 bool result;
17026 void *argp1 = 0 ;
17027 int res1 = 0 ;
17028 byte temp2 ;
17029 int res2 = SWIG_TMPOBJ ;
17030 byte temp3 ;
17031 int res3 = SWIG_TMPOBJ ;
17032 byte temp4 ;
17033 int res4 = SWIG_TMPOBJ ;
17034 unsigned char val5 ;
17035 int ecode5 = 0 ;
17036 unsigned char val6 ;
17037 int ecode6 = 0 ;
17038 unsigned char val7 ;
17039 int ecode7 = 0 ;
17040 PyObject * obj0 = 0 ;
17041 PyObject * obj1 = 0 ;
17042 PyObject * obj2 = 0 ;
17043 PyObject * obj3 = 0 ;
17044 char * kwnames[] = {
17045 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17046 };
17047
17048 arg2 = &temp2;
17049 arg3 = &temp3;
17050 arg4 = &temp4;
17051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17053 if (!SWIG_IsOK(res1)) {
17054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17055 }
17056 arg1 = reinterpret_cast< wxImage * >(argp1);
17057 if (obj1) {
17058 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17059 if (!SWIG_IsOK(ecode5)) {
17060 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17061 }
17062 arg5 = static_cast< byte >(val5);
17063 }
17064 if (obj2) {
17065 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17066 if (!SWIG_IsOK(ecode6)) {
17067 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17068 }
17069 arg6 = static_cast< byte >(val6);
17070 }
17071 if (obj3) {
17072 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17073 if (!SWIG_IsOK(ecode7)) {
17074 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17075 }
17076 arg7 = static_cast< byte >(val7);
17077 }
17078 {
17079 PyThreadState* __tstate = wxPyBeginAllowThreads();
17080 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17081 wxPyEndAllowThreads(__tstate);
17082 if (PyErr_Occurred()) SWIG_fail;
17083 }
17084 {
17085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17086 }
17087 if (SWIG_IsTmpObj(res2)) {
17088 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17089 } else {
17090 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17091 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17092 }
17093 if (SWIG_IsTmpObj(res3)) {
17094 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17095 } else {
17096 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17097 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17098 }
17099 if (SWIG_IsTmpObj(res4)) {
17100 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17101 } else {
17102 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17103 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17104 }
17105 return resultobj;
17106 fail:
17107 return NULL;
17108 }
17109
17110
17111 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17112 PyObject *resultobj = 0;
17113 wxImage *arg1 = (wxImage *) 0 ;
17114 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17115 bool result;
17116 void *argp1 = 0 ;
17117 int res1 = 0 ;
17118 unsigned char val2 ;
17119 int ecode2 = 0 ;
17120 PyObject * obj0 = 0 ;
17121 PyObject * obj1 = 0 ;
17122 char * kwnames[] = {
17123 (char *) "self",(char *) "threshold", NULL
17124 };
17125
17126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17128 if (!SWIG_IsOK(res1)) {
17129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17130 }
17131 arg1 = reinterpret_cast< wxImage * >(argp1);
17132 if (obj1) {
17133 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17134 if (!SWIG_IsOK(ecode2)) {
17135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17136 }
17137 arg2 = static_cast< byte >(val2);
17138 }
17139 {
17140 PyThreadState* __tstate = wxPyBeginAllowThreads();
17141 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17142 wxPyEndAllowThreads(__tstate);
17143 if (PyErr_Occurred()) SWIG_fail;
17144 }
17145 {
17146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17147 }
17148 return resultobj;
17149 fail:
17150 return NULL;
17151 }
17152
17153
17154 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17155 PyObject *resultobj = 0;
17156 wxImage *arg1 = (wxImage *) 0 ;
17157 byte arg2 ;
17158 byte arg3 ;
17159 byte arg4 ;
17160 bool result;
17161 void *argp1 = 0 ;
17162 int res1 = 0 ;
17163 unsigned char val2 ;
17164 int ecode2 = 0 ;
17165 unsigned char val3 ;
17166 int ecode3 = 0 ;
17167 unsigned char val4 ;
17168 int ecode4 = 0 ;
17169 PyObject * obj0 = 0 ;
17170 PyObject * obj1 = 0 ;
17171 PyObject * obj2 = 0 ;
17172 PyObject * obj3 = 0 ;
17173 char * kwnames[] = {
17174 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17175 };
17176
17177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17179 if (!SWIG_IsOK(res1)) {
17180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17181 }
17182 arg1 = reinterpret_cast< wxImage * >(argp1);
17183 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17184 if (!SWIG_IsOK(ecode2)) {
17185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17186 }
17187 arg2 = static_cast< byte >(val2);
17188 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17189 if (!SWIG_IsOK(ecode3)) {
17190 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17191 }
17192 arg3 = static_cast< byte >(val3);
17193 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17194 if (!SWIG_IsOK(ecode4)) {
17195 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17196 }
17197 arg4 = static_cast< byte >(val4);
17198 {
17199 PyThreadState* __tstate = wxPyBeginAllowThreads();
17200 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17201 wxPyEndAllowThreads(__tstate);
17202 if (PyErr_Occurred()) SWIG_fail;
17203 }
17204 {
17205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17206 }
17207 return resultobj;
17208 fail:
17209 return NULL;
17210 }
17211
17212
17213 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17214 PyObject *resultobj = 0;
17215 wxImage *arg1 = (wxImage *) 0 ;
17216 wxImage *arg2 = 0 ;
17217 byte arg3 ;
17218 byte arg4 ;
17219 byte arg5 ;
17220 bool result;
17221 void *argp1 = 0 ;
17222 int res1 = 0 ;
17223 void *argp2 = 0 ;
17224 int res2 = 0 ;
17225 unsigned char val3 ;
17226 int ecode3 = 0 ;
17227 unsigned char val4 ;
17228 int ecode4 = 0 ;
17229 unsigned char val5 ;
17230 int ecode5 = 0 ;
17231 PyObject * obj0 = 0 ;
17232 PyObject * obj1 = 0 ;
17233 PyObject * obj2 = 0 ;
17234 PyObject * obj3 = 0 ;
17235 PyObject * obj4 = 0 ;
17236 char * kwnames[] = {
17237 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17238 };
17239
17240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17242 if (!SWIG_IsOK(res1)) {
17243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17244 }
17245 arg1 = reinterpret_cast< wxImage * >(argp1);
17246 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17247 if (!SWIG_IsOK(res2)) {
17248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17249 }
17250 if (!argp2) {
17251 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17252 }
17253 arg2 = reinterpret_cast< wxImage * >(argp2);
17254 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17255 if (!SWIG_IsOK(ecode3)) {
17256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17257 }
17258 arg3 = static_cast< byte >(val3);
17259 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17260 if (!SWIG_IsOK(ecode4)) {
17261 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17262 }
17263 arg4 = static_cast< byte >(val4);
17264 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17265 if (!SWIG_IsOK(ecode5)) {
17266 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17267 }
17268 arg5 = static_cast< byte >(val5);
17269 {
17270 PyThreadState* __tstate = wxPyBeginAllowThreads();
17271 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17272 wxPyEndAllowThreads(__tstate);
17273 if (PyErr_Occurred()) SWIG_fail;
17274 }
17275 {
17276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17277 }
17278 return resultobj;
17279 fail:
17280 return NULL;
17281 }
17282
17283
17284 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17285 PyObject *resultobj = 0;
17286 wxString *arg1 = 0 ;
17287 bool result;
17288 bool temp1 = false ;
17289 PyObject * obj0 = 0 ;
17290 char * kwnames[] = {
17291 (char *) "filename", NULL
17292 };
17293
17294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17295 {
17296 arg1 = wxString_in_helper(obj0);
17297 if (arg1 == NULL) SWIG_fail;
17298 temp1 = true;
17299 }
17300 {
17301 PyThreadState* __tstate = wxPyBeginAllowThreads();
17302 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17303 wxPyEndAllowThreads(__tstate);
17304 if (PyErr_Occurred()) SWIG_fail;
17305 }
17306 {
17307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17308 }
17309 {
17310 if (temp1)
17311 delete arg1;
17312 }
17313 return resultobj;
17314 fail:
17315 {
17316 if (temp1)
17317 delete arg1;
17318 }
17319 return NULL;
17320 }
17321
17322
17323 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17324 PyObject *resultobj = 0;
17325 wxString *arg1 = 0 ;
17326 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17327 int result;
17328 bool temp1 = false ;
17329 long val2 ;
17330 int ecode2 = 0 ;
17331 PyObject * obj0 = 0 ;
17332 PyObject * obj1 = 0 ;
17333 char * kwnames[] = {
17334 (char *) "filename",(char *) "type", NULL
17335 };
17336
17337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17338 {
17339 arg1 = wxString_in_helper(obj0);
17340 if (arg1 == NULL) SWIG_fail;
17341 temp1 = true;
17342 }
17343 if (obj1) {
17344 ecode2 = SWIG_AsVal_long(obj1, &val2);
17345 if (!SWIG_IsOK(ecode2)) {
17346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17347 }
17348 arg2 = static_cast< long >(val2);
17349 }
17350 {
17351 PyThreadState* __tstate = wxPyBeginAllowThreads();
17352 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17353 wxPyEndAllowThreads(__tstate);
17354 if (PyErr_Occurred()) SWIG_fail;
17355 }
17356 resultobj = SWIG_From_int(static_cast< int >(result));
17357 {
17358 if (temp1)
17359 delete arg1;
17360 }
17361 return resultobj;
17362 fail:
17363 {
17364 if (temp1)
17365 delete arg1;
17366 }
17367 return NULL;
17368 }
17369
17370
17371 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17372 PyObject *resultobj = 0;
17373 wxImage *arg1 = (wxImage *) 0 ;
17374 wxString *arg2 = 0 ;
17375 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17376 int arg4 = (int) -1 ;
17377 bool result;
17378 void *argp1 = 0 ;
17379 int res1 = 0 ;
17380 bool temp2 = false ;
17381 long val3 ;
17382 int ecode3 = 0 ;
17383 int val4 ;
17384 int ecode4 = 0 ;
17385 PyObject * obj0 = 0 ;
17386 PyObject * obj1 = 0 ;
17387 PyObject * obj2 = 0 ;
17388 PyObject * obj3 = 0 ;
17389 char * kwnames[] = {
17390 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17391 };
17392
17393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17395 if (!SWIG_IsOK(res1)) {
17396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17397 }
17398 arg1 = reinterpret_cast< wxImage * >(argp1);
17399 {
17400 arg2 = wxString_in_helper(obj1);
17401 if (arg2 == NULL) SWIG_fail;
17402 temp2 = true;
17403 }
17404 if (obj2) {
17405 ecode3 = SWIG_AsVal_long(obj2, &val3);
17406 if (!SWIG_IsOK(ecode3)) {
17407 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17408 }
17409 arg3 = static_cast< long >(val3);
17410 }
17411 if (obj3) {
17412 ecode4 = SWIG_AsVal_int(obj3, &val4);
17413 if (!SWIG_IsOK(ecode4)) {
17414 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17415 }
17416 arg4 = static_cast< int >(val4);
17417 }
17418 {
17419 PyThreadState* __tstate = wxPyBeginAllowThreads();
17420 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17421 wxPyEndAllowThreads(__tstate);
17422 if (PyErr_Occurred()) SWIG_fail;
17423 }
17424 {
17425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17426 }
17427 {
17428 if (temp2)
17429 delete arg2;
17430 }
17431 return resultobj;
17432 fail:
17433 {
17434 if (temp2)
17435 delete arg2;
17436 }
17437 return NULL;
17438 }
17439
17440
17441 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17442 PyObject *resultobj = 0;
17443 wxImage *arg1 = (wxImage *) 0 ;
17444 wxString *arg2 = 0 ;
17445 wxString *arg3 = 0 ;
17446 int arg4 = (int) -1 ;
17447 bool result;
17448 void *argp1 = 0 ;
17449 int res1 = 0 ;
17450 bool temp2 = false ;
17451 bool temp3 = false ;
17452 int val4 ;
17453 int ecode4 = 0 ;
17454 PyObject * obj0 = 0 ;
17455 PyObject * obj1 = 0 ;
17456 PyObject * obj2 = 0 ;
17457 PyObject * obj3 = 0 ;
17458 char * kwnames[] = {
17459 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17460 };
17461
17462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17464 if (!SWIG_IsOK(res1)) {
17465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17466 }
17467 arg1 = reinterpret_cast< wxImage * >(argp1);
17468 {
17469 arg2 = wxString_in_helper(obj1);
17470 if (arg2 == NULL) SWIG_fail;
17471 temp2 = true;
17472 }
17473 {
17474 arg3 = wxString_in_helper(obj2);
17475 if (arg3 == NULL) SWIG_fail;
17476 temp3 = true;
17477 }
17478 if (obj3) {
17479 ecode4 = SWIG_AsVal_int(obj3, &val4);
17480 if (!SWIG_IsOK(ecode4)) {
17481 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17482 }
17483 arg4 = static_cast< int >(val4);
17484 }
17485 {
17486 PyThreadState* __tstate = wxPyBeginAllowThreads();
17487 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17488 wxPyEndAllowThreads(__tstate);
17489 if (PyErr_Occurred()) SWIG_fail;
17490 }
17491 {
17492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17493 }
17494 {
17495 if (temp2)
17496 delete arg2;
17497 }
17498 {
17499 if (temp3)
17500 delete arg3;
17501 }
17502 return resultobj;
17503 fail:
17504 {
17505 if (temp2)
17506 delete arg2;
17507 }
17508 {
17509 if (temp3)
17510 delete arg3;
17511 }
17512 return NULL;
17513 }
17514
17515
17516 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17517 PyObject *resultobj = 0;
17518 wxImage *arg1 = (wxImage *) 0 ;
17519 wxString *arg2 = 0 ;
17520 int arg3 ;
17521 bool result;
17522 void *argp1 = 0 ;
17523 int res1 = 0 ;
17524 bool temp2 = false ;
17525 int val3 ;
17526 int ecode3 = 0 ;
17527 PyObject * obj0 = 0 ;
17528 PyObject * obj1 = 0 ;
17529 PyObject * obj2 = 0 ;
17530 char * kwnames[] = {
17531 (char *) "self",(char *) "name",(char *) "type", NULL
17532 };
17533
17534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17536 if (!SWIG_IsOK(res1)) {
17537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17538 }
17539 arg1 = reinterpret_cast< wxImage * >(argp1);
17540 {
17541 arg2 = wxString_in_helper(obj1);
17542 if (arg2 == NULL) SWIG_fail;
17543 temp2 = true;
17544 }
17545 ecode3 = SWIG_AsVal_int(obj2, &val3);
17546 if (!SWIG_IsOK(ecode3)) {
17547 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17548 }
17549 arg3 = static_cast< int >(val3);
17550 {
17551 PyThreadState* __tstate = wxPyBeginAllowThreads();
17552 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17553 wxPyEndAllowThreads(__tstate);
17554 if (PyErr_Occurred()) SWIG_fail;
17555 }
17556 {
17557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17558 }
17559 {
17560 if (temp2)
17561 delete arg2;
17562 }
17563 return resultobj;
17564 fail:
17565 {
17566 if (temp2)
17567 delete arg2;
17568 }
17569 return NULL;
17570 }
17571
17572
17573 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17574 PyObject *resultobj = 0;
17575 wxImage *arg1 = (wxImage *) 0 ;
17576 wxString *arg2 = 0 ;
17577 wxString *arg3 = 0 ;
17578 bool result;
17579 void *argp1 = 0 ;
17580 int res1 = 0 ;
17581 bool temp2 = false ;
17582 bool temp3 = false ;
17583 PyObject * obj0 = 0 ;
17584 PyObject * obj1 = 0 ;
17585 PyObject * obj2 = 0 ;
17586 char * kwnames[] = {
17587 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17588 };
17589
17590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17592 if (!SWIG_IsOK(res1)) {
17593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17594 }
17595 arg1 = reinterpret_cast< wxImage * >(argp1);
17596 {
17597 arg2 = wxString_in_helper(obj1);
17598 if (arg2 == NULL) SWIG_fail;
17599 temp2 = true;
17600 }
17601 {
17602 arg3 = wxString_in_helper(obj2);
17603 if (arg3 == NULL) SWIG_fail;
17604 temp3 = true;
17605 }
17606 {
17607 PyThreadState* __tstate = wxPyBeginAllowThreads();
17608 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17609 wxPyEndAllowThreads(__tstate);
17610 if (PyErr_Occurred()) SWIG_fail;
17611 }
17612 {
17613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17614 }
17615 {
17616 if (temp2)
17617 delete arg2;
17618 }
17619 {
17620 if (temp3)
17621 delete arg3;
17622 }
17623 return resultobj;
17624 fail:
17625 {
17626 if (temp2)
17627 delete arg2;
17628 }
17629 {
17630 if (temp3)
17631 delete arg3;
17632 }
17633 return NULL;
17634 }
17635
17636
17637 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17638 PyObject *resultobj = 0;
17639 wxInputStream *arg1 = 0 ;
17640 bool result;
17641 wxPyInputStream *temp1 ;
17642 bool created1 ;
17643 PyObject * obj0 = 0 ;
17644 char * kwnames[] = {
17645 (char *) "stream", NULL
17646 };
17647
17648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17649 {
17650 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17651 arg1 = temp1->m_wxis;
17652 created1 = false;
17653 } else {
17654 PyErr_Clear(); // clear the failure of the wxPyConvert above
17655 arg1 = wxPyCBInputStream_create(obj0, false);
17656 if (arg1 == NULL) {
17657 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17658 SWIG_fail;
17659 }
17660 created1 = true;
17661 }
17662 }
17663 {
17664 PyThreadState* __tstate = wxPyBeginAllowThreads();
17665 result = (bool)wxImage::CanRead(*arg1);
17666 wxPyEndAllowThreads(__tstate);
17667 if (PyErr_Occurred()) SWIG_fail;
17668 }
17669 {
17670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17671 }
17672 {
17673 if (created1) delete arg1;
17674 }
17675 return resultobj;
17676 fail:
17677 {
17678 if (created1) delete arg1;
17679 }
17680 return NULL;
17681 }
17682
17683
17684 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17685 PyObject *resultobj = 0;
17686 wxImage *arg1 = (wxImage *) 0 ;
17687 wxInputStream *arg2 = 0 ;
17688 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17689 int arg4 = (int) -1 ;
17690 bool result;
17691 void *argp1 = 0 ;
17692 int res1 = 0 ;
17693 wxPyInputStream *temp2 ;
17694 bool created2 ;
17695 long val3 ;
17696 int ecode3 = 0 ;
17697 int val4 ;
17698 int ecode4 = 0 ;
17699 PyObject * obj0 = 0 ;
17700 PyObject * obj1 = 0 ;
17701 PyObject * obj2 = 0 ;
17702 PyObject * obj3 = 0 ;
17703 char * kwnames[] = {
17704 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17705 };
17706
17707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17709 if (!SWIG_IsOK(res1)) {
17710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17711 }
17712 arg1 = reinterpret_cast< wxImage * >(argp1);
17713 {
17714 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17715 arg2 = temp2->m_wxis;
17716 created2 = false;
17717 } else {
17718 PyErr_Clear(); // clear the failure of the wxPyConvert above
17719 arg2 = wxPyCBInputStream_create(obj1, false);
17720 if (arg2 == NULL) {
17721 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17722 SWIG_fail;
17723 }
17724 created2 = true;
17725 }
17726 }
17727 if (obj2) {
17728 ecode3 = SWIG_AsVal_long(obj2, &val3);
17729 if (!SWIG_IsOK(ecode3)) {
17730 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17731 }
17732 arg3 = static_cast< long >(val3);
17733 }
17734 if (obj3) {
17735 ecode4 = SWIG_AsVal_int(obj3, &val4);
17736 if (!SWIG_IsOK(ecode4)) {
17737 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17738 }
17739 arg4 = static_cast< int >(val4);
17740 }
17741 {
17742 PyThreadState* __tstate = wxPyBeginAllowThreads();
17743 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17744 wxPyEndAllowThreads(__tstate);
17745 if (PyErr_Occurred()) SWIG_fail;
17746 }
17747 {
17748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17749 }
17750 {
17751 if (created2) delete arg2;
17752 }
17753 return resultobj;
17754 fail:
17755 {
17756 if (created2) delete arg2;
17757 }
17758 return NULL;
17759 }
17760
17761
17762 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17763 PyObject *resultobj = 0;
17764 wxImage *arg1 = (wxImage *) 0 ;
17765 wxInputStream *arg2 = 0 ;
17766 wxString *arg3 = 0 ;
17767 int arg4 = (int) -1 ;
17768 bool result;
17769 void *argp1 = 0 ;
17770 int res1 = 0 ;
17771 wxPyInputStream *temp2 ;
17772 bool created2 ;
17773 bool temp3 = false ;
17774 int val4 ;
17775 int ecode4 = 0 ;
17776 PyObject * obj0 = 0 ;
17777 PyObject * obj1 = 0 ;
17778 PyObject * obj2 = 0 ;
17779 PyObject * obj3 = 0 ;
17780 char * kwnames[] = {
17781 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17782 };
17783
17784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17786 if (!SWIG_IsOK(res1)) {
17787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17788 }
17789 arg1 = reinterpret_cast< wxImage * >(argp1);
17790 {
17791 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17792 arg2 = temp2->m_wxis;
17793 created2 = false;
17794 } else {
17795 PyErr_Clear(); // clear the failure of the wxPyConvert above
17796 arg2 = wxPyCBInputStream_create(obj1, false);
17797 if (arg2 == NULL) {
17798 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17799 SWIG_fail;
17800 }
17801 created2 = true;
17802 }
17803 }
17804 {
17805 arg3 = wxString_in_helper(obj2);
17806 if (arg3 == NULL) SWIG_fail;
17807 temp3 = true;
17808 }
17809 if (obj3) {
17810 ecode4 = SWIG_AsVal_int(obj3, &val4);
17811 if (!SWIG_IsOK(ecode4)) {
17812 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17813 }
17814 arg4 = static_cast< int >(val4);
17815 }
17816 {
17817 PyThreadState* __tstate = wxPyBeginAllowThreads();
17818 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17819 wxPyEndAllowThreads(__tstate);
17820 if (PyErr_Occurred()) SWIG_fail;
17821 }
17822 {
17823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17824 }
17825 {
17826 if (created2) delete arg2;
17827 }
17828 {
17829 if (temp3)
17830 delete arg3;
17831 }
17832 return resultobj;
17833 fail:
17834 {
17835 if (created2) delete arg2;
17836 }
17837 {
17838 if (temp3)
17839 delete arg3;
17840 }
17841 return NULL;
17842 }
17843
17844
17845 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17846 PyObject *resultobj = 0;
17847 wxImage *arg1 = (wxImage *) 0 ;
17848 bool result;
17849 void *argp1 = 0 ;
17850 int res1 = 0 ;
17851 PyObject *swig_obj[1] ;
17852
17853 if (!args) SWIG_fail;
17854 swig_obj[0] = args;
17855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17856 if (!SWIG_IsOK(res1)) {
17857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
17858 }
17859 arg1 = reinterpret_cast< wxImage * >(argp1);
17860 {
17861 PyThreadState* __tstate = wxPyBeginAllowThreads();
17862 result = (bool)(arg1)->IsOk();
17863 wxPyEndAllowThreads(__tstate);
17864 if (PyErr_Occurred()) SWIG_fail;
17865 }
17866 {
17867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17868 }
17869 return resultobj;
17870 fail:
17871 return NULL;
17872 }
17873
17874
17875 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17876 PyObject *resultobj = 0;
17877 wxImage *arg1 = (wxImage *) 0 ;
17878 int result;
17879 void *argp1 = 0 ;
17880 int res1 = 0 ;
17881 PyObject *swig_obj[1] ;
17882
17883 if (!args) SWIG_fail;
17884 swig_obj[0] = args;
17885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17886 if (!SWIG_IsOK(res1)) {
17887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17888 }
17889 arg1 = reinterpret_cast< wxImage * >(argp1);
17890 {
17891 PyThreadState* __tstate = wxPyBeginAllowThreads();
17892 result = (int)(arg1)->GetWidth();
17893 wxPyEndAllowThreads(__tstate);
17894 if (PyErr_Occurred()) SWIG_fail;
17895 }
17896 resultobj = SWIG_From_int(static_cast< int >(result));
17897 return resultobj;
17898 fail:
17899 return NULL;
17900 }
17901
17902
17903 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17904 PyObject *resultobj = 0;
17905 wxImage *arg1 = (wxImage *) 0 ;
17906 int result;
17907 void *argp1 = 0 ;
17908 int res1 = 0 ;
17909 PyObject *swig_obj[1] ;
17910
17911 if (!args) SWIG_fail;
17912 swig_obj[0] = args;
17913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17914 if (!SWIG_IsOK(res1)) {
17915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17916 }
17917 arg1 = reinterpret_cast< wxImage * >(argp1);
17918 {
17919 PyThreadState* __tstate = wxPyBeginAllowThreads();
17920 result = (int)(arg1)->GetHeight();
17921 wxPyEndAllowThreads(__tstate);
17922 if (PyErr_Occurred()) SWIG_fail;
17923 }
17924 resultobj = SWIG_From_int(static_cast< int >(result));
17925 return resultobj;
17926 fail:
17927 return NULL;
17928 }
17929
17930
17931 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17932 PyObject *resultobj = 0;
17933 wxImage *arg1 = (wxImage *) 0 ;
17934 wxSize result;
17935 void *argp1 = 0 ;
17936 int res1 = 0 ;
17937 PyObject *swig_obj[1] ;
17938
17939 if (!args) SWIG_fail;
17940 swig_obj[0] = args;
17941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17942 if (!SWIG_IsOK(res1)) {
17943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
17944 }
17945 arg1 = reinterpret_cast< wxImage * >(argp1);
17946 {
17947 PyThreadState* __tstate = wxPyBeginAllowThreads();
17948 result = wxImage_GetSize(arg1);
17949 wxPyEndAllowThreads(__tstate);
17950 if (PyErr_Occurred()) SWIG_fail;
17951 }
17952 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
17953 return resultobj;
17954 fail:
17955 return NULL;
17956 }
17957
17958
17959 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17960 PyObject *resultobj = 0;
17961 wxImage *arg1 = (wxImage *) 0 ;
17962 wxRect *arg2 = 0 ;
17963 SwigValueWrapper<wxImage > result;
17964 void *argp1 = 0 ;
17965 int res1 = 0 ;
17966 wxRect temp2 ;
17967 PyObject * obj0 = 0 ;
17968 PyObject * obj1 = 0 ;
17969 char * kwnames[] = {
17970 (char *) "self",(char *) "rect", NULL
17971 };
17972
17973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
17974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17975 if (!SWIG_IsOK(res1)) {
17976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
17977 }
17978 arg1 = reinterpret_cast< wxImage * >(argp1);
17979 {
17980 arg2 = &temp2;
17981 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17982 }
17983 {
17984 PyThreadState* __tstate = wxPyBeginAllowThreads();
17985 result = (arg1)->GetSubImage((wxRect const &)*arg2);
17986 wxPyEndAllowThreads(__tstate);
17987 if (PyErr_Occurred()) SWIG_fail;
17988 }
17989 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
17990 return resultobj;
17991 fail:
17992 return NULL;
17993 }
17994
17995
17996 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17997 PyObject *resultobj = 0;
17998 wxImage *arg1 = (wxImage *) 0 ;
17999 wxSize *arg2 = 0 ;
18000 wxPoint *arg3 = 0 ;
18001 int arg4 = (int) -1 ;
18002 int arg5 = (int) -1 ;
18003 int arg6 = (int) -1 ;
18004 SwigValueWrapper<wxImage > result;
18005 void *argp1 = 0 ;
18006 int res1 = 0 ;
18007 wxSize temp2 ;
18008 wxPoint temp3 ;
18009 int val4 ;
18010 int ecode4 = 0 ;
18011 int val5 ;
18012 int ecode5 = 0 ;
18013 int val6 ;
18014 int ecode6 = 0 ;
18015 PyObject * obj0 = 0 ;
18016 PyObject * obj1 = 0 ;
18017 PyObject * obj2 = 0 ;
18018 PyObject * obj3 = 0 ;
18019 PyObject * obj4 = 0 ;
18020 PyObject * obj5 = 0 ;
18021 char * kwnames[] = {
18022 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18023 };
18024
18025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18027 if (!SWIG_IsOK(res1)) {
18028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18029 }
18030 arg1 = reinterpret_cast< wxImage * >(argp1);
18031 {
18032 arg2 = &temp2;
18033 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18034 }
18035 {
18036 arg3 = &temp3;
18037 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18038 }
18039 if (obj3) {
18040 ecode4 = SWIG_AsVal_int(obj3, &val4);
18041 if (!SWIG_IsOK(ecode4)) {
18042 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18043 }
18044 arg4 = static_cast< int >(val4);
18045 }
18046 if (obj4) {
18047 ecode5 = SWIG_AsVal_int(obj4, &val5);
18048 if (!SWIG_IsOK(ecode5)) {
18049 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18050 }
18051 arg5 = static_cast< int >(val5);
18052 }
18053 if (obj5) {
18054 ecode6 = SWIG_AsVal_int(obj5, &val6);
18055 if (!SWIG_IsOK(ecode6)) {
18056 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18057 }
18058 arg6 = static_cast< int >(val6);
18059 }
18060 {
18061 PyThreadState* __tstate = wxPyBeginAllowThreads();
18062 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18063 wxPyEndAllowThreads(__tstate);
18064 if (PyErr_Occurred()) SWIG_fail;
18065 }
18066 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18067 return resultobj;
18068 fail:
18069 return NULL;
18070 }
18071
18072
18073 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18074 PyObject *resultobj = 0;
18075 wxImage *arg1 = (wxImage *) 0 ;
18076 SwigValueWrapper<wxImage > result;
18077 void *argp1 = 0 ;
18078 int res1 = 0 ;
18079 PyObject *swig_obj[1] ;
18080
18081 if (!args) SWIG_fail;
18082 swig_obj[0] = args;
18083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18084 if (!SWIG_IsOK(res1)) {
18085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18086 }
18087 arg1 = reinterpret_cast< wxImage * >(argp1);
18088 {
18089 PyThreadState* __tstate = wxPyBeginAllowThreads();
18090 result = (arg1)->Copy();
18091 wxPyEndAllowThreads(__tstate);
18092 if (PyErr_Occurred()) SWIG_fail;
18093 }
18094 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18095 return resultobj;
18096 fail:
18097 return NULL;
18098 }
18099
18100
18101 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18102 PyObject *resultobj = 0;
18103 wxImage *arg1 = (wxImage *) 0 ;
18104 wxImage *arg2 = 0 ;
18105 int arg3 ;
18106 int arg4 ;
18107 void *argp1 = 0 ;
18108 int res1 = 0 ;
18109 void *argp2 = 0 ;
18110 int res2 = 0 ;
18111 int val3 ;
18112 int ecode3 = 0 ;
18113 int val4 ;
18114 int ecode4 = 0 ;
18115 PyObject * obj0 = 0 ;
18116 PyObject * obj1 = 0 ;
18117 PyObject * obj2 = 0 ;
18118 PyObject * obj3 = 0 ;
18119 char * kwnames[] = {
18120 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18121 };
18122
18123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18125 if (!SWIG_IsOK(res1)) {
18126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18127 }
18128 arg1 = reinterpret_cast< wxImage * >(argp1);
18129 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18130 if (!SWIG_IsOK(res2)) {
18131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18132 }
18133 if (!argp2) {
18134 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18135 }
18136 arg2 = reinterpret_cast< wxImage * >(argp2);
18137 ecode3 = SWIG_AsVal_int(obj2, &val3);
18138 if (!SWIG_IsOK(ecode3)) {
18139 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18140 }
18141 arg3 = static_cast< int >(val3);
18142 ecode4 = SWIG_AsVal_int(obj3, &val4);
18143 if (!SWIG_IsOK(ecode4)) {
18144 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18145 }
18146 arg4 = static_cast< int >(val4);
18147 {
18148 PyThreadState* __tstate = wxPyBeginAllowThreads();
18149 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18150 wxPyEndAllowThreads(__tstate);
18151 if (PyErr_Occurred()) SWIG_fail;
18152 }
18153 resultobj = SWIG_Py_Void();
18154 return resultobj;
18155 fail:
18156 return NULL;
18157 }
18158
18159
18160 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18161 PyObject *resultobj = 0;
18162 wxImage *arg1 = (wxImage *) 0 ;
18163 PyObject *result = 0 ;
18164 void *argp1 = 0 ;
18165 int res1 = 0 ;
18166 PyObject *swig_obj[1] ;
18167
18168 if (!args) SWIG_fail;
18169 swig_obj[0] = args;
18170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18171 if (!SWIG_IsOK(res1)) {
18172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18173 }
18174 arg1 = reinterpret_cast< wxImage * >(argp1);
18175 {
18176 PyThreadState* __tstate = wxPyBeginAllowThreads();
18177 result = (PyObject *)wxImage_GetData(arg1);
18178 wxPyEndAllowThreads(__tstate);
18179 if (PyErr_Occurred()) SWIG_fail;
18180 }
18181 resultobj = result;
18182 return resultobj;
18183 fail:
18184 return NULL;
18185 }
18186
18187
18188 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18189 PyObject *resultobj = 0;
18190 wxImage *arg1 = (wxImage *) 0 ;
18191 buffer arg2 ;
18192 int arg3 ;
18193 void *argp1 = 0 ;
18194 int res1 = 0 ;
18195 Py_ssize_t temp2 ;
18196 PyObject * obj0 = 0 ;
18197 PyObject * obj1 = 0 ;
18198 char * kwnames[] = {
18199 (char *) "self",(char *) "data", NULL
18200 };
18201
18202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18204 if (!SWIG_IsOK(res1)) {
18205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18206 }
18207 arg1 = reinterpret_cast< wxImage * >(argp1);
18208 {
18209 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18210 arg3 = (int)temp2;
18211 }
18212 {
18213 PyThreadState* __tstate = wxPyBeginAllowThreads();
18214 wxImage_SetData(arg1,arg2,arg3);
18215 wxPyEndAllowThreads(__tstate);
18216 if (PyErr_Occurred()) SWIG_fail;
18217 }
18218 resultobj = SWIG_Py_Void();
18219 return resultobj;
18220 fail:
18221 return NULL;
18222 }
18223
18224
18225 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18226 PyObject *resultobj = 0;
18227 wxImage *arg1 = (wxImage *) 0 ;
18228 PyObject *result = 0 ;
18229 void *argp1 = 0 ;
18230 int res1 = 0 ;
18231 PyObject *swig_obj[1] ;
18232
18233 if (!args) SWIG_fail;
18234 swig_obj[0] = args;
18235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18236 if (!SWIG_IsOK(res1)) {
18237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18238 }
18239 arg1 = reinterpret_cast< wxImage * >(argp1);
18240 {
18241 PyThreadState* __tstate = wxPyBeginAllowThreads();
18242 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18243 wxPyEndAllowThreads(__tstate);
18244 if (PyErr_Occurred()) SWIG_fail;
18245 }
18246 resultobj = result;
18247 return resultobj;
18248 fail:
18249 return NULL;
18250 }
18251
18252
18253 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18254 PyObject *resultobj = 0;
18255 wxImage *arg1 = (wxImage *) 0 ;
18256 buffer arg2 ;
18257 int arg3 ;
18258 void *argp1 = 0 ;
18259 int res1 = 0 ;
18260 Py_ssize_t temp2 ;
18261 PyObject * obj0 = 0 ;
18262 PyObject * obj1 = 0 ;
18263 char * kwnames[] = {
18264 (char *) "self",(char *) "data", NULL
18265 };
18266
18267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18269 if (!SWIG_IsOK(res1)) {
18270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18271 }
18272 arg1 = reinterpret_cast< wxImage * >(argp1);
18273 {
18274 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18275 arg3 = (int)temp2;
18276 }
18277 {
18278 PyThreadState* __tstate = wxPyBeginAllowThreads();
18279 wxImage_SetDataBuffer(arg1,arg2,arg3);
18280 wxPyEndAllowThreads(__tstate);
18281 if (PyErr_Occurred()) SWIG_fail;
18282 }
18283 resultobj = SWIG_Py_Void();
18284 return resultobj;
18285 fail:
18286 return NULL;
18287 }
18288
18289
18290 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18291 PyObject *resultobj = 0;
18292 wxImage *arg1 = (wxImage *) 0 ;
18293 PyObject *result = 0 ;
18294 void *argp1 = 0 ;
18295 int res1 = 0 ;
18296 PyObject *swig_obj[1] ;
18297
18298 if (!args) SWIG_fail;
18299 swig_obj[0] = args;
18300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18301 if (!SWIG_IsOK(res1)) {
18302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18303 }
18304 arg1 = reinterpret_cast< wxImage * >(argp1);
18305 {
18306 PyThreadState* __tstate = wxPyBeginAllowThreads();
18307 result = (PyObject *)wxImage_GetAlphaData(arg1);
18308 wxPyEndAllowThreads(__tstate);
18309 if (PyErr_Occurred()) SWIG_fail;
18310 }
18311 resultobj = result;
18312 return resultobj;
18313 fail:
18314 return NULL;
18315 }
18316
18317
18318 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18319 PyObject *resultobj = 0;
18320 wxImage *arg1 = (wxImage *) 0 ;
18321 buffer arg2 ;
18322 int arg3 ;
18323 void *argp1 = 0 ;
18324 int res1 = 0 ;
18325 Py_ssize_t temp2 ;
18326 PyObject * obj0 = 0 ;
18327 PyObject * obj1 = 0 ;
18328 char * kwnames[] = {
18329 (char *) "self",(char *) "alpha", NULL
18330 };
18331
18332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18334 if (!SWIG_IsOK(res1)) {
18335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18336 }
18337 arg1 = reinterpret_cast< wxImage * >(argp1);
18338 {
18339 if (obj1 != Py_None) {
18340 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18341 arg3 = (int)temp2;
18342 }
18343 }
18344 {
18345 PyThreadState* __tstate = wxPyBeginAllowThreads();
18346 wxImage_SetAlphaData(arg1,arg2,arg3);
18347 wxPyEndAllowThreads(__tstate);
18348 if (PyErr_Occurred()) SWIG_fail;
18349 }
18350 resultobj = SWIG_Py_Void();
18351 return resultobj;
18352 fail:
18353 return NULL;
18354 }
18355
18356
18357 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18358 PyObject *resultobj = 0;
18359 wxImage *arg1 = (wxImage *) 0 ;
18360 PyObject *result = 0 ;
18361 void *argp1 = 0 ;
18362 int res1 = 0 ;
18363 PyObject *swig_obj[1] ;
18364
18365 if (!args) SWIG_fail;
18366 swig_obj[0] = args;
18367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18368 if (!SWIG_IsOK(res1)) {
18369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18370 }
18371 arg1 = reinterpret_cast< wxImage * >(argp1);
18372 {
18373 PyThreadState* __tstate = wxPyBeginAllowThreads();
18374 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18375 wxPyEndAllowThreads(__tstate);
18376 if (PyErr_Occurred()) SWIG_fail;
18377 }
18378 resultobj = result;
18379 return resultobj;
18380 fail:
18381 return NULL;
18382 }
18383
18384
18385 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18386 PyObject *resultobj = 0;
18387 wxImage *arg1 = (wxImage *) 0 ;
18388 buffer arg2 ;
18389 int arg3 ;
18390 void *argp1 = 0 ;
18391 int res1 = 0 ;
18392 Py_ssize_t temp2 ;
18393 PyObject * obj0 = 0 ;
18394 PyObject * obj1 = 0 ;
18395 char * kwnames[] = {
18396 (char *) "self",(char *) "alpha", NULL
18397 };
18398
18399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18401 if (!SWIG_IsOK(res1)) {
18402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18403 }
18404 arg1 = reinterpret_cast< wxImage * >(argp1);
18405 {
18406 if (obj1 != Py_None) {
18407 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18408 arg3 = (int)temp2;
18409 }
18410 }
18411 {
18412 PyThreadState* __tstate = wxPyBeginAllowThreads();
18413 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18414 wxPyEndAllowThreads(__tstate);
18415 if (PyErr_Occurred()) SWIG_fail;
18416 }
18417 resultobj = SWIG_Py_Void();
18418 return resultobj;
18419 fail:
18420 return NULL;
18421 }
18422
18423
18424 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18425 PyObject *resultobj = 0;
18426 wxImage *arg1 = (wxImage *) 0 ;
18427 byte arg2 ;
18428 byte arg3 ;
18429 byte arg4 ;
18430 void *argp1 = 0 ;
18431 int res1 = 0 ;
18432 unsigned char val2 ;
18433 int ecode2 = 0 ;
18434 unsigned char val3 ;
18435 int ecode3 = 0 ;
18436 unsigned char val4 ;
18437 int ecode4 = 0 ;
18438 PyObject * obj0 = 0 ;
18439 PyObject * obj1 = 0 ;
18440 PyObject * obj2 = 0 ;
18441 PyObject * obj3 = 0 ;
18442 char * kwnames[] = {
18443 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18444 };
18445
18446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18448 if (!SWIG_IsOK(res1)) {
18449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18450 }
18451 arg1 = reinterpret_cast< wxImage * >(argp1);
18452 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18453 if (!SWIG_IsOK(ecode2)) {
18454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18455 }
18456 arg2 = static_cast< byte >(val2);
18457 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18458 if (!SWIG_IsOK(ecode3)) {
18459 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18460 }
18461 arg3 = static_cast< byte >(val3);
18462 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18463 if (!SWIG_IsOK(ecode4)) {
18464 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18465 }
18466 arg4 = static_cast< byte >(val4);
18467 {
18468 PyThreadState* __tstate = wxPyBeginAllowThreads();
18469 (arg1)->SetMaskColour(arg2,arg3,arg4);
18470 wxPyEndAllowThreads(__tstate);
18471 if (PyErr_Occurred()) SWIG_fail;
18472 }
18473 resultobj = SWIG_Py_Void();
18474 return resultobj;
18475 fail:
18476 return NULL;
18477 }
18478
18479
18480 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18481 PyObject *resultobj = 0;
18482 wxImage *arg1 = (wxImage *) 0 ;
18483 byte *arg2 = (byte *) 0 ;
18484 byte *arg3 = (byte *) 0 ;
18485 byte *arg4 = (byte *) 0 ;
18486 void *argp1 = 0 ;
18487 int res1 = 0 ;
18488 byte temp2 ;
18489 int res2 = SWIG_TMPOBJ ;
18490 byte temp3 ;
18491 int res3 = SWIG_TMPOBJ ;
18492 byte temp4 ;
18493 int res4 = SWIG_TMPOBJ ;
18494 PyObject *swig_obj[1] ;
18495
18496 arg2 = &temp2;
18497 arg3 = &temp3;
18498 arg4 = &temp4;
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_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18504 }
18505 arg1 = reinterpret_cast< wxImage * >(argp1);
18506 {
18507 PyThreadState* __tstate = wxPyBeginAllowThreads();
18508 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18509 wxPyEndAllowThreads(__tstate);
18510 if (PyErr_Occurred()) SWIG_fail;
18511 }
18512 resultobj = SWIG_Py_Void();
18513 if (SWIG_IsTmpObj(res2)) {
18514 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18515 } else {
18516 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18517 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18518 }
18519 if (SWIG_IsTmpObj(res3)) {
18520 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18521 } else {
18522 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18523 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18524 }
18525 if (SWIG_IsTmpObj(res4)) {
18526 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18527 } else {
18528 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18529 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18530 }
18531 return resultobj;
18532 fail:
18533 return NULL;
18534 }
18535
18536
18537 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18538 PyObject *resultobj = 0;
18539 wxImage *arg1 = (wxImage *) 0 ;
18540 byte result;
18541 void *argp1 = 0 ;
18542 int res1 = 0 ;
18543 PyObject *swig_obj[1] ;
18544
18545 if (!args) SWIG_fail;
18546 swig_obj[0] = args;
18547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18548 if (!SWIG_IsOK(res1)) {
18549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18550 }
18551 arg1 = reinterpret_cast< wxImage * >(argp1);
18552 {
18553 PyThreadState* __tstate = wxPyBeginAllowThreads();
18554 result = (byte)(arg1)->GetMaskRed();
18555 wxPyEndAllowThreads(__tstate);
18556 if (PyErr_Occurred()) SWIG_fail;
18557 }
18558 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18559 return resultobj;
18560 fail:
18561 return NULL;
18562 }
18563
18564
18565 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18566 PyObject *resultobj = 0;
18567 wxImage *arg1 = (wxImage *) 0 ;
18568 byte result;
18569 void *argp1 = 0 ;
18570 int res1 = 0 ;
18571 PyObject *swig_obj[1] ;
18572
18573 if (!args) SWIG_fail;
18574 swig_obj[0] = args;
18575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18576 if (!SWIG_IsOK(res1)) {
18577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18578 }
18579 arg1 = reinterpret_cast< wxImage * >(argp1);
18580 {
18581 PyThreadState* __tstate = wxPyBeginAllowThreads();
18582 result = (byte)(arg1)->GetMaskGreen();
18583 wxPyEndAllowThreads(__tstate);
18584 if (PyErr_Occurred()) SWIG_fail;
18585 }
18586 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18587 return resultobj;
18588 fail:
18589 return NULL;
18590 }
18591
18592
18593 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18594 PyObject *resultobj = 0;
18595 wxImage *arg1 = (wxImage *) 0 ;
18596 byte result;
18597 void *argp1 = 0 ;
18598 int res1 = 0 ;
18599 PyObject *swig_obj[1] ;
18600
18601 if (!args) SWIG_fail;
18602 swig_obj[0] = args;
18603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18604 if (!SWIG_IsOK(res1)) {
18605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18606 }
18607 arg1 = reinterpret_cast< wxImage * >(argp1);
18608 {
18609 PyThreadState* __tstate = wxPyBeginAllowThreads();
18610 result = (byte)(arg1)->GetMaskBlue();
18611 wxPyEndAllowThreads(__tstate);
18612 if (PyErr_Occurred()) SWIG_fail;
18613 }
18614 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18615 return resultobj;
18616 fail:
18617 return NULL;
18618 }
18619
18620
18621 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18622 PyObject *resultobj = 0;
18623 wxImage *arg1 = (wxImage *) 0 ;
18624 bool arg2 = (bool) true ;
18625 void *argp1 = 0 ;
18626 int res1 = 0 ;
18627 bool val2 ;
18628 int ecode2 = 0 ;
18629 PyObject * obj0 = 0 ;
18630 PyObject * obj1 = 0 ;
18631 char * kwnames[] = {
18632 (char *) "self",(char *) "mask", NULL
18633 };
18634
18635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18637 if (!SWIG_IsOK(res1)) {
18638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18639 }
18640 arg1 = reinterpret_cast< wxImage * >(argp1);
18641 if (obj1) {
18642 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18643 if (!SWIG_IsOK(ecode2)) {
18644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18645 }
18646 arg2 = static_cast< bool >(val2);
18647 }
18648 {
18649 PyThreadState* __tstate = wxPyBeginAllowThreads();
18650 (arg1)->SetMask(arg2);
18651 wxPyEndAllowThreads(__tstate);
18652 if (PyErr_Occurred()) SWIG_fail;
18653 }
18654 resultobj = SWIG_Py_Void();
18655 return resultobj;
18656 fail:
18657 return NULL;
18658 }
18659
18660
18661 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18662 PyObject *resultobj = 0;
18663 wxImage *arg1 = (wxImage *) 0 ;
18664 bool result;
18665 void *argp1 = 0 ;
18666 int res1 = 0 ;
18667 PyObject *swig_obj[1] ;
18668
18669 if (!args) SWIG_fail;
18670 swig_obj[0] = args;
18671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18672 if (!SWIG_IsOK(res1)) {
18673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18674 }
18675 arg1 = reinterpret_cast< wxImage * >(argp1);
18676 {
18677 PyThreadState* __tstate = wxPyBeginAllowThreads();
18678 result = (bool)(arg1)->HasMask();
18679 wxPyEndAllowThreads(__tstate);
18680 if (PyErr_Occurred()) SWIG_fail;
18681 }
18682 {
18683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18684 }
18685 return resultobj;
18686 fail:
18687 return NULL;
18688 }
18689
18690
18691 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18692 PyObject *resultobj = 0;
18693 wxImage *arg1 = (wxImage *) 0 ;
18694 double arg2 ;
18695 wxPoint *arg3 = 0 ;
18696 bool arg4 = (bool) true ;
18697 wxPoint *arg5 = (wxPoint *) NULL ;
18698 SwigValueWrapper<wxImage > result;
18699 void *argp1 = 0 ;
18700 int res1 = 0 ;
18701 double val2 ;
18702 int ecode2 = 0 ;
18703 wxPoint temp3 ;
18704 bool val4 ;
18705 int ecode4 = 0 ;
18706 void *argp5 = 0 ;
18707 int res5 = 0 ;
18708 PyObject * obj0 = 0 ;
18709 PyObject * obj1 = 0 ;
18710 PyObject * obj2 = 0 ;
18711 PyObject * obj3 = 0 ;
18712 PyObject * obj4 = 0 ;
18713 char * kwnames[] = {
18714 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18715 };
18716
18717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18719 if (!SWIG_IsOK(res1)) {
18720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18721 }
18722 arg1 = reinterpret_cast< wxImage * >(argp1);
18723 ecode2 = SWIG_AsVal_double(obj1, &val2);
18724 if (!SWIG_IsOK(ecode2)) {
18725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18726 }
18727 arg2 = static_cast< double >(val2);
18728 {
18729 arg3 = &temp3;
18730 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18731 }
18732 if (obj3) {
18733 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18734 if (!SWIG_IsOK(ecode4)) {
18735 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18736 }
18737 arg4 = static_cast< bool >(val4);
18738 }
18739 if (obj4) {
18740 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18741 if (!SWIG_IsOK(res5)) {
18742 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
18743 }
18744 arg5 = reinterpret_cast< wxPoint * >(argp5);
18745 }
18746 {
18747 PyThreadState* __tstate = wxPyBeginAllowThreads();
18748 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18749 wxPyEndAllowThreads(__tstate);
18750 if (PyErr_Occurred()) SWIG_fail;
18751 }
18752 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18753 return resultobj;
18754 fail:
18755 return NULL;
18756 }
18757
18758
18759 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18760 PyObject *resultobj = 0;
18761 wxImage *arg1 = (wxImage *) 0 ;
18762 bool arg2 = (bool) true ;
18763 SwigValueWrapper<wxImage > result;
18764 void *argp1 = 0 ;
18765 int res1 = 0 ;
18766 bool val2 ;
18767 int ecode2 = 0 ;
18768 PyObject * obj0 = 0 ;
18769 PyObject * obj1 = 0 ;
18770 char * kwnames[] = {
18771 (char *) "self",(char *) "clockwise", NULL
18772 };
18773
18774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18776 if (!SWIG_IsOK(res1)) {
18777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18778 }
18779 arg1 = reinterpret_cast< wxImage * >(argp1);
18780 if (obj1) {
18781 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18782 if (!SWIG_IsOK(ecode2)) {
18783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18784 }
18785 arg2 = static_cast< bool >(val2);
18786 }
18787 {
18788 PyThreadState* __tstate = wxPyBeginAllowThreads();
18789 result = (arg1)->Rotate90(arg2);
18790 wxPyEndAllowThreads(__tstate);
18791 if (PyErr_Occurred()) SWIG_fail;
18792 }
18793 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18794 return resultobj;
18795 fail:
18796 return NULL;
18797 }
18798
18799
18800 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18801 PyObject *resultobj = 0;
18802 wxImage *arg1 = (wxImage *) 0 ;
18803 bool arg2 = (bool) true ;
18804 SwigValueWrapper<wxImage > result;
18805 void *argp1 = 0 ;
18806 int res1 = 0 ;
18807 bool val2 ;
18808 int ecode2 = 0 ;
18809 PyObject * obj0 = 0 ;
18810 PyObject * obj1 = 0 ;
18811 char * kwnames[] = {
18812 (char *) "self",(char *) "horizontally", NULL
18813 };
18814
18815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18817 if (!SWIG_IsOK(res1)) {
18818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18819 }
18820 arg1 = reinterpret_cast< wxImage * >(argp1);
18821 if (obj1) {
18822 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18823 if (!SWIG_IsOK(ecode2)) {
18824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18825 }
18826 arg2 = static_cast< bool >(val2);
18827 }
18828 {
18829 PyThreadState* __tstate = wxPyBeginAllowThreads();
18830 result = (arg1)->Mirror(arg2);
18831 wxPyEndAllowThreads(__tstate);
18832 if (PyErr_Occurred()) SWIG_fail;
18833 }
18834 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18835 return resultobj;
18836 fail:
18837 return NULL;
18838 }
18839
18840
18841 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18842 PyObject *resultobj = 0;
18843 wxImage *arg1 = (wxImage *) 0 ;
18844 byte arg2 ;
18845 byte arg3 ;
18846 byte arg4 ;
18847 byte arg5 ;
18848 byte arg6 ;
18849 byte arg7 ;
18850 void *argp1 = 0 ;
18851 int res1 = 0 ;
18852 unsigned char val2 ;
18853 int ecode2 = 0 ;
18854 unsigned char val3 ;
18855 int ecode3 = 0 ;
18856 unsigned char val4 ;
18857 int ecode4 = 0 ;
18858 unsigned char val5 ;
18859 int ecode5 = 0 ;
18860 unsigned char val6 ;
18861 int ecode6 = 0 ;
18862 unsigned char val7 ;
18863 int ecode7 = 0 ;
18864 PyObject * obj0 = 0 ;
18865 PyObject * obj1 = 0 ;
18866 PyObject * obj2 = 0 ;
18867 PyObject * obj3 = 0 ;
18868 PyObject * obj4 = 0 ;
18869 PyObject * obj5 = 0 ;
18870 PyObject * obj6 = 0 ;
18871 char * kwnames[] = {
18872 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18873 };
18874
18875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18877 if (!SWIG_IsOK(res1)) {
18878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18879 }
18880 arg1 = reinterpret_cast< wxImage * >(argp1);
18881 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18882 if (!SWIG_IsOK(ecode2)) {
18883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18884 }
18885 arg2 = static_cast< byte >(val2);
18886 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18887 if (!SWIG_IsOK(ecode3)) {
18888 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18889 }
18890 arg3 = static_cast< byte >(val3);
18891 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18892 if (!SWIG_IsOK(ecode4)) {
18893 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18894 }
18895 arg4 = static_cast< byte >(val4);
18896 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18897 if (!SWIG_IsOK(ecode5)) {
18898 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18899 }
18900 arg5 = static_cast< byte >(val5);
18901 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18902 if (!SWIG_IsOK(ecode6)) {
18903 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18904 }
18905 arg6 = static_cast< byte >(val6);
18906 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18907 if (!SWIG_IsOK(ecode7)) {
18908 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18909 }
18910 arg7 = static_cast< byte >(val7);
18911 {
18912 PyThreadState* __tstate = wxPyBeginAllowThreads();
18913 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18914 wxPyEndAllowThreads(__tstate);
18915 if (PyErr_Occurred()) SWIG_fail;
18916 }
18917 resultobj = SWIG_Py_Void();
18918 return resultobj;
18919 fail:
18920 return NULL;
18921 }
18922
18923
18924 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18925 PyObject *resultobj = 0;
18926 wxImage *arg1 = (wxImage *) 0 ;
18927 double arg2 = (double) 0.299 ;
18928 double arg3 = (double) 0.587 ;
18929 double arg4 = (double) 0.114 ;
18930 SwigValueWrapper<wxImage > result;
18931 void *argp1 = 0 ;
18932 int res1 = 0 ;
18933 double val2 ;
18934 int ecode2 = 0 ;
18935 double val3 ;
18936 int ecode3 = 0 ;
18937 double val4 ;
18938 int ecode4 = 0 ;
18939 PyObject * obj0 = 0 ;
18940 PyObject * obj1 = 0 ;
18941 PyObject * obj2 = 0 ;
18942 PyObject * obj3 = 0 ;
18943 char * kwnames[] = {
18944 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
18945 };
18946
18947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18949 if (!SWIG_IsOK(res1)) {
18950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
18951 }
18952 arg1 = reinterpret_cast< wxImage * >(argp1);
18953 if (obj1) {
18954 ecode2 = SWIG_AsVal_double(obj1, &val2);
18955 if (!SWIG_IsOK(ecode2)) {
18956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
18957 }
18958 arg2 = static_cast< double >(val2);
18959 }
18960 if (obj2) {
18961 ecode3 = SWIG_AsVal_double(obj2, &val3);
18962 if (!SWIG_IsOK(ecode3)) {
18963 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
18964 }
18965 arg3 = static_cast< double >(val3);
18966 }
18967 if (obj3) {
18968 ecode4 = SWIG_AsVal_double(obj3, &val4);
18969 if (!SWIG_IsOK(ecode4)) {
18970 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
18971 }
18972 arg4 = static_cast< double >(val4);
18973 }
18974 {
18975 PyThreadState* __tstate = wxPyBeginAllowThreads();
18976 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
18977 wxPyEndAllowThreads(__tstate);
18978 if (PyErr_Occurred()) SWIG_fail;
18979 }
18980 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18981 return resultobj;
18982 fail:
18983 return NULL;
18984 }
18985
18986
18987 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18988 PyObject *resultobj = 0;
18989 wxImage *arg1 = (wxImage *) 0 ;
18990 byte arg2 ;
18991 byte arg3 ;
18992 byte arg4 ;
18993 SwigValueWrapper<wxImage > result;
18994 void *argp1 = 0 ;
18995 int res1 = 0 ;
18996 unsigned char val2 ;
18997 int ecode2 = 0 ;
18998 unsigned char val3 ;
18999 int ecode3 = 0 ;
19000 unsigned char val4 ;
19001 int ecode4 = 0 ;
19002 PyObject * obj0 = 0 ;
19003 PyObject * obj1 = 0 ;
19004 PyObject * obj2 = 0 ;
19005 PyObject * obj3 = 0 ;
19006 char * kwnames[] = {
19007 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19008 };
19009
19010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19012 if (!SWIG_IsOK(res1)) {
19013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19014 }
19015 arg1 = reinterpret_cast< wxImage * >(argp1);
19016 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19017 if (!SWIG_IsOK(ecode2)) {
19018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19019 }
19020 arg2 = static_cast< byte >(val2);
19021 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19022 if (!SWIG_IsOK(ecode3)) {
19023 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19024 }
19025 arg3 = static_cast< byte >(val3);
19026 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19027 if (!SWIG_IsOK(ecode4)) {
19028 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19029 }
19030 arg4 = static_cast< byte >(val4);
19031 {
19032 PyThreadState* __tstate = wxPyBeginAllowThreads();
19033 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19034 wxPyEndAllowThreads(__tstate);
19035 if (PyErr_Occurred()) SWIG_fail;
19036 }
19037 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19038 return resultobj;
19039 fail:
19040 return NULL;
19041 }
19042
19043
19044 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19045 PyObject *resultobj = 0;
19046 wxImage *arg1 = (wxImage *) 0 ;
19047 wxString *arg2 = 0 ;
19048 wxString *arg3 = 0 ;
19049 void *argp1 = 0 ;
19050 int res1 = 0 ;
19051 bool temp2 = false ;
19052 bool temp3 = false ;
19053 PyObject * obj0 = 0 ;
19054 PyObject * obj1 = 0 ;
19055 PyObject * obj2 = 0 ;
19056 char * kwnames[] = {
19057 (char *) "self",(char *) "name",(char *) "value", NULL
19058 };
19059
19060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19062 if (!SWIG_IsOK(res1)) {
19063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19064 }
19065 arg1 = reinterpret_cast< wxImage * >(argp1);
19066 {
19067 arg2 = wxString_in_helper(obj1);
19068 if (arg2 == NULL) SWIG_fail;
19069 temp2 = true;
19070 }
19071 {
19072 arg3 = wxString_in_helper(obj2);
19073 if (arg3 == NULL) SWIG_fail;
19074 temp3 = true;
19075 }
19076 {
19077 PyThreadState* __tstate = wxPyBeginAllowThreads();
19078 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19079 wxPyEndAllowThreads(__tstate);
19080 if (PyErr_Occurred()) SWIG_fail;
19081 }
19082 resultobj = SWIG_Py_Void();
19083 {
19084 if (temp2)
19085 delete arg2;
19086 }
19087 {
19088 if (temp3)
19089 delete arg3;
19090 }
19091 return resultobj;
19092 fail:
19093 {
19094 if (temp2)
19095 delete arg2;
19096 }
19097 {
19098 if (temp3)
19099 delete arg3;
19100 }
19101 return NULL;
19102 }
19103
19104
19105 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19106 PyObject *resultobj = 0;
19107 wxImage *arg1 = (wxImage *) 0 ;
19108 wxString *arg2 = 0 ;
19109 int arg3 ;
19110 void *argp1 = 0 ;
19111 int res1 = 0 ;
19112 bool temp2 = false ;
19113 int val3 ;
19114 int ecode3 = 0 ;
19115 PyObject * obj0 = 0 ;
19116 PyObject * obj1 = 0 ;
19117 PyObject * obj2 = 0 ;
19118 char * kwnames[] = {
19119 (char *) "self",(char *) "name",(char *) "value", NULL
19120 };
19121
19122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19124 if (!SWIG_IsOK(res1)) {
19125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19126 }
19127 arg1 = reinterpret_cast< wxImage * >(argp1);
19128 {
19129 arg2 = wxString_in_helper(obj1);
19130 if (arg2 == NULL) SWIG_fail;
19131 temp2 = true;
19132 }
19133 ecode3 = SWIG_AsVal_int(obj2, &val3);
19134 if (!SWIG_IsOK(ecode3)) {
19135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19136 }
19137 arg3 = static_cast< int >(val3);
19138 {
19139 PyThreadState* __tstate = wxPyBeginAllowThreads();
19140 (arg1)->SetOption((wxString const &)*arg2,arg3);
19141 wxPyEndAllowThreads(__tstate);
19142 if (PyErr_Occurred()) SWIG_fail;
19143 }
19144 resultobj = SWIG_Py_Void();
19145 {
19146 if (temp2)
19147 delete arg2;
19148 }
19149 return resultobj;
19150 fail:
19151 {
19152 if (temp2)
19153 delete arg2;
19154 }
19155 return NULL;
19156 }
19157
19158
19159 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19160 PyObject *resultobj = 0;
19161 wxImage *arg1 = (wxImage *) 0 ;
19162 wxString *arg2 = 0 ;
19163 wxString result;
19164 void *argp1 = 0 ;
19165 int res1 = 0 ;
19166 bool temp2 = false ;
19167 PyObject * obj0 = 0 ;
19168 PyObject * obj1 = 0 ;
19169 char * kwnames[] = {
19170 (char *) "self",(char *) "name", NULL
19171 };
19172
19173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19175 if (!SWIG_IsOK(res1)) {
19176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19177 }
19178 arg1 = reinterpret_cast< wxImage * >(argp1);
19179 {
19180 arg2 = wxString_in_helper(obj1);
19181 if (arg2 == NULL) SWIG_fail;
19182 temp2 = true;
19183 }
19184 {
19185 PyThreadState* __tstate = wxPyBeginAllowThreads();
19186 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19187 wxPyEndAllowThreads(__tstate);
19188 if (PyErr_Occurred()) SWIG_fail;
19189 }
19190 {
19191 #if wxUSE_UNICODE
19192 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19193 #else
19194 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19195 #endif
19196 }
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_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19212 PyObject *resultobj = 0;
19213 wxImage *arg1 = (wxImage *) 0 ;
19214 wxString *arg2 = 0 ;
19215 int 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_GetOptionInt",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_GetOptionInt" "', 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 = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19239 wxPyEndAllowThreads(__tstate);
19240 if (PyErr_Occurred()) SWIG_fail;
19241 }
19242 resultobj = SWIG_From_int(static_cast< int >(result));
19243 {
19244 if (temp2)
19245 delete arg2;
19246 }
19247 return resultobj;
19248 fail:
19249 {
19250 if (temp2)
19251 delete arg2;
19252 }
19253 return NULL;
19254 }
19255
19256
19257 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19258 PyObject *resultobj = 0;
19259 wxImage *arg1 = (wxImage *) 0 ;
19260 wxString *arg2 = 0 ;
19261 bool result;
19262 void *argp1 = 0 ;
19263 int res1 = 0 ;
19264 bool temp2 = false ;
19265 PyObject * obj0 = 0 ;
19266 PyObject * obj1 = 0 ;
19267 char * kwnames[] = {
19268 (char *) "self",(char *) "name", NULL
19269 };
19270
19271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19273 if (!SWIG_IsOK(res1)) {
19274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19275 }
19276 arg1 = reinterpret_cast< wxImage * >(argp1);
19277 {
19278 arg2 = wxString_in_helper(obj1);
19279 if (arg2 == NULL) SWIG_fail;
19280 temp2 = true;
19281 }
19282 {
19283 PyThreadState* __tstate = wxPyBeginAllowThreads();
19284 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19285 wxPyEndAllowThreads(__tstate);
19286 if (PyErr_Occurred()) SWIG_fail;
19287 }
19288 {
19289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19290 }
19291 {
19292 if (temp2)
19293 delete arg2;
19294 }
19295 return resultobj;
19296 fail:
19297 {
19298 if (temp2)
19299 delete arg2;
19300 }
19301 return NULL;
19302 }
19303
19304
19305 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19306 PyObject *resultobj = 0;
19307 wxImage *arg1 = (wxImage *) 0 ;
19308 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19309 unsigned long result;
19310 void *argp1 = 0 ;
19311 int res1 = 0 ;
19312 unsigned long val2 ;
19313 int ecode2 = 0 ;
19314 PyObject * obj0 = 0 ;
19315 PyObject * obj1 = 0 ;
19316 char * kwnames[] = {
19317 (char *) "self",(char *) "stopafter", NULL
19318 };
19319
19320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19322 if (!SWIG_IsOK(res1)) {
19323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19324 }
19325 arg1 = reinterpret_cast< wxImage * >(argp1);
19326 if (obj1) {
19327 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19328 if (!SWIG_IsOK(ecode2)) {
19329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19330 }
19331 arg2 = static_cast< unsigned long >(val2);
19332 }
19333 {
19334 PyThreadState* __tstate = wxPyBeginAllowThreads();
19335 result = (unsigned long)(arg1)->CountColours(arg2);
19336 wxPyEndAllowThreads(__tstate);
19337 if (PyErr_Occurred()) SWIG_fail;
19338 }
19339 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19340 return resultobj;
19341 fail:
19342 return NULL;
19343 }
19344
19345
19346 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19347 PyObject *resultobj = 0;
19348 wxImage *arg1 = (wxImage *) 0 ;
19349 wxImageHistogram *arg2 = 0 ;
19350 unsigned long result;
19351 void *argp1 = 0 ;
19352 int res1 = 0 ;
19353 void *argp2 = 0 ;
19354 int res2 = 0 ;
19355 PyObject * obj0 = 0 ;
19356 PyObject * obj1 = 0 ;
19357 char * kwnames[] = {
19358 (char *) "self",(char *) "h", NULL
19359 };
19360
19361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19363 if (!SWIG_IsOK(res1)) {
19364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19365 }
19366 arg1 = reinterpret_cast< wxImage * >(argp1);
19367 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19368 if (!SWIG_IsOK(res2)) {
19369 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19370 }
19371 if (!argp2) {
19372 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19373 }
19374 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19375 {
19376 PyThreadState* __tstate = wxPyBeginAllowThreads();
19377 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19378 wxPyEndAllowThreads(__tstate);
19379 if (PyErr_Occurred()) SWIG_fail;
19380 }
19381 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19382 return resultobj;
19383 fail:
19384 return NULL;
19385 }
19386
19387
19388 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19389 PyObject *resultobj = 0;
19390 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19391 void *argp1 = 0 ;
19392 int res1 = 0 ;
19393 PyObject * obj0 = 0 ;
19394 char * kwnames[] = {
19395 (char *) "handler", NULL
19396 };
19397
19398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19400 if (!SWIG_IsOK(res1)) {
19401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19402 }
19403 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19404 {
19405 PyThreadState* __tstate = wxPyBeginAllowThreads();
19406 wxImage::AddHandler(arg1);
19407 wxPyEndAllowThreads(__tstate);
19408 if (PyErr_Occurred()) SWIG_fail;
19409 }
19410 resultobj = SWIG_Py_Void();
19411 return resultobj;
19412 fail:
19413 return NULL;
19414 }
19415
19416
19417 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19418 PyObject *resultobj = 0;
19419 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19420 void *argp1 = 0 ;
19421 int res1 = 0 ;
19422 PyObject * obj0 = 0 ;
19423 char * kwnames[] = {
19424 (char *) "handler", NULL
19425 };
19426
19427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19429 if (!SWIG_IsOK(res1)) {
19430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19431 }
19432 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19433 {
19434 PyThreadState* __tstate = wxPyBeginAllowThreads();
19435 wxImage::InsertHandler(arg1);
19436 wxPyEndAllowThreads(__tstate);
19437 if (PyErr_Occurred()) SWIG_fail;
19438 }
19439 resultobj = SWIG_Py_Void();
19440 return resultobj;
19441 fail:
19442 return NULL;
19443 }
19444
19445
19446 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19447 PyObject *resultobj = 0;
19448 wxString *arg1 = 0 ;
19449 bool result;
19450 bool temp1 = false ;
19451 PyObject * obj0 = 0 ;
19452 char * kwnames[] = {
19453 (char *) "name", NULL
19454 };
19455
19456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19457 {
19458 arg1 = wxString_in_helper(obj0);
19459 if (arg1 == NULL) SWIG_fail;
19460 temp1 = true;
19461 }
19462 {
19463 PyThreadState* __tstate = wxPyBeginAllowThreads();
19464 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19465 wxPyEndAllowThreads(__tstate);
19466 if (PyErr_Occurred()) SWIG_fail;
19467 }
19468 {
19469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19470 }
19471 {
19472 if (temp1)
19473 delete arg1;
19474 }
19475 return resultobj;
19476 fail:
19477 {
19478 if (temp1)
19479 delete arg1;
19480 }
19481 return NULL;
19482 }
19483
19484
19485 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19486 PyObject *resultobj = 0;
19487 PyObject *result = 0 ;
19488
19489 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19490 {
19491 PyThreadState* __tstate = wxPyBeginAllowThreads();
19492 result = (PyObject *)wxImage_GetHandlers();
19493 wxPyEndAllowThreads(__tstate);
19494 if (PyErr_Occurred()) SWIG_fail;
19495 }
19496 resultobj = result;
19497 return resultobj;
19498 fail:
19499 return NULL;
19500 }
19501
19502
19503 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19504 PyObject *resultobj = 0;
19505 wxString result;
19506
19507 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19508 {
19509 PyThreadState* __tstate = wxPyBeginAllowThreads();
19510 result = wxImage::GetImageExtWildcard();
19511 wxPyEndAllowThreads(__tstate);
19512 if (PyErr_Occurred()) SWIG_fail;
19513 }
19514 {
19515 #if wxUSE_UNICODE
19516 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19517 #else
19518 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19519 #endif
19520 }
19521 return resultobj;
19522 fail:
19523 return NULL;
19524 }
19525
19526
19527 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19528 PyObject *resultobj = 0;
19529 wxImage *arg1 = (wxImage *) 0 ;
19530 int arg2 = (int) -1 ;
19531 wxBitmap result;
19532 void *argp1 = 0 ;
19533 int res1 = 0 ;
19534 int val2 ;
19535 int ecode2 = 0 ;
19536 PyObject * obj0 = 0 ;
19537 PyObject * obj1 = 0 ;
19538 char * kwnames[] = {
19539 (char *) "self",(char *) "depth", NULL
19540 };
19541
19542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19544 if (!SWIG_IsOK(res1)) {
19545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19546 }
19547 arg1 = reinterpret_cast< wxImage * >(argp1);
19548 if (obj1) {
19549 ecode2 = SWIG_AsVal_int(obj1, &val2);
19550 if (!SWIG_IsOK(ecode2)) {
19551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19552 }
19553 arg2 = static_cast< int >(val2);
19554 }
19555 {
19556 if (!wxPyCheckForApp()) SWIG_fail;
19557 PyThreadState* __tstate = wxPyBeginAllowThreads();
19558 result = wxImage_ConvertToBitmap(arg1,arg2);
19559 wxPyEndAllowThreads(__tstate);
19560 if (PyErr_Occurred()) SWIG_fail;
19561 }
19562 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19563 return resultobj;
19564 fail:
19565 return NULL;
19566 }
19567
19568
19569 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19570 PyObject *resultobj = 0;
19571 wxImage *arg1 = (wxImage *) 0 ;
19572 byte arg2 ;
19573 byte arg3 ;
19574 byte arg4 ;
19575 wxBitmap result;
19576 void *argp1 = 0 ;
19577 int res1 = 0 ;
19578 unsigned char val2 ;
19579 int ecode2 = 0 ;
19580 unsigned char val3 ;
19581 int ecode3 = 0 ;
19582 unsigned char val4 ;
19583 int ecode4 = 0 ;
19584 PyObject * obj0 = 0 ;
19585 PyObject * obj1 = 0 ;
19586 PyObject * obj2 = 0 ;
19587 PyObject * obj3 = 0 ;
19588 char * kwnames[] = {
19589 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19590 };
19591
19592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19594 if (!SWIG_IsOK(res1)) {
19595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19596 }
19597 arg1 = reinterpret_cast< wxImage * >(argp1);
19598 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19599 if (!SWIG_IsOK(ecode2)) {
19600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19601 }
19602 arg2 = static_cast< byte >(val2);
19603 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19604 if (!SWIG_IsOK(ecode3)) {
19605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19606 }
19607 arg3 = static_cast< byte >(val3);
19608 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19609 if (!SWIG_IsOK(ecode4)) {
19610 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19611 }
19612 arg4 = static_cast< byte >(val4);
19613 {
19614 if (!wxPyCheckForApp()) SWIG_fail;
19615 PyThreadState* __tstate = wxPyBeginAllowThreads();
19616 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19617 wxPyEndAllowThreads(__tstate);
19618 if (PyErr_Occurred()) SWIG_fail;
19619 }
19620 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19621 return resultobj;
19622 fail:
19623 return NULL;
19624 }
19625
19626
19627 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19628 PyObject *resultobj = 0;
19629 wxImage *arg1 = (wxImage *) 0 ;
19630 double arg2 ;
19631 void *argp1 = 0 ;
19632 int res1 = 0 ;
19633 double val2 ;
19634 int ecode2 = 0 ;
19635 PyObject * obj0 = 0 ;
19636 PyObject * obj1 = 0 ;
19637 char * kwnames[] = {
19638 (char *) "self",(char *) "angle", NULL
19639 };
19640
19641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19643 if (!SWIG_IsOK(res1)) {
19644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19645 }
19646 arg1 = reinterpret_cast< wxImage * >(argp1);
19647 ecode2 = SWIG_AsVal_double(obj1, &val2);
19648 if (!SWIG_IsOK(ecode2)) {
19649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19650 }
19651 arg2 = static_cast< double >(val2);
19652 {
19653 PyThreadState* __tstate = wxPyBeginAllowThreads();
19654 (arg1)->RotateHue(arg2);
19655 wxPyEndAllowThreads(__tstate);
19656 if (PyErr_Occurred()) SWIG_fail;
19657 }
19658 resultobj = SWIG_Py_Void();
19659 return resultobj;
19660 fail:
19661 return NULL;
19662 }
19663
19664
19665 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19666 PyObject *resultobj = 0;
19667 wxImage_RGBValue arg1 ;
19668 wxImage_HSVValue result;
19669 void *argp1 ;
19670 int res1 = 0 ;
19671 PyObject * obj0 = 0 ;
19672 char * kwnames[] = {
19673 (char *) "rgb", NULL
19674 };
19675
19676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19677 {
19678 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19679 if (!SWIG_IsOK(res1)) {
19680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19681 }
19682 if (!argp1) {
19683 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19684 } else {
19685 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19686 arg1 = *temp;
19687 if (SWIG_IsNewObj(res1)) delete temp;
19688 }
19689 }
19690 {
19691 PyThreadState* __tstate = wxPyBeginAllowThreads();
19692 result = wxImage::RGBtoHSV(arg1);
19693 wxPyEndAllowThreads(__tstate);
19694 if (PyErr_Occurred()) SWIG_fail;
19695 }
19696 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19697 return resultobj;
19698 fail:
19699 return NULL;
19700 }
19701
19702
19703 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19704 PyObject *resultobj = 0;
19705 wxImage_HSVValue arg1 ;
19706 wxImage_RGBValue result;
19707 void *argp1 ;
19708 int res1 = 0 ;
19709 PyObject * obj0 = 0 ;
19710 char * kwnames[] = {
19711 (char *) "hsv", NULL
19712 };
19713
19714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19715 {
19716 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19717 if (!SWIG_IsOK(res1)) {
19718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19719 }
19720 if (!argp1) {
19721 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19722 } else {
19723 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19724 arg1 = *temp;
19725 if (SWIG_IsNewObj(res1)) delete temp;
19726 }
19727 }
19728 {
19729 PyThreadState* __tstate = wxPyBeginAllowThreads();
19730 result = wxImage::HSVtoRGB(arg1);
19731 wxPyEndAllowThreads(__tstate);
19732 if (PyErr_Occurred()) SWIG_fail;
19733 }
19734 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19735 return resultobj;
19736 fail:
19737 return NULL;
19738 }
19739
19740
19741 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19742 PyObject *obj;
19743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19744 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19745 return SWIG_Py_Void();
19746 }
19747
19748 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19749 return SWIG_Python_InitShadowInstance(args);
19750 }
19751
19752 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19753 PyObject *resultobj = 0;
19754 int arg1 ;
19755 int arg2 ;
19756 buffer arg3 ;
19757 int arg4 ;
19758 buffer arg5 = (buffer) NULL ;
19759 int arg6 = (int) 0 ;
19760 wxImage *result = 0 ;
19761 int val1 ;
19762 int ecode1 = 0 ;
19763 int val2 ;
19764 int ecode2 = 0 ;
19765 Py_ssize_t temp3 ;
19766 Py_ssize_t temp5 ;
19767 PyObject * obj0 = 0 ;
19768 PyObject * obj1 = 0 ;
19769 PyObject * obj2 = 0 ;
19770 PyObject * obj3 = 0 ;
19771 char * kwnames[] = {
19772 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19773 };
19774
19775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19776 ecode1 = SWIG_AsVal_int(obj0, &val1);
19777 if (!SWIG_IsOK(ecode1)) {
19778 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19779 }
19780 arg1 = static_cast< int >(val1);
19781 ecode2 = SWIG_AsVal_int(obj1, &val2);
19782 if (!SWIG_IsOK(ecode2)) {
19783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19784 }
19785 arg2 = static_cast< int >(val2);
19786 {
19787 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19788 arg4 = (int)temp3;
19789 }
19790 if (obj3) {
19791 {
19792 if (obj3 != Py_None) {
19793 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19794 arg6 = (int)temp5;
19795 }
19796 }
19797 }
19798 {
19799 PyThreadState* __tstate = wxPyBeginAllowThreads();
19800 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19801 wxPyEndAllowThreads(__tstate);
19802 if (PyErr_Occurred()) SWIG_fail;
19803 }
19804 {
19805 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19806 }
19807 return resultobj;
19808 fail:
19809 return NULL;
19810 }
19811
19812
19813 SWIGINTERN int NullImage_set(PyObject *) {
19814 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19815 return 1;
19816 }
19817
19818
19819 SWIGINTERN PyObject *NullImage_get(void) {
19820 PyObject *pyobj = 0;
19821
19822 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19823 return pyobj;
19824 }
19825
19826
19827 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19828 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19829 return 1;
19830 }
19831
19832
19833 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19834 PyObject *pyobj = 0;
19835
19836 {
19837 #if wxUSE_UNICODE
19838 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19839 #else
19840 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19841 #endif
19842 }
19843 return pyobj;
19844 }
19845
19846
19847 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19848 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19849 return 1;
19850 }
19851
19852
19853 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19854 PyObject *pyobj = 0;
19855
19856 {
19857 #if wxUSE_UNICODE
19858 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19859 #else
19860 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19861 #endif
19862 }
19863 return pyobj;
19864 }
19865
19866
19867 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19868 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19869 return 1;
19870 }
19871
19872
19873 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19874 PyObject *pyobj = 0;
19875
19876 {
19877 #if wxUSE_UNICODE
19878 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19879 #else
19880 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19881 #endif
19882 }
19883 return pyobj;
19884 }
19885
19886
19887 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19888 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19889 return 1;
19890 }
19891
19892
19893 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19894 PyObject *pyobj = 0;
19895
19896 {
19897 #if wxUSE_UNICODE
19898 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19899 #else
19900 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19901 #endif
19902 }
19903 return pyobj;
19904 }
19905
19906
19907 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19908 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19909 return 1;
19910 }
19911
19912
19913 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19914 PyObject *pyobj = 0;
19915
19916 {
19917 #if wxUSE_UNICODE
19918 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19919 #else
19920 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19921 #endif
19922 }
19923 return pyobj;
19924 }
19925
19926
19927 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
19928 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
19929 return 1;
19930 }
19931
19932
19933 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
19934 PyObject *pyobj = 0;
19935
19936 {
19937 #if wxUSE_UNICODE
19938 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19939 #else
19940 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19941 #endif
19942 }
19943 return pyobj;
19944 }
19945
19946
19947 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
19948 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
19949 return 1;
19950 }
19951
19952
19953 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
19954 PyObject *pyobj = 0;
19955
19956 {
19957 #if wxUSE_UNICODE
19958 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19959 #else
19960 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19961 #endif
19962 }
19963 return pyobj;
19964 }
19965
19966
19967 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
19968 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
19969 return 1;
19970 }
19971
19972
19973 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
19974 PyObject *pyobj = 0;
19975
19976 {
19977 #if wxUSE_UNICODE
19978 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19979 #else
19980 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19981 #endif
19982 }
19983 return pyobj;
19984 }
19985
19986
19987 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
19988 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
19989 return 1;
19990 }
19991
19992
19993 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
19994 PyObject *pyobj = 0;
19995
19996 {
19997 #if wxUSE_UNICODE
19998 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
19999 #else
20000 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20001 #endif
20002 }
20003 return pyobj;
20004 }
20005
20006
20007 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
20008 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
20009 return 1;
20010 }
20011
20012
20013 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20014 PyObject *pyobj = 0;
20015
20016 {
20017 #if wxUSE_UNICODE
20018 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20019 #else
20020 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20021 #endif
20022 }
20023 return pyobj;
20024 }
20025
20026
20027 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20028 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20029 return 1;
20030 }
20031
20032
20033 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20034 PyObject *pyobj = 0;
20035
20036 {
20037 #if wxUSE_UNICODE
20038 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20039 #else
20040 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20041 #endif
20042 }
20043 return pyobj;
20044 }
20045
20046
20047 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20048 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20049 return 1;
20050 }
20051
20052
20053 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20054 PyObject *pyobj = 0;
20055
20056 {
20057 #if wxUSE_UNICODE
20058 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20059 #else
20060 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20061 #endif
20062 }
20063 return pyobj;
20064 }
20065
20066
20067 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20068 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20069 return 1;
20070 }
20071
20072
20073 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20074 PyObject *pyobj = 0;
20075
20076 {
20077 #if wxUSE_UNICODE
20078 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20079 #else
20080 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20081 #endif
20082 }
20083 return pyobj;
20084 }
20085
20086
20087 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20088 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20089 return 1;
20090 }
20091
20092
20093 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20094 PyObject *pyobj = 0;
20095
20096 {
20097 #if wxUSE_UNICODE
20098 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20099 #else
20100 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20101 #endif
20102 }
20103 return pyobj;
20104 }
20105
20106
20107 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20108 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20109 return 1;
20110 }
20111
20112
20113 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20114 PyObject *pyobj = 0;
20115
20116 {
20117 #if wxUSE_UNICODE
20118 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20119 #else
20120 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20121 #endif
20122 }
20123 return pyobj;
20124 }
20125
20126
20127 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20128 PyObject *resultobj = 0;
20129 wxBMPHandler *result = 0 ;
20130
20131 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20132 {
20133 PyThreadState* __tstate = wxPyBeginAllowThreads();
20134 result = (wxBMPHandler *)new wxBMPHandler();
20135 wxPyEndAllowThreads(__tstate);
20136 if (PyErr_Occurred()) SWIG_fail;
20137 }
20138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20139 return resultobj;
20140 fail:
20141 return NULL;
20142 }
20143
20144
20145 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20146 PyObject *obj;
20147 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20148 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20149 return SWIG_Py_Void();
20150 }
20151
20152 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20153 return SWIG_Python_InitShadowInstance(args);
20154 }
20155
20156 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20157 PyObject *resultobj = 0;
20158 wxICOHandler *result = 0 ;
20159
20160 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20161 {
20162 PyThreadState* __tstate = wxPyBeginAllowThreads();
20163 result = (wxICOHandler *)new wxICOHandler();
20164 wxPyEndAllowThreads(__tstate);
20165 if (PyErr_Occurred()) SWIG_fail;
20166 }
20167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20168 return resultobj;
20169 fail:
20170 return NULL;
20171 }
20172
20173
20174 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20175 PyObject *obj;
20176 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20177 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20178 return SWIG_Py_Void();
20179 }
20180
20181 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20182 return SWIG_Python_InitShadowInstance(args);
20183 }
20184
20185 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20186 PyObject *resultobj = 0;
20187 wxCURHandler *result = 0 ;
20188
20189 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20190 {
20191 PyThreadState* __tstate = wxPyBeginAllowThreads();
20192 result = (wxCURHandler *)new wxCURHandler();
20193 wxPyEndAllowThreads(__tstate);
20194 if (PyErr_Occurred()) SWIG_fail;
20195 }
20196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20197 return resultobj;
20198 fail:
20199 return NULL;
20200 }
20201
20202
20203 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20204 PyObject *obj;
20205 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20206 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20207 return SWIG_Py_Void();
20208 }
20209
20210 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20211 return SWIG_Python_InitShadowInstance(args);
20212 }
20213
20214 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20215 PyObject *resultobj = 0;
20216 wxANIHandler *result = 0 ;
20217
20218 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20219 {
20220 PyThreadState* __tstate = wxPyBeginAllowThreads();
20221 result = (wxANIHandler *)new wxANIHandler();
20222 wxPyEndAllowThreads(__tstate);
20223 if (PyErr_Occurred()) SWIG_fail;
20224 }
20225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20226 return resultobj;
20227 fail:
20228 return NULL;
20229 }
20230
20231
20232 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20233 PyObject *obj;
20234 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20235 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20236 return SWIG_Py_Void();
20237 }
20238
20239 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20240 return SWIG_Python_InitShadowInstance(args);
20241 }
20242
20243 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20244 PyObject *resultobj = 0;
20245 wxPNGHandler *result = 0 ;
20246
20247 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20248 {
20249 PyThreadState* __tstate = wxPyBeginAllowThreads();
20250 result = (wxPNGHandler *)new wxPNGHandler();
20251 wxPyEndAllowThreads(__tstate);
20252 if (PyErr_Occurred()) SWIG_fail;
20253 }
20254 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20255 return resultobj;
20256 fail:
20257 return NULL;
20258 }
20259
20260
20261 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20262 PyObject *obj;
20263 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20264 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20265 return SWIG_Py_Void();
20266 }
20267
20268 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20269 return SWIG_Python_InitShadowInstance(args);
20270 }
20271
20272 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20273 PyObject *resultobj = 0;
20274 wxGIFHandler *result = 0 ;
20275
20276 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20277 {
20278 PyThreadState* __tstate = wxPyBeginAllowThreads();
20279 result = (wxGIFHandler *)new wxGIFHandler();
20280 wxPyEndAllowThreads(__tstate);
20281 if (PyErr_Occurred()) SWIG_fail;
20282 }
20283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20284 return resultobj;
20285 fail:
20286 return NULL;
20287 }
20288
20289
20290 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20291 PyObject *obj;
20292 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20293 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20294 return SWIG_Py_Void();
20295 }
20296
20297 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20298 return SWIG_Python_InitShadowInstance(args);
20299 }
20300
20301 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20302 PyObject *resultobj = 0;
20303 wxPCXHandler *result = 0 ;
20304
20305 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20306 {
20307 PyThreadState* __tstate = wxPyBeginAllowThreads();
20308 result = (wxPCXHandler *)new wxPCXHandler();
20309 wxPyEndAllowThreads(__tstate);
20310 if (PyErr_Occurred()) SWIG_fail;
20311 }
20312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20313 return resultobj;
20314 fail:
20315 return NULL;
20316 }
20317
20318
20319 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20320 PyObject *obj;
20321 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20322 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20323 return SWIG_Py_Void();
20324 }
20325
20326 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20327 return SWIG_Python_InitShadowInstance(args);
20328 }
20329
20330 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20331 PyObject *resultobj = 0;
20332 wxJPEGHandler *result = 0 ;
20333
20334 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20335 {
20336 PyThreadState* __tstate = wxPyBeginAllowThreads();
20337 result = (wxJPEGHandler *)new wxJPEGHandler();
20338 wxPyEndAllowThreads(__tstate);
20339 if (PyErr_Occurred()) SWIG_fail;
20340 }
20341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20342 return resultobj;
20343 fail:
20344 return NULL;
20345 }
20346
20347
20348 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20349 PyObject *obj;
20350 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20351 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20352 return SWIG_Py_Void();
20353 }
20354
20355 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20356 return SWIG_Python_InitShadowInstance(args);
20357 }
20358
20359 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20360 PyObject *resultobj = 0;
20361 wxPNMHandler *result = 0 ;
20362
20363 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20364 {
20365 PyThreadState* __tstate = wxPyBeginAllowThreads();
20366 result = (wxPNMHandler *)new wxPNMHandler();
20367 wxPyEndAllowThreads(__tstate);
20368 if (PyErr_Occurred()) SWIG_fail;
20369 }
20370 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20371 return resultobj;
20372 fail:
20373 return NULL;
20374 }
20375
20376
20377 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20378 PyObject *obj;
20379 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20380 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20381 return SWIG_Py_Void();
20382 }
20383
20384 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20385 return SWIG_Python_InitShadowInstance(args);
20386 }
20387
20388 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20389 PyObject *resultobj = 0;
20390 wxXPMHandler *result = 0 ;
20391
20392 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20393 {
20394 PyThreadState* __tstate = wxPyBeginAllowThreads();
20395 result = (wxXPMHandler *)new wxXPMHandler();
20396 wxPyEndAllowThreads(__tstate);
20397 if (PyErr_Occurred()) SWIG_fail;
20398 }
20399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20400 return resultobj;
20401 fail:
20402 return NULL;
20403 }
20404
20405
20406 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20407 PyObject *obj;
20408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20409 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20410 return SWIG_Py_Void();
20411 }
20412
20413 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20414 return SWIG_Python_InitShadowInstance(args);
20415 }
20416
20417 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20418 PyObject *resultobj = 0;
20419 wxTIFFHandler *result = 0 ;
20420
20421 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20422 {
20423 PyThreadState* __tstate = wxPyBeginAllowThreads();
20424 result = (wxTIFFHandler *)new wxTIFFHandler();
20425 wxPyEndAllowThreads(__tstate);
20426 if (PyErr_Occurred()) SWIG_fail;
20427 }
20428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20429 return resultobj;
20430 fail:
20431 return NULL;
20432 }
20433
20434
20435 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20436 PyObject *obj;
20437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20438 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20439 return SWIG_Py_Void();
20440 }
20441
20442 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20443 return SWIG_Python_InitShadowInstance(args);
20444 }
20445
20446 SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20447 PyObject *resultobj = 0;
20448 wxTGAHandler *result = 0 ;
20449
20450 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
20451 {
20452 PyThreadState* __tstate = wxPyBeginAllowThreads();
20453 result = (wxTGAHandler *)new wxTGAHandler();
20454 wxPyEndAllowThreads(__tstate);
20455 if (PyErr_Occurred()) SWIG_fail;
20456 }
20457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
20458 return resultobj;
20459 fail:
20460 return NULL;
20461 }
20462
20463
20464 SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20465 PyObject *obj;
20466 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20467 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
20468 return SWIG_Py_Void();
20469 }
20470
20471 SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20472 return SWIG_Python_InitShadowInstance(args);
20473 }
20474
20475 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20476 PyObject *resultobj = 0;
20477 wxImage *arg1 = 0 ;
20478 wxImage *arg2 = 0 ;
20479 int arg3 = (int) 236 ;
20480 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20481 bool result;
20482 void *argp1 = 0 ;
20483 int res1 = 0 ;
20484 void *argp2 = 0 ;
20485 int res2 = 0 ;
20486 int val3 ;
20487 int ecode3 = 0 ;
20488 int val4 ;
20489 int ecode4 = 0 ;
20490 PyObject * obj0 = 0 ;
20491 PyObject * obj1 = 0 ;
20492 PyObject * obj2 = 0 ;
20493 PyObject * obj3 = 0 ;
20494 char * kwnames[] = {
20495 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20496 };
20497
20498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20499 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20500 if (!SWIG_IsOK(res1)) {
20501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20502 }
20503 if (!argp1) {
20504 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20505 }
20506 arg1 = reinterpret_cast< wxImage * >(argp1);
20507 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20508 if (!SWIG_IsOK(res2)) {
20509 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20510 }
20511 if (!argp2) {
20512 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20513 }
20514 arg2 = reinterpret_cast< wxImage * >(argp2);
20515 if (obj2) {
20516 ecode3 = SWIG_AsVal_int(obj2, &val3);
20517 if (!SWIG_IsOK(ecode3)) {
20518 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20519 }
20520 arg3 = static_cast< int >(val3);
20521 }
20522 if (obj3) {
20523 ecode4 = SWIG_AsVal_int(obj3, &val4);
20524 if (!SWIG_IsOK(ecode4)) {
20525 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20526 }
20527 arg4 = static_cast< int >(val4);
20528 }
20529 {
20530 PyThreadState* __tstate = wxPyBeginAllowThreads();
20531 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20532 wxPyEndAllowThreads(__tstate);
20533 if (PyErr_Occurred()) SWIG_fail;
20534 }
20535 {
20536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20537 }
20538 return resultobj;
20539 fail:
20540 return NULL;
20541 }
20542
20543
20544 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20545 PyObject *obj;
20546 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20547 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20548 return SWIG_Py_Void();
20549 }
20550
20551 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20552 PyObject *resultobj = 0;
20553 wxEvtHandler *result = 0 ;
20554
20555 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20556 {
20557 PyThreadState* __tstate = wxPyBeginAllowThreads();
20558 result = (wxEvtHandler *)new wxEvtHandler();
20559 wxPyEndAllowThreads(__tstate);
20560 if (PyErr_Occurred()) SWIG_fail;
20561 }
20562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20563 return resultobj;
20564 fail:
20565 return NULL;
20566 }
20567
20568
20569 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20570 PyObject *resultobj = 0;
20571 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20572 wxEvtHandler *result = 0 ;
20573 void *argp1 = 0 ;
20574 int res1 = 0 ;
20575 PyObject *swig_obj[1] ;
20576
20577 if (!args) SWIG_fail;
20578 swig_obj[0] = args;
20579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20580 if (!SWIG_IsOK(res1)) {
20581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20582 }
20583 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20584 {
20585 PyThreadState* __tstate = wxPyBeginAllowThreads();
20586 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20587 wxPyEndAllowThreads(__tstate);
20588 if (PyErr_Occurred()) SWIG_fail;
20589 }
20590 {
20591 resultobj = wxPyMake_wxObject(result, 0);
20592 }
20593 return resultobj;
20594 fail:
20595 return NULL;
20596 }
20597
20598
20599 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20600 PyObject *resultobj = 0;
20601 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20602 wxEvtHandler *result = 0 ;
20603 void *argp1 = 0 ;
20604 int res1 = 0 ;
20605 PyObject *swig_obj[1] ;
20606
20607 if (!args) SWIG_fail;
20608 swig_obj[0] = args;
20609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20610 if (!SWIG_IsOK(res1)) {
20611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20612 }
20613 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20614 {
20615 PyThreadState* __tstate = wxPyBeginAllowThreads();
20616 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20617 wxPyEndAllowThreads(__tstate);
20618 if (PyErr_Occurred()) SWIG_fail;
20619 }
20620 {
20621 resultobj = wxPyMake_wxObject(result, 0);
20622 }
20623 return resultobj;
20624 fail:
20625 return NULL;
20626 }
20627
20628
20629 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20630 PyObject *resultobj = 0;
20631 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20632 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20633 void *argp1 = 0 ;
20634 int res1 = 0 ;
20635 void *argp2 = 0 ;
20636 int res2 = 0 ;
20637 PyObject * obj0 = 0 ;
20638 PyObject * obj1 = 0 ;
20639 char * kwnames[] = {
20640 (char *) "self",(char *) "handler", NULL
20641 };
20642
20643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20645 if (!SWIG_IsOK(res1)) {
20646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20647 }
20648 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20649 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20650 if (!SWIG_IsOK(res2)) {
20651 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20652 }
20653 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20654 {
20655 PyThreadState* __tstate = wxPyBeginAllowThreads();
20656 (arg1)->SetNextHandler(arg2);
20657 wxPyEndAllowThreads(__tstate);
20658 if (PyErr_Occurred()) SWIG_fail;
20659 }
20660 resultobj = SWIG_Py_Void();
20661 return resultobj;
20662 fail:
20663 return NULL;
20664 }
20665
20666
20667 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20668 PyObject *resultobj = 0;
20669 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20670 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20671 void *argp1 = 0 ;
20672 int res1 = 0 ;
20673 void *argp2 = 0 ;
20674 int res2 = 0 ;
20675 PyObject * obj0 = 0 ;
20676 PyObject * obj1 = 0 ;
20677 char * kwnames[] = {
20678 (char *) "self",(char *) "handler", NULL
20679 };
20680
20681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20683 if (!SWIG_IsOK(res1)) {
20684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20685 }
20686 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20687 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20688 if (!SWIG_IsOK(res2)) {
20689 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20690 }
20691 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20692 {
20693 PyThreadState* __tstate = wxPyBeginAllowThreads();
20694 (arg1)->SetPreviousHandler(arg2);
20695 wxPyEndAllowThreads(__tstate);
20696 if (PyErr_Occurred()) SWIG_fail;
20697 }
20698 resultobj = SWIG_Py_Void();
20699 return resultobj;
20700 fail:
20701 return NULL;
20702 }
20703
20704
20705 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20706 PyObject *resultobj = 0;
20707 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20708 bool result;
20709 void *argp1 = 0 ;
20710 int res1 = 0 ;
20711 PyObject *swig_obj[1] ;
20712
20713 if (!args) SWIG_fail;
20714 swig_obj[0] = args;
20715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20716 if (!SWIG_IsOK(res1)) {
20717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20718 }
20719 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20720 {
20721 PyThreadState* __tstate = wxPyBeginAllowThreads();
20722 result = (bool)(arg1)->GetEvtHandlerEnabled();
20723 wxPyEndAllowThreads(__tstate);
20724 if (PyErr_Occurred()) SWIG_fail;
20725 }
20726 {
20727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20728 }
20729 return resultobj;
20730 fail:
20731 return NULL;
20732 }
20733
20734
20735 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20736 PyObject *resultobj = 0;
20737 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20738 bool arg2 ;
20739 void *argp1 = 0 ;
20740 int res1 = 0 ;
20741 bool val2 ;
20742 int ecode2 = 0 ;
20743 PyObject * obj0 = 0 ;
20744 PyObject * obj1 = 0 ;
20745 char * kwnames[] = {
20746 (char *) "self",(char *) "enabled", NULL
20747 };
20748
20749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20751 if (!SWIG_IsOK(res1)) {
20752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20753 }
20754 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20755 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20756 if (!SWIG_IsOK(ecode2)) {
20757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20758 }
20759 arg2 = static_cast< bool >(val2);
20760 {
20761 PyThreadState* __tstate = wxPyBeginAllowThreads();
20762 (arg1)->SetEvtHandlerEnabled(arg2);
20763 wxPyEndAllowThreads(__tstate);
20764 if (PyErr_Occurred()) SWIG_fail;
20765 }
20766 resultobj = SWIG_Py_Void();
20767 return resultobj;
20768 fail:
20769 return NULL;
20770 }
20771
20772
20773 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20774 PyObject *resultobj = 0;
20775 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20776 wxEvent *arg2 = 0 ;
20777 bool result;
20778 void *argp1 = 0 ;
20779 int res1 = 0 ;
20780 void *argp2 = 0 ;
20781 int res2 = 0 ;
20782 PyObject * obj0 = 0 ;
20783 PyObject * obj1 = 0 ;
20784 char * kwnames[] = {
20785 (char *) "self",(char *) "event", NULL
20786 };
20787
20788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20790 if (!SWIG_IsOK(res1)) {
20791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20792 }
20793 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20794 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20795 if (!SWIG_IsOK(res2)) {
20796 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20797 }
20798 if (!argp2) {
20799 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20800 }
20801 arg2 = reinterpret_cast< wxEvent * >(argp2);
20802 {
20803 PyThreadState* __tstate = wxPyBeginAllowThreads();
20804 result = (bool)(arg1)->ProcessEvent(*arg2);
20805 wxPyEndAllowThreads(__tstate);
20806 if (PyErr_Occurred()) SWIG_fail;
20807 }
20808 {
20809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20810 }
20811 return resultobj;
20812 fail:
20813 return NULL;
20814 }
20815
20816
20817 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20818 PyObject *resultobj = 0;
20819 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20820 wxEvent *arg2 = 0 ;
20821 void *argp1 = 0 ;
20822 int res1 = 0 ;
20823 void *argp2 = 0 ;
20824 int res2 = 0 ;
20825 PyObject * obj0 = 0 ;
20826 PyObject * obj1 = 0 ;
20827 char * kwnames[] = {
20828 (char *) "self",(char *) "event", NULL
20829 };
20830
20831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20833 if (!SWIG_IsOK(res1)) {
20834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20835 }
20836 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20837 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20838 if (!SWIG_IsOK(res2)) {
20839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20840 }
20841 if (!argp2) {
20842 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20843 }
20844 arg2 = reinterpret_cast< wxEvent * >(argp2);
20845 {
20846 PyThreadState* __tstate = wxPyBeginAllowThreads();
20847 (arg1)->AddPendingEvent(*arg2);
20848 wxPyEndAllowThreads(__tstate);
20849 if (PyErr_Occurred()) SWIG_fail;
20850 }
20851 resultobj = SWIG_Py_Void();
20852 return resultobj;
20853 fail:
20854 return NULL;
20855 }
20856
20857
20858 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20859 PyObject *resultobj = 0;
20860 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20861 void *argp1 = 0 ;
20862 int res1 = 0 ;
20863 PyObject *swig_obj[1] ;
20864
20865 if (!args) SWIG_fail;
20866 swig_obj[0] = args;
20867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20868 if (!SWIG_IsOK(res1)) {
20869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20870 }
20871 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20872 {
20873 PyThreadState* __tstate = wxPyBeginAllowThreads();
20874 (arg1)->ProcessPendingEvents();
20875 wxPyEndAllowThreads(__tstate);
20876 if (PyErr_Occurred()) SWIG_fail;
20877 }
20878 resultobj = SWIG_Py_Void();
20879 return resultobj;
20880 fail:
20881 return NULL;
20882 }
20883
20884
20885 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20886 PyObject *resultobj = 0;
20887 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20888 int arg2 ;
20889 int arg3 ;
20890 int arg4 ;
20891 PyObject *arg5 = (PyObject *) 0 ;
20892 void *argp1 = 0 ;
20893 int res1 = 0 ;
20894 int val2 ;
20895 int ecode2 = 0 ;
20896 int val3 ;
20897 int ecode3 = 0 ;
20898 int val4 ;
20899 int ecode4 = 0 ;
20900 PyObject * obj0 = 0 ;
20901 PyObject * obj1 = 0 ;
20902 PyObject * obj2 = 0 ;
20903 PyObject * obj3 = 0 ;
20904 PyObject * obj4 = 0 ;
20905 char * kwnames[] = {
20906 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20907 };
20908
20909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20911 if (!SWIG_IsOK(res1)) {
20912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20913 }
20914 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20915 ecode2 = SWIG_AsVal_int(obj1, &val2);
20916 if (!SWIG_IsOK(ecode2)) {
20917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
20918 }
20919 arg2 = static_cast< int >(val2);
20920 ecode3 = SWIG_AsVal_int(obj2, &val3);
20921 if (!SWIG_IsOK(ecode3)) {
20922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
20923 }
20924 arg3 = static_cast< int >(val3);
20925 ecode4 = SWIG_AsVal_int(obj3, &val4);
20926 if (!SWIG_IsOK(ecode4)) {
20927 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
20928 }
20929 arg4 = static_cast< int >(val4);
20930 arg5 = obj4;
20931 {
20932 PyThreadState* __tstate = wxPyBeginAllowThreads();
20933 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
20934 wxPyEndAllowThreads(__tstate);
20935 if (PyErr_Occurred()) SWIG_fail;
20936 }
20937 resultobj = SWIG_Py_Void();
20938 return resultobj;
20939 fail:
20940 return NULL;
20941 }
20942
20943
20944 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20945 PyObject *resultobj = 0;
20946 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20947 int arg2 ;
20948 int arg3 = (int) -1 ;
20949 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
20950 bool result;
20951 void *argp1 = 0 ;
20952 int res1 = 0 ;
20953 int val2 ;
20954 int ecode2 = 0 ;
20955 int val3 ;
20956 int ecode3 = 0 ;
20957 int val4 ;
20958 int ecode4 = 0 ;
20959 PyObject * obj0 = 0 ;
20960 PyObject * obj1 = 0 ;
20961 PyObject * obj2 = 0 ;
20962 PyObject * obj3 = 0 ;
20963 char * kwnames[] = {
20964 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
20965 };
20966
20967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20969 if (!SWIG_IsOK(res1)) {
20970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20971 }
20972 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20973 ecode2 = SWIG_AsVal_int(obj1, &val2);
20974 if (!SWIG_IsOK(ecode2)) {
20975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
20976 }
20977 arg2 = static_cast< int >(val2);
20978 if (obj2) {
20979 ecode3 = SWIG_AsVal_int(obj2, &val3);
20980 if (!SWIG_IsOK(ecode3)) {
20981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
20982 }
20983 arg3 = static_cast< int >(val3);
20984 }
20985 if (obj3) {
20986 ecode4 = SWIG_AsVal_int(obj3, &val4);
20987 if (!SWIG_IsOK(ecode4)) {
20988 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
20989 }
20990 arg4 = static_cast< wxEventType >(val4);
20991 }
20992 {
20993 PyThreadState* __tstate = wxPyBeginAllowThreads();
20994 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
20995 wxPyEndAllowThreads(__tstate);
20996 if (PyErr_Occurred()) SWIG_fail;
20997 }
20998 {
20999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21000 }
21001 return resultobj;
21002 fail:
21003 return NULL;
21004 }
21005
21006
21007 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21008 PyObject *resultobj = 0;
21009 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21010 PyObject *arg2 = (PyObject *) 0 ;
21011 bool arg3 = (bool) true ;
21012 void *argp1 = 0 ;
21013 int res1 = 0 ;
21014 bool val3 ;
21015 int ecode3 = 0 ;
21016 PyObject * obj0 = 0 ;
21017 PyObject * obj1 = 0 ;
21018 PyObject * obj2 = 0 ;
21019 char * kwnames[] = {
21020 (char *) "self",(char *) "_self",(char *) "incref", NULL
21021 };
21022
21023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21025 if (!SWIG_IsOK(res1)) {
21026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21027 }
21028 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21029 arg2 = obj1;
21030 if (obj2) {
21031 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21032 if (!SWIG_IsOK(ecode3)) {
21033 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21034 }
21035 arg3 = static_cast< bool >(val3);
21036 }
21037 {
21038 PyThreadState* __tstate = wxPyBeginAllowThreads();
21039 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21040 wxPyEndAllowThreads(__tstate);
21041 if (PyErr_Occurred()) SWIG_fail;
21042 }
21043 resultobj = SWIG_Py_Void();
21044 return resultobj;
21045 fail:
21046 return NULL;
21047 }
21048
21049
21050 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21051 PyObject *obj;
21052 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21053 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21054 return SWIG_Py_Void();
21055 }
21056
21057 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21058 return SWIG_Python_InitShadowInstance(args);
21059 }
21060
21061 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21062 PyObject *resultobj = 0;
21063 wxEventType result;
21064
21065 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21066 {
21067 PyThreadState* __tstate = wxPyBeginAllowThreads();
21068 result = (wxEventType)wxNewEventType();
21069 wxPyEndAllowThreads(__tstate);
21070 if (PyErr_Occurred()) SWIG_fail;
21071 }
21072 resultobj = SWIG_From_int(static_cast< int >(result));
21073 return resultobj;
21074 fail:
21075 return NULL;
21076 }
21077
21078
21079 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21080 PyObject *resultobj = 0;
21081 wxEvent *arg1 = (wxEvent *) 0 ;
21082 void *argp1 = 0 ;
21083 int res1 = 0 ;
21084 PyObject *swig_obj[1] ;
21085
21086 if (!args) SWIG_fail;
21087 swig_obj[0] = args;
21088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21089 if (!SWIG_IsOK(res1)) {
21090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21091 }
21092 arg1 = reinterpret_cast< wxEvent * >(argp1);
21093 {
21094 PyThreadState* __tstate = wxPyBeginAllowThreads();
21095 delete arg1;
21096
21097 wxPyEndAllowThreads(__tstate);
21098 if (PyErr_Occurred()) SWIG_fail;
21099 }
21100 resultobj = SWIG_Py_Void();
21101 return resultobj;
21102 fail:
21103 return NULL;
21104 }
21105
21106
21107 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21108 PyObject *resultobj = 0;
21109 wxEvent *arg1 = (wxEvent *) 0 ;
21110 wxEventType arg2 ;
21111 void *argp1 = 0 ;
21112 int res1 = 0 ;
21113 int val2 ;
21114 int ecode2 = 0 ;
21115 PyObject * obj0 = 0 ;
21116 PyObject * obj1 = 0 ;
21117 char * kwnames[] = {
21118 (char *) "self",(char *) "typ", NULL
21119 };
21120
21121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21123 if (!SWIG_IsOK(res1)) {
21124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21125 }
21126 arg1 = reinterpret_cast< wxEvent * >(argp1);
21127 ecode2 = SWIG_AsVal_int(obj1, &val2);
21128 if (!SWIG_IsOK(ecode2)) {
21129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21130 }
21131 arg2 = static_cast< wxEventType >(val2);
21132 {
21133 PyThreadState* __tstate = wxPyBeginAllowThreads();
21134 (arg1)->SetEventType(arg2);
21135 wxPyEndAllowThreads(__tstate);
21136 if (PyErr_Occurred()) SWIG_fail;
21137 }
21138 resultobj = SWIG_Py_Void();
21139 return resultobj;
21140 fail:
21141 return NULL;
21142 }
21143
21144
21145 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21146 PyObject *resultobj = 0;
21147 wxEvent *arg1 = (wxEvent *) 0 ;
21148 wxEventType result;
21149 void *argp1 = 0 ;
21150 int res1 = 0 ;
21151 PyObject *swig_obj[1] ;
21152
21153 if (!args) SWIG_fail;
21154 swig_obj[0] = args;
21155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21156 if (!SWIG_IsOK(res1)) {
21157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21158 }
21159 arg1 = reinterpret_cast< wxEvent * >(argp1);
21160 {
21161 PyThreadState* __tstate = wxPyBeginAllowThreads();
21162 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21163 wxPyEndAllowThreads(__tstate);
21164 if (PyErr_Occurred()) SWIG_fail;
21165 }
21166 resultobj = SWIG_From_int(static_cast< int >(result));
21167 return resultobj;
21168 fail:
21169 return NULL;
21170 }
21171
21172
21173 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21174 PyObject *resultobj = 0;
21175 wxEvent *arg1 = (wxEvent *) 0 ;
21176 wxObject *result = 0 ;
21177 void *argp1 = 0 ;
21178 int res1 = 0 ;
21179 PyObject *swig_obj[1] ;
21180
21181 if (!args) SWIG_fail;
21182 swig_obj[0] = args;
21183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21184 if (!SWIG_IsOK(res1)) {
21185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21186 }
21187 arg1 = reinterpret_cast< wxEvent * >(argp1);
21188 {
21189 PyThreadState* __tstate = wxPyBeginAllowThreads();
21190 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21191 wxPyEndAllowThreads(__tstate);
21192 if (PyErr_Occurred()) SWIG_fail;
21193 }
21194 {
21195 resultobj = wxPyMake_wxObject(result, (bool)0);
21196 }
21197 return resultobj;
21198 fail:
21199 return NULL;
21200 }
21201
21202
21203 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21204 PyObject *resultobj = 0;
21205 wxEvent *arg1 = (wxEvent *) 0 ;
21206 wxObject *arg2 = (wxObject *) 0 ;
21207 void *argp1 = 0 ;
21208 int res1 = 0 ;
21209 void *argp2 = 0 ;
21210 int res2 = 0 ;
21211 PyObject * obj0 = 0 ;
21212 PyObject * obj1 = 0 ;
21213 char * kwnames[] = {
21214 (char *) "self",(char *) "obj", NULL
21215 };
21216
21217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21219 if (!SWIG_IsOK(res1)) {
21220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21221 }
21222 arg1 = reinterpret_cast< wxEvent * >(argp1);
21223 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21224 if (!SWIG_IsOK(res2)) {
21225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21226 }
21227 arg2 = reinterpret_cast< wxObject * >(argp2);
21228 {
21229 PyThreadState* __tstate = wxPyBeginAllowThreads();
21230 (arg1)->SetEventObject(arg2);
21231 wxPyEndAllowThreads(__tstate);
21232 if (PyErr_Occurred()) SWIG_fail;
21233 }
21234 resultobj = SWIG_Py_Void();
21235 return resultobj;
21236 fail:
21237 return NULL;
21238 }
21239
21240
21241 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21242 PyObject *resultobj = 0;
21243 wxEvent *arg1 = (wxEvent *) 0 ;
21244 long result;
21245 void *argp1 = 0 ;
21246 int res1 = 0 ;
21247 PyObject *swig_obj[1] ;
21248
21249 if (!args) SWIG_fail;
21250 swig_obj[0] = args;
21251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21252 if (!SWIG_IsOK(res1)) {
21253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21254 }
21255 arg1 = reinterpret_cast< wxEvent * >(argp1);
21256 {
21257 PyThreadState* __tstate = wxPyBeginAllowThreads();
21258 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21259 wxPyEndAllowThreads(__tstate);
21260 if (PyErr_Occurred()) SWIG_fail;
21261 }
21262 resultobj = SWIG_From_long(static_cast< long >(result));
21263 return resultobj;
21264 fail:
21265 return NULL;
21266 }
21267
21268
21269 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21270 PyObject *resultobj = 0;
21271 wxEvent *arg1 = (wxEvent *) 0 ;
21272 long arg2 = (long) 0 ;
21273 void *argp1 = 0 ;
21274 int res1 = 0 ;
21275 long val2 ;
21276 int ecode2 = 0 ;
21277 PyObject * obj0 = 0 ;
21278 PyObject * obj1 = 0 ;
21279 char * kwnames[] = {
21280 (char *) "self",(char *) "ts", NULL
21281 };
21282
21283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21285 if (!SWIG_IsOK(res1)) {
21286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21287 }
21288 arg1 = reinterpret_cast< wxEvent * >(argp1);
21289 if (obj1) {
21290 ecode2 = SWIG_AsVal_long(obj1, &val2);
21291 if (!SWIG_IsOK(ecode2)) {
21292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21293 }
21294 arg2 = static_cast< long >(val2);
21295 }
21296 {
21297 PyThreadState* __tstate = wxPyBeginAllowThreads();
21298 (arg1)->SetTimestamp(arg2);
21299 wxPyEndAllowThreads(__tstate);
21300 if (PyErr_Occurred()) SWIG_fail;
21301 }
21302 resultobj = SWIG_Py_Void();
21303 return resultobj;
21304 fail:
21305 return NULL;
21306 }
21307
21308
21309 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21310 PyObject *resultobj = 0;
21311 wxEvent *arg1 = (wxEvent *) 0 ;
21312 int result;
21313 void *argp1 = 0 ;
21314 int res1 = 0 ;
21315 PyObject *swig_obj[1] ;
21316
21317 if (!args) SWIG_fail;
21318 swig_obj[0] = args;
21319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21320 if (!SWIG_IsOK(res1)) {
21321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21322 }
21323 arg1 = reinterpret_cast< wxEvent * >(argp1);
21324 {
21325 PyThreadState* __tstate = wxPyBeginAllowThreads();
21326 result = (int)((wxEvent const *)arg1)->GetId();
21327 wxPyEndAllowThreads(__tstate);
21328 if (PyErr_Occurred()) SWIG_fail;
21329 }
21330 resultobj = SWIG_From_int(static_cast< int >(result));
21331 return resultobj;
21332 fail:
21333 return NULL;
21334 }
21335
21336
21337 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21338 PyObject *resultobj = 0;
21339 wxEvent *arg1 = (wxEvent *) 0 ;
21340 int arg2 ;
21341 void *argp1 = 0 ;
21342 int res1 = 0 ;
21343 int val2 ;
21344 int ecode2 = 0 ;
21345 PyObject * obj0 = 0 ;
21346 PyObject * obj1 = 0 ;
21347 char * kwnames[] = {
21348 (char *) "self",(char *) "Id", NULL
21349 };
21350
21351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21353 if (!SWIG_IsOK(res1)) {
21354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21355 }
21356 arg1 = reinterpret_cast< wxEvent * >(argp1);
21357 ecode2 = SWIG_AsVal_int(obj1, &val2);
21358 if (!SWIG_IsOK(ecode2)) {
21359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21360 }
21361 arg2 = static_cast< int >(val2);
21362 {
21363 PyThreadState* __tstate = wxPyBeginAllowThreads();
21364 (arg1)->SetId(arg2);
21365 wxPyEndAllowThreads(__tstate);
21366 if (PyErr_Occurred()) SWIG_fail;
21367 }
21368 resultobj = SWIG_Py_Void();
21369 return resultobj;
21370 fail:
21371 return NULL;
21372 }
21373
21374
21375 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21376 PyObject *resultobj = 0;
21377 wxEvent *arg1 = (wxEvent *) 0 ;
21378 bool result;
21379 void *argp1 = 0 ;
21380 int res1 = 0 ;
21381 PyObject *swig_obj[1] ;
21382
21383 if (!args) SWIG_fail;
21384 swig_obj[0] = args;
21385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21386 if (!SWIG_IsOK(res1)) {
21387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21388 }
21389 arg1 = reinterpret_cast< wxEvent * >(argp1);
21390 {
21391 PyThreadState* __tstate = wxPyBeginAllowThreads();
21392 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21393 wxPyEndAllowThreads(__tstate);
21394 if (PyErr_Occurred()) SWIG_fail;
21395 }
21396 {
21397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21398 }
21399 return resultobj;
21400 fail:
21401 return NULL;
21402 }
21403
21404
21405 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21406 PyObject *resultobj = 0;
21407 wxEvent *arg1 = (wxEvent *) 0 ;
21408 bool arg2 = (bool) true ;
21409 void *argp1 = 0 ;
21410 int res1 = 0 ;
21411 bool val2 ;
21412 int ecode2 = 0 ;
21413 PyObject * obj0 = 0 ;
21414 PyObject * obj1 = 0 ;
21415 char * kwnames[] = {
21416 (char *) "self",(char *) "skip", NULL
21417 };
21418
21419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21421 if (!SWIG_IsOK(res1)) {
21422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21423 }
21424 arg1 = reinterpret_cast< wxEvent * >(argp1);
21425 if (obj1) {
21426 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21427 if (!SWIG_IsOK(ecode2)) {
21428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21429 }
21430 arg2 = static_cast< bool >(val2);
21431 }
21432 {
21433 PyThreadState* __tstate = wxPyBeginAllowThreads();
21434 (arg1)->Skip(arg2);
21435 wxPyEndAllowThreads(__tstate);
21436 if (PyErr_Occurred()) SWIG_fail;
21437 }
21438 resultobj = SWIG_Py_Void();
21439 return resultobj;
21440 fail:
21441 return NULL;
21442 }
21443
21444
21445 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21446 PyObject *resultobj = 0;
21447 wxEvent *arg1 = (wxEvent *) 0 ;
21448 bool result;
21449 void *argp1 = 0 ;
21450 int res1 = 0 ;
21451 PyObject *swig_obj[1] ;
21452
21453 if (!args) SWIG_fail;
21454 swig_obj[0] = args;
21455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21456 if (!SWIG_IsOK(res1)) {
21457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21458 }
21459 arg1 = reinterpret_cast< wxEvent * >(argp1);
21460 {
21461 PyThreadState* __tstate = wxPyBeginAllowThreads();
21462 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21463 wxPyEndAllowThreads(__tstate);
21464 if (PyErr_Occurred()) SWIG_fail;
21465 }
21466 {
21467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21468 }
21469 return resultobj;
21470 fail:
21471 return NULL;
21472 }
21473
21474
21475 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21476 PyObject *resultobj = 0;
21477 wxEvent *arg1 = (wxEvent *) 0 ;
21478 bool result;
21479 void *argp1 = 0 ;
21480 int res1 = 0 ;
21481 PyObject *swig_obj[1] ;
21482
21483 if (!args) SWIG_fail;
21484 swig_obj[0] = args;
21485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21486 if (!SWIG_IsOK(res1)) {
21487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21488 }
21489 arg1 = reinterpret_cast< wxEvent * >(argp1);
21490 {
21491 PyThreadState* __tstate = wxPyBeginAllowThreads();
21492 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21493 wxPyEndAllowThreads(__tstate);
21494 if (PyErr_Occurred()) SWIG_fail;
21495 }
21496 {
21497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21498 }
21499 return resultobj;
21500 fail:
21501 return NULL;
21502 }
21503
21504
21505 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21506 PyObject *resultobj = 0;
21507 wxEvent *arg1 = (wxEvent *) 0 ;
21508 int result;
21509 void *argp1 = 0 ;
21510 int res1 = 0 ;
21511 PyObject *swig_obj[1] ;
21512
21513 if (!args) SWIG_fail;
21514 swig_obj[0] = args;
21515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21516 if (!SWIG_IsOK(res1)) {
21517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21518 }
21519 arg1 = reinterpret_cast< wxEvent * >(argp1);
21520 {
21521 PyThreadState* __tstate = wxPyBeginAllowThreads();
21522 result = (int)(arg1)->StopPropagation();
21523 wxPyEndAllowThreads(__tstate);
21524 if (PyErr_Occurred()) SWIG_fail;
21525 }
21526 resultobj = SWIG_From_int(static_cast< int >(result));
21527 return resultobj;
21528 fail:
21529 return NULL;
21530 }
21531
21532
21533 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21534 PyObject *resultobj = 0;
21535 wxEvent *arg1 = (wxEvent *) 0 ;
21536 int arg2 ;
21537 void *argp1 = 0 ;
21538 int res1 = 0 ;
21539 int val2 ;
21540 int ecode2 = 0 ;
21541 PyObject * obj0 = 0 ;
21542 PyObject * obj1 = 0 ;
21543 char * kwnames[] = {
21544 (char *) "self",(char *) "propagationLevel", NULL
21545 };
21546
21547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21549 if (!SWIG_IsOK(res1)) {
21550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21551 }
21552 arg1 = reinterpret_cast< wxEvent * >(argp1);
21553 ecode2 = SWIG_AsVal_int(obj1, &val2);
21554 if (!SWIG_IsOK(ecode2)) {
21555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21556 }
21557 arg2 = static_cast< int >(val2);
21558 {
21559 PyThreadState* __tstate = wxPyBeginAllowThreads();
21560 (arg1)->ResumePropagation(arg2);
21561 wxPyEndAllowThreads(__tstate);
21562 if (PyErr_Occurred()) SWIG_fail;
21563 }
21564 resultobj = SWIG_Py_Void();
21565 return resultobj;
21566 fail:
21567 return NULL;
21568 }
21569
21570
21571 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21572 PyObject *resultobj = 0;
21573 wxEvent *arg1 = (wxEvent *) 0 ;
21574 wxEvent *result = 0 ;
21575 void *argp1 = 0 ;
21576 int res1 = 0 ;
21577 PyObject *swig_obj[1] ;
21578
21579 if (!args) SWIG_fail;
21580 swig_obj[0] = args;
21581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21582 if (!SWIG_IsOK(res1)) {
21583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21584 }
21585 arg1 = reinterpret_cast< wxEvent * >(argp1);
21586 {
21587 PyThreadState* __tstate = wxPyBeginAllowThreads();
21588 result = (wxEvent *)(arg1)->Clone();
21589 wxPyEndAllowThreads(__tstate);
21590 if (PyErr_Occurred()) SWIG_fail;
21591 }
21592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21593 return resultobj;
21594 fail:
21595 return NULL;
21596 }
21597
21598
21599 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21600 PyObject *obj;
21601 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21602 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21603 return SWIG_Py_Void();
21604 }
21605
21606 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21607 PyObject *resultobj = 0;
21608 wxEvent *arg1 = 0 ;
21609 wxPropagationDisabler *result = 0 ;
21610 void *argp1 = 0 ;
21611 int res1 = 0 ;
21612 PyObject * obj0 = 0 ;
21613 char * kwnames[] = {
21614 (char *) "event", NULL
21615 };
21616
21617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21618 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21619 if (!SWIG_IsOK(res1)) {
21620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21621 }
21622 if (!argp1) {
21623 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21624 }
21625 arg1 = reinterpret_cast< wxEvent * >(argp1);
21626 {
21627 PyThreadState* __tstate = wxPyBeginAllowThreads();
21628 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21629 wxPyEndAllowThreads(__tstate);
21630 if (PyErr_Occurred()) SWIG_fail;
21631 }
21632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21633 return resultobj;
21634 fail:
21635 return NULL;
21636 }
21637
21638
21639 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21640 PyObject *resultobj = 0;
21641 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21642 void *argp1 = 0 ;
21643 int res1 = 0 ;
21644 PyObject *swig_obj[1] ;
21645
21646 if (!args) SWIG_fail;
21647 swig_obj[0] = args;
21648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21649 if (!SWIG_IsOK(res1)) {
21650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21651 }
21652 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21653 {
21654 PyThreadState* __tstate = wxPyBeginAllowThreads();
21655 delete arg1;
21656
21657 wxPyEndAllowThreads(__tstate);
21658 if (PyErr_Occurred()) SWIG_fail;
21659 }
21660 resultobj = SWIG_Py_Void();
21661 return resultobj;
21662 fail:
21663 return NULL;
21664 }
21665
21666
21667 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21668 PyObject *obj;
21669 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21670 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21671 return SWIG_Py_Void();
21672 }
21673
21674 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21675 return SWIG_Python_InitShadowInstance(args);
21676 }
21677
21678 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21679 PyObject *resultobj = 0;
21680 wxEvent *arg1 = 0 ;
21681 wxPropagateOnce *result = 0 ;
21682 void *argp1 = 0 ;
21683 int res1 = 0 ;
21684 PyObject * obj0 = 0 ;
21685 char * kwnames[] = {
21686 (char *) "event", NULL
21687 };
21688
21689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21690 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21691 if (!SWIG_IsOK(res1)) {
21692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21693 }
21694 if (!argp1) {
21695 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21696 }
21697 arg1 = reinterpret_cast< wxEvent * >(argp1);
21698 {
21699 PyThreadState* __tstate = wxPyBeginAllowThreads();
21700 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21701 wxPyEndAllowThreads(__tstate);
21702 if (PyErr_Occurred()) SWIG_fail;
21703 }
21704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21705 return resultobj;
21706 fail:
21707 return NULL;
21708 }
21709
21710
21711 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21712 PyObject *resultobj = 0;
21713 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21714 void *argp1 = 0 ;
21715 int res1 = 0 ;
21716 PyObject *swig_obj[1] ;
21717
21718 if (!args) SWIG_fail;
21719 swig_obj[0] = args;
21720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21721 if (!SWIG_IsOK(res1)) {
21722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21723 }
21724 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21725 {
21726 PyThreadState* __tstate = wxPyBeginAllowThreads();
21727 delete arg1;
21728
21729 wxPyEndAllowThreads(__tstate);
21730 if (PyErr_Occurred()) SWIG_fail;
21731 }
21732 resultobj = SWIG_Py_Void();
21733 return resultobj;
21734 fail:
21735 return NULL;
21736 }
21737
21738
21739 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21740 PyObject *obj;
21741 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21742 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21743 return SWIG_Py_Void();
21744 }
21745
21746 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21747 return SWIG_Python_InitShadowInstance(args);
21748 }
21749
21750 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21751 PyObject *resultobj = 0;
21752 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21753 int arg2 = (int) 0 ;
21754 wxCommandEvent *result = 0 ;
21755 int val1 ;
21756 int ecode1 = 0 ;
21757 int val2 ;
21758 int ecode2 = 0 ;
21759 PyObject * obj0 = 0 ;
21760 PyObject * obj1 = 0 ;
21761 char * kwnames[] = {
21762 (char *) "commandType",(char *) "winid", NULL
21763 };
21764
21765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21766 if (obj0) {
21767 ecode1 = SWIG_AsVal_int(obj0, &val1);
21768 if (!SWIG_IsOK(ecode1)) {
21769 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21770 }
21771 arg1 = static_cast< wxEventType >(val1);
21772 }
21773 if (obj1) {
21774 ecode2 = SWIG_AsVal_int(obj1, &val2);
21775 if (!SWIG_IsOK(ecode2)) {
21776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21777 }
21778 arg2 = static_cast< int >(val2);
21779 }
21780 {
21781 PyThreadState* __tstate = wxPyBeginAllowThreads();
21782 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21783 wxPyEndAllowThreads(__tstate);
21784 if (PyErr_Occurred()) SWIG_fail;
21785 }
21786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21787 return resultobj;
21788 fail:
21789 return NULL;
21790 }
21791
21792
21793 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21794 PyObject *resultobj = 0;
21795 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21796 int result;
21797 void *argp1 = 0 ;
21798 int res1 = 0 ;
21799 PyObject *swig_obj[1] ;
21800
21801 if (!args) SWIG_fail;
21802 swig_obj[0] = args;
21803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21804 if (!SWIG_IsOK(res1)) {
21805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21806 }
21807 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21808 {
21809 PyThreadState* __tstate = wxPyBeginAllowThreads();
21810 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21811 wxPyEndAllowThreads(__tstate);
21812 if (PyErr_Occurred()) SWIG_fail;
21813 }
21814 resultobj = SWIG_From_int(static_cast< int >(result));
21815 return resultobj;
21816 fail:
21817 return NULL;
21818 }
21819
21820
21821 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21822 PyObject *resultobj = 0;
21823 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21824 wxString *arg2 = 0 ;
21825 void *argp1 = 0 ;
21826 int res1 = 0 ;
21827 bool temp2 = false ;
21828 PyObject * obj0 = 0 ;
21829 PyObject * obj1 = 0 ;
21830 char * kwnames[] = {
21831 (char *) "self",(char *) "s", NULL
21832 };
21833
21834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21836 if (!SWIG_IsOK(res1)) {
21837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21838 }
21839 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21840 {
21841 arg2 = wxString_in_helper(obj1);
21842 if (arg2 == NULL) SWIG_fail;
21843 temp2 = true;
21844 }
21845 {
21846 PyThreadState* __tstate = wxPyBeginAllowThreads();
21847 (arg1)->SetString((wxString const &)*arg2);
21848 wxPyEndAllowThreads(__tstate);
21849 if (PyErr_Occurred()) SWIG_fail;
21850 }
21851 resultobj = SWIG_Py_Void();
21852 {
21853 if (temp2)
21854 delete arg2;
21855 }
21856 return resultobj;
21857 fail:
21858 {
21859 if (temp2)
21860 delete arg2;
21861 }
21862 return NULL;
21863 }
21864
21865
21866 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21867 PyObject *resultobj = 0;
21868 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21869 wxString result;
21870 void *argp1 = 0 ;
21871 int res1 = 0 ;
21872 PyObject *swig_obj[1] ;
21873
21874 if (!args) SWIG_fail;
21875 swig_obj[0] = args;
21876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21877 if (!SWIG_IsOK(res1)) {
21878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21879 }
21880 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21881 {
21882 PyThreadState* __tstate = wxPyBeginAllowThreads();
21883 result = ((wxCommandEvent const *)arg1)->GetString();
21884 wxPyEndAllowThreads(__tstate);
21885 if (PyErr_Occurred()) SWIG_fail;
21886 }
21887 {
21888 #if wxUSE_UNICODE
21889 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21890 #else
21891 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21892 #endif
21893 }
21894 return resultobj;
21895 fail:
21896 return NULL;
21897 }
21898
21899
21900 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21901 PyObject *resultobj = 0;
21902 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21903 bool result;
21904 void *argp1 = 0 ;
21905 int res1 = 0 ;
21906 PyObject *swig_obj[1] ;
21907
21908 if (!args) SWIG_fail;
21909 swig_obj[0] = args;
21910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21911 if (!SWIG_IsOK(res1)) {
21912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21913 }
21914 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21915 {
21916 PyThreadState* __tstate = wxPyBeginAllowThreads();
21917 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
21918 wxPyEndAllowThreads(__tstate);
21919 if (PyErr_Occurred()) SWIG_fail;
21920 }
21921 {
21922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21923 }
21924 return resultobj;
21925 fail:
21926 return NULL;
21927 }
21928
21929
21930 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21931 PyObject *resultobj = 0;
21932 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21933 bool result;
21934 void *argp1 = 0 ;
21935 int res1 = 0 ;
21936 PyObject *swig_obj[1] ;
21937
21938 if (!args) SWIG_fail;
21939 swig_obj[0] = args;
21940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21941 if (!SWIG_IsOK(res1)) {
21942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21943 }
21944 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21945 {
21946 PyThreadState* __tstate = wxPyBeginAllowThreads();
21947 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
21948 wxPyEndAllowThreads(__tstate);
21949 if (PyErr_Occurred()) SWIG_fail;
21950 }
21951 {
21952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21953 }
21954 return resultobj;
21955 fail:
21956 return NULL;
21957 }
21958
21959
21960 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21961 PyObject *resultobj = 0;
21962 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21963 long arg2 ;
21964 void *argp1 = 0 ;
21965 int res1 = 0 ;
21966 long val2 ;
21967 int ecode2 = 0 ;
21968 PyObject * obj0 = 0 ;
21969 PyObject * obj1 = 0 ;
21970 char * kwnames[] = {
21971 (char *) "self",(char *) "extraLong", NULL
21972 };
21973
21974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
21975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21976 if (!SWIG_IsOK(res1)) {
21977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21978 }
21979 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21980 ecode2 = SWIG_AsVal_long(obj1, &val2);
21981 if (!SWIG_IsOK(ecode2)) {
21982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
21983 }
21984 arg2 = static_cast< long >(val2);
21985 {
21986 PyThreadState* __tstate = wxPyBeginAllowThreads();
21987 (arg1)->SetExtraLong(arg2);
21988 wxPyEndAllowThreads(__tstate);
21989 if (PyErr_Occurred()) SWIG_fail;
21990 }
21991 resultobj = SWIG_Py_Void();
21992 return resultobj;
21993 fail:
21994 return NULL;
21995 }
21996
21997
21998 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21999 PyObject *resultobj = 0;
22000 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22001 long result;
22002 void *argp1 = 0 ;
22003 int res1 = 0 ;
22004 PyObject *swig_obj[1] ;
22005
22006 if (!args) SWIG_fail;
22007 swig_obj[0] = args;
22008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22009 if (!SWIG_IsOK(res1)) {
22010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22011 }
22012 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22013 {
22014 PyThreadState* __tstate = wxPyBeginAllowThreads();
22015 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22016 wxPyEndAllowThreads(__tstate);
22017 if (PyErr_Occurred()) SWIG_fail;
22018 }
22019 resultobj = SWIG_From_long(static_cast< long >(result));
22020 return resultobj;
22021 fail:
22022 return NULL;
22023 }
22024
22025
22026 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22027 PyObject *resultobj = 0;
22028 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22029 int arg2 ;
22030 void *argp1 = 0 ;
22031 int res1 = 0 ;
22032 int val2 ;
22033 int ecode2 = 0 ;
22034 PyObject * obj0 = 0 ;
22035 PyObject * obj1 = 0 ;
22036 char * kwnames[] = {
22037 (char *) "self",(char *) "i", NULL
22038 };
22039
22040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22042 if (!SWIG_IsOK(res1)) {
22043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22044 }
22045 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22046 ecode2 = SWIG_AsVal_int(obj1, &val2);
22047 if (!SWIG_IsOK(ecode2)) {
22048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22049 }
22050 arg2 = static_cast< int >(val2);
22051 {
22052 PyThreadState* __tstate = wxPyBeginAllowThreads();
22053 (arg1)->SetInt(arg2);
22054 wxPyEndAllowThreads(__tstate);
22055 if (PyErr_Occurred()) SWIG_fail;
22056 }
22057 resultobj = SWIG_Py_Void();
22058 return resultobj;
22059 fail:
22060 return NULL;
22061 }
22062
22063
22064 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22065 PyObject *resultobj = 0;
22066 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22067 int result;
22068 void *argp1 = 0 ;
22069 int res1 = 0 ;
22070 PyObject *swig_obj[1] ;
22071
22072 if (!args) SWIG_fail;
22073 swig_obj[0] = args;
22074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22075 if (!SWIG_IsOK(res1)) {
22076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22077 }
22078 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22079 {
22080 PyThreadState* __tstate = wxPyBeginAllowThreads();
22081 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22082 wxPyEndAllowThreads(__tstate);
22083 if (PyErr_Occurred()) SWIG_fail;
22084 }
22085 resultobj = SWIG_From_int(static_cast< int >(result));
22086 return resultobj;
22087 fail:
22088 return NULL;
22089 }
22090
22091
22092 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22093 PyObject *resultobj = 0;
22094 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22095 PyObject *result = 0 ;
22096 void *argp1 = 0 ;
22097 int res1 = 0 ;
22098 PyObject *swig_obj[1] ;
22099
22100 if (!args) SWIG_fail;
22101 swig_obj[0] = args;
22102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22103 if (!SWIG_IsOK(res1)) {
22104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22105 }
22106 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22107 {
22108 PyThreadState* __tstate = wxPyBeginAllowThreads();
22109 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22110 wxPyEndAllowThreads(__tstate);
22111 if (PyErr_Occurred()) SWIG_fail;
22112 }
22113 resultobj = result;
22114 return resultobj;
22115 fail:
22116 return NULL;
22117 }
22118
22119
22120 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22121 PyObject *resultobj = 0;
22122 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22123 PyObject *arg2 = (PyObject *) 0 ;
22124 void *argp1 = 0 ;
22125 int res1 = 0 ;
22126 PyObject * obj0 = 0 ;
22127 PyObject * obj1 = 0 ;
22128 char * kwnames[] = {
22129 (char *) "self",(char *) "clientData", NULL
22130 };
22131
22132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22134 if (!SWIG_IsOK(res1)) {
22135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22136 }
22137 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22138 arg2 = obj1;
22139 {
22140 PyThreadState* __tstate = wxPyBeginAllowThreads();
22141 wxCommandEvent_SetClientData(arg1,arg2);
22142 wxPyEndAllowThreads(__tstate);
22143 if (PyErr_Occurred()) SWIG_fail;
22144 }
22145 resultobj = SWIG_Py_Void();
22146 return resultobj;
22147 fail:
22148 return NULL;
22149 }
22150
22151
22152 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22153 PyObject *resultobj = 0;
22154 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22155 wxEvent *result = 0 ;
22156 void *argp1 = 0 ;
22157 int res1 = 0 ;
22158 PyObject *swig_obj[1] ;
22159
22160 if (!args) SWIG_fail;
22161 swig_obj[0] = args;
22162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22163 if (!SWIG_IsOK(res1)) {
22164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22165 }
22166 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22167 {
22168 PyThreadState* __tstate = wxPyBeginAllowThreads();
22169 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22170 wxPyEndAllowThreads(__tstate);
22171 if (PyErr_Occurred()) SWIG_fail;
22172 }
22173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22174 return resultobj;
22175 fail:
22176 return NULL;
22177 }
22178
22179
22180 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22181 PyObject *obj;
22182 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22183 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22184 return SWIG_Py_Void();
22185 }
22186
22187 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22188 return SWIG_Python_InitShadowInstance(args);
22189 }
22190
22191 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22192 PyObject *resultobj = 0;
22193 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22194 int arg2 = (int) 0 ;
22195 wxNotifyEvent *result = 0 ;
22196 int val1 ;
22197 int ecode1 = 0 ;
22198 int val2 ;
22199 int ecode2 = 0 ;
22200 PyObject * obj0 = 0 ;
22201 PyObject * obj1 = 0 ;
22202 char * kwnames[] = {
22203 (char *) "commandType",(char *) "winid", NULL
22204 };
22205
22206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22207 if (obj0) {
22208 ecode1 = SWIG_AsVal_int(obj0, &val1);
22209 if (!SWIG_IsOK(ecode1)) {
22210 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22211 }
22212 arg1 = static_cast< wxEventType >(val1);
22213 }
22214 if (obj1) {
22215 ecode2 = SWIG_AsVal_int(obj1, &val2);
22216 if (!SWIG_IsOK(ecode2)) {
22217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22218 }
22219 arg2 = static_cast< int >(val2);
22220 }
22221 {
22222 PyThreadState* __tstate = wxPyBeginAllowThreads();
22223 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22224 wxPyEndAllowThreads(__tstate);
22225 if (PyErr_Occurred()) SWIG_fail;
22226 }
22227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22228 return resultobj;
22229 fail:
22230 return NULL;
22231 }
22232
22233
22234 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22235 PyObject *resultobj = 0;
22236 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22237 void *argp1 = 0 ;
22238 int res1 = 0 ;
22239 PyObject *swig_obj[1] ;
22240
22241 if (!args) SWIG_fail;
22242 swig_obj[0] = args;
22243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22244 if (!SWIG_IsOK(res1)) {
22245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22246 }
22247 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22248 {
22249 PyThreadState* __tstate = wxPyBeginAllowThreads();
22250 (arg1)->Veto();
22251 wxPyEndAllowThreads(__tstate);
22252 if (PyErr_Occurred()) SWIG_fail;
22253 }
22254 resultobj = SWIG_Py_Void();
22255 return resultobj;
22256 fail:
22257 return NULL;
22258 }
22259
22260
22261 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22262 PyObject *resultobj = 0;
22263 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22264 void *argp1 = 0 ;
22265 int res1 = 0 ;
22266 PyObject *swig_obj[1] ;
22267
22268 if (!args) SWIG_fail;
22269 swig_obj[0] = args;
22270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22271 if (!SWIG_IsOK(res1)) {
22272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22273 }
22274 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22275 {
22276 PyThreadState* __tstate = wxPyBeginAllowThreads();
22277 (arg1)->Allow();
22278 wxPyEndAllowThreads(__tstate);
22279 if (PyErr_Occurred()) SWIG_fail;
22280 }
22281 resultobj = SWIG_Py_Void();
22282 return resultobj;
22283 fail:
22284 return NULL;
22285 }
22286
22287
22288 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22289 PyObject *resultobj = 0;
22290 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22291 bool result;
22292 void *argp1 = 0 ;
22293 int res1 = 0 ;
22294 PyObject *swig_obj[1] ;
22295
22296 if (!args) SWIG_fail;
22297 swig_obj[0] = args;
22298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22299 if (!SWIG_IsOK(res1)) {
22300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22301 }
22302 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22303 {
22304 PyThreadState* __tstate = wxPyBeginAllowThreads();
22305 result = (bool)(arg1)->IsAllowed();
22306 wxPyEndAllowThreads(__tstate);
22307 if (PyErr_Occurred()) SWIG_fail;
22308 }
22309 {
22310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22311 }
22312 return resultobj;
22313 fail:
22314 return NULL;
22315 }
22316
22317
22318 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22319 PyObject *obj;
22320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22321 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22322 return SWIG_Py_Void();
22323 }
22324
22325 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22326 return SWIG_Python_InitShadowInstance(args);
22327 }
22328
22329 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22330 PyObject *resultobj = 0;
22331 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22332 int arg2 = (int) 0 ;
22333 int arg3 = (int) 0 ;
22334 int arg4 = (int) 0 ;
22335 wxScrollEvent *result = 0 ;
22336 int val1 ;
22337 int ecode1 = 0 ;
22338 int val2 ;
22339 int ecode2 = 0 ;
22340 int val3 ;
22341 int ecode3 = 0 ;
22342 int val4 ;
22343 int ecode4 = 0 ;
22344 PyObject * obj0 = 0 ;
22345 PyObject * obj1 = 0 ;
22346 PyObject * obj2 = 0 ;
22347 PyObject * obj3 = 0 ;
22348 char * kwnames[] = {
22349 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22350 };
22351
22352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22353 if (obj0) {
22354 ecode1 = SWIG_AsVal_int(obj0, &val1);
22355 if (!SWIG_IsOK(ecode1)) {
22356 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22357 }
22358 arg1 = static_cast< wxEventType >(val1);
22359 }
22360 if (obj1) {
22361 ecode2 = SWIG_AsVal_int(obj1, &val2);
22362 if (!SWIG_IsOK(ecode2)) {
22363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22364 }
22365 arg2 = static_cast< int >(val2);
22366 }
22367 if (obj2) {
22368 ecode3 = SWIG_AsVal_int(obj2, &val3);
22369 if (!SWIG_IsOK(ecode3)) {
22370 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22371 }
22372 arg3 = static_cast< int >(val3);
22373 }
22374 if (obj3) {
22375 ecode4 = SWIG_AsVal_int(obj3, &val4);
22376 if (!SWIG_IsOK(ecode4)) {
22377 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22378 }
22379 arg4 = static_cast< int >(val4);
22380 }
22381 {
22382 PyThreadState* __tstate = wxPyBeginAllowThreads();
22383 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22384 wxPyEndAllowThreads(__tstate);
22385 if (PyErr_Occurred()) SWIG_fail;
22386 }
22387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22388 return resultobj;
22389 fail:
22390 return NULL;
22391 }
22392
22393
22394 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22395 PyObject *resultobj = 0;
22396 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22397 int result;
22398 void *argp1 = 0 ;
22399 int res1 = 0 ;
22400 PyObject *swig_obj[1] ;
22401
22402 if (!args) SWIG_fail;
22403 swig_obj[0] = args;
22404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22405 if (!SWIG_IsOK(res1)) {
22406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22407 }
22408 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22409 {
22410 PyThreadState* __tstate = wxPyBeginAllowThreads();
22411 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22412 wxPyEndAllowThreads(__tstate);
22413 if (PyErr_Occurred()) SWIG_fail;
22414 }
22415 resultobj = SWIG_From_int(static_cast< int >(result));
22416 return resultobj;
22417 fail:
22418 return NULL;
22419 }
22420
22421
22422 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22423 PyObject *resultobj = 0;
22424 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22425 int result;
22426 void *argp1 = 0 ;
22427 int res1 = 0 ;
22428 PyObject *swig_obj[1] ;
22429
22430 if (!args) SWIG_fail;
22431 swig_obj[0] = args;
22432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22433 if (!SWIG_IsOK(res1)) {
22434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22435 }
22436 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22437 {
22438 PyThreadState* __tstate = wxPyBeginAllowThreads();
22439 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22440 wxPyEndAllowThreads(__tstate);
22441 if (PyErr_Occurred()) SWIG_fail;
22442 }
22443 resultobj = SWIG_From_int(static_cast< int >(result));
22444 return resultobj;
22445 fail:
22446 return NULL;
22447 }
22448
22449
22450 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22451 PyObject *resultobj = 0;
22452 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22453 int arg2 ;
22454 void *argp1 = 0 ;
22455 int res1 = 0 ;
22456 int val2 ;
22457 int ecode2 = 0 ;
22458 PyObject * obj0 = 0 ;
22459 PyObject * obj1 = 0 ;
22460 char * kwnames[] = {
22461 (char *) "self",(char *) "orient", NULL
22462 };
22463
22464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22466 if (!SWIG_IsOK(res1)) {
22467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22468 }
22469 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22470 ecode2 = SWIG_AsVal_int(obj1, &val2);
22471 if (!SWIG_IsOK(ecode2)) {
22472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22473 }
22474 arg2 = static_cast< int >(val2);
22475 {
22476 PyThreadState* __tstate = wxPyBeginAllowThreads();
22477 (arg1)->SetOrientation(arg2);
22478 wxPyEndAllowThreads(__tstate);
22479 if (PyErr_Occurred()) SWIG_fail;
22480 }
22481 resultobj = SWIG_Py_Void();
22482 return resultobj;
22483 fail:
22484 return NULL;
22485 }
22486
22487
22488 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22489 PyObject *resultobj = 0;
22490 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22491 int arg2 ;
22492 void *argp1 = 0 ;
22493 int res1 = 0 ;
22494 int val2 ;
22495 int ecode2 = 0 ;
22496 PyObject * obj0 = 0 ;
22497 PyObject * obj1 = 0 ;
22498 char * kwnames[] = {
22499 (char *) "self",(char *) "pos", NULL
22500 };
22501
22502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22504 if (!SWIG_IsOK(res1)) {
22505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22506 }
22507 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22508 ecode2 = SWIG_AsVal_int(obj1, &val2);
22509 if (!SWIG_IsOK(ecode2)) {
22510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22511 }
22512 arg2 = static_cast< int >(val2);
22513 {
22514 PyThreadState* __tstate = wxPyBeginAllowThreads();
22515 (arg1)->SetPosition(arg2);
22516 wxPyEndAllowThreads(__tstate);
22517 if (PyErr_Occurred()) SWIG_fail;
22518 }
22519 resultobj = SWIG_Py_Void();
22520 return resultobj;
22521 fail:
22522 return NULL;
22523 }
22524
22525
22526 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22527 PyObject *obj;
22528 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22529 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22530 return SWIG_Py_Void();
22531 }
22532
22533 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22534 return SWIG_Python_InitShadowInstance(args);
22535 }
22536
22537 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22538 PyObject *resultobj = 0;
22539 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22540 int arg2 = (int) 0 ;
22541 int arg3 = (int) 0 ;
22542 wxScrollWinEvent *result = 0 ;
22543 int val1 ;
22544 int ecode1 = 0 ;
22545 int val2 ;
22546 int ecode2 = 0 ;
22547 int val3 ;
22548 int ecode3 = 0 ;
22549 PyObject * obj0 = 0 ;
22550 PyObject * obj1 = 0 ;
22551 PyObject * obj2 = 0 ;
22552 char * kwnames[] = {
22553 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22554 };
22555
22556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22557 if (obj0) {
22558 ecode1 = SWIG_AsVal_int(obj0, &val1);
22559 if (!SWIG_IsOK(ecode1)) {
22560 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22561 }
22562 arg1 = static_cast< wxEventType >(val1);
22563 }
22564 if (obj1) {
22565 ecode2 = SWIG_AsVal_int(obj1, &val2);
22566 if (!SWIG_IsOK(ecode2)) {
22567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22568 }
22569 arg2 = static_cast< int >(val2);
22570 }
22571 if (obj2) {
22572 ecode3 = SWIG_AsVal_int(obj2, &val3);
22573 if (!SWIG_IsOK(ecode3)) {
22574 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22575 }
22576 arg3 = static_cast< int >(val3);
22577 }
22578 {
22579 PyThreadState* __tstate = wxPyBeginAllowThreads();
22580 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22581 wxPyEndAllowThreads(__tstate);
22582 if (PyErr_Occurred()) SWIG_fail;
22583 }
22584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22585 return resultobj;
22586 fail:
22587 return NULL;
22588 }
22589
22590
22591 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22592 PyObject *resultobj = 0;
22593 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22594 int result;
22595 void *argp1 = 0 ;
22596 int res1 = 0 ;
22597 PyObject *swig_obj[1] ;
22598
22599 if (!args) SWIG_fail;
22600 swig_obj[0] = args;
22601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22602 if (!SWIG_IsOK(res1)) {
22603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22604 }
22605 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22606 {
22607 PyThreadState* __tstate = wxPyBeginAllowThreads();
22608 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22609 wxPyEndAllowThreads(__tstate);
22610 if (PyErr_Occurred()) SWIG_fail;
22611 }
22612 resultobj = SWIG_From_int(static_cast< int >(result));
22613 return resultobj;
22614 fail:
22615 return NULL;
22616 }
22617
22618
22619 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22620 PyObject *resultobj = 0;
22621 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22622 int result;
22623 void *argp1 = 0 ;
22624 int res1 = 0 ;
22625 PyObject *swig_obj[1] ;
22626
22627 if (!args) SWIG_fail;
22628 swig_obj[0] = args;
22629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22630 if (!SWIG_IsOK(res1)) {
22631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22632 }
22633 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22634 {
22635 PyThreadState* __tstate = wxPyBeginAllowThreads();
22636 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22637 wxPyEndAllowThreads(__tstate);
22638 if (PyErr_Occurred()) SWIG_fail;
22639 }
22640 resultobj = SWIG_From_int(static_cast< int >(result));
22641 return resultobj;
22642 fail:
22643 return NULL;
22644 }
22645
22646
22647 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22648 PyObject *resultobj = 0;
22649 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22650 int arg2 ;
22651 void *argp1 = 0 ;
22652 int res1 = 0 ;
22653 int val2 ;
22654 int ecode2 = 0 ;
22655 PyObject * obj0 = 0 ;
22656 PyObject * obj1 = 0 ;
22657 char * kwnames[] = {
22658 (char *) "self",(char *) "orient", NULL
22659 };
22660
22661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22663 if (!SWIG_IsOK(res1)) {
22664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22665 }
22666 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22667 ecode2 = SWIG_AsVal_int(obj1, &val2);
22668 if (!SWIG_IsOK(ecode2)) {
22669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22670 }
22671 arg2 = static_cast< int >(val2);
22672 {
22673 PyThreadState* __tstate = wxPyBeginAllowThreads();
22674 (arg1)->SetOrientation(arg2);
22675 wxPyEndAllowThreads(__tstate);
22676 if (PyErr_Occurred()) SWIG_fail;
22677 }
22678 resultobj = SWIG_Py_Void();
22679 return resultobj;
22680 fail:
22681 return NULL;
22682 }
22683
22684
22685 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22686 PyObject *resultobj = 0;
22687 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22688 int arg2 ;
22689 void *argp1 = 0 ;
22690 int res1 = 0 ;
22691 int val2 ;
22692 int ecode2 = 0 ;
22693 PyObject * obj0 = 0 ;
22694 PyObject * obj1 = 0 ;
22695 char * kwnames[] = {
22696 (char *) "self",(char *) "pos", NULL
22697 };
22698
22699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22701 if (!SWIG_IsOK(res1)) {
22702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22703 }
22704 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22705 ecode2 = SWIG_AsVal_int(obj1, &val2);
22706 if (!SWIG_IsOK(ecode2)) {
22707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22708 }
22709 arg2 = static_cast< int >(val2);
22710 {
22711 PyThreadState* __tstate = wxPyBeginAllowThreads();
22712 (arg1)->SetPosition(arg2);
22713 wxPyEndAllowThreads(__tstate);
22714 if (PyErr_Occurred()) SWIG_fail;
22715 }
22716 resultobj = SWIG_Py_Void();
22717 return resultobj;
22718 fail:
22719 return NULL;
22720 }
22721
22722
22723 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22724 PyObject *obj;
22725 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22726 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22727 return SWIG_Py_Void();
22728 }
22729
22730 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22731 return SWIG_Python_InitShadowInstance(args);
22732 }
22733
22734 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22735 PyObject *resultobj = 0;
22736 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22737 wxMouseEvent *result = 0 ;
22738 int val1 ;
22739 int ecode1 = 0 ;
22740 PyObject * obj0 = 0 ;
22741 char * kwnames[] = {
22742 (char *) "mouseType", NULL
22743 };
22744
22745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22746 if (obj0) {
22747 ecode1 = SWIG_AsVal_int(obj0, &val1);
22748 if (!SWIG_IsOK(ecode1)) {
22749 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22750 }
22751 arg1 = static_cast< wxEventType >(val1);
22752 }
22753 {
22754 PyThreadState* __tstate = wxPyBeginAllowThreads();
22755 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22756 wxPyEndAllowThreads(__tstate);
22757 if (PyErr_Occurred()) SWIG_fail;
22758 }
22759 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22760 return resultobj;
22761 fail:
22762 return NULL;
22763 }
22764
22765
22766 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22767 PyObject *resultobj = 0;
22768 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22769 bool result;
22770 void *argp1 = 0 ;
22771 int res1 = 0 ;
22772 PyObject *swig_obj[1] ;
22773
22774 if (!args) SWIG_fail;
22775 swig_obj[0] = args;
22776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22777 if (!SWIG_IsOK(res1)) {
22778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22779 }
22780 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22781 {
22782 PyThreadState* __tstate = wxPyBeginAllowThreads();
22783 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22784 wxPyEndAllowThreads(__tstate);
22785 if (PyErr_Occurred()) SWIG_fail;
22786 }
22787 {
22788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22789 }
22790 return resultobj;
22791 fail:
22792 return NULL;
22793 }
22794
22795
22796 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22797 PyObject *resultobj = 0;
22798 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22799 int arg2 = (int) wxMOUSE_BTN_ANY ;
22800 bool result;
22801 void *argp1 = 0 ;
22802 int res1 = 0 ;
22803 int val2 ;
22804 int ecode2 = 0 ;
22805 PyObject * obj0 = 0 ;
22806 PyObject * obj1 = 0 ;
22807 char * kwnames[] = {
22808 (char *) "self",(char *) "but", NULL
22809 };
22810
22811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22813 if (!SWIG_IsOK(res1)) {
22814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22815 }
22816 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22817 if (obj1) {
22818 ecode2 = SWIG_AsVal_int(obj1, &val2);
22819 if (!SWIG_IsOK(ecode2)) {
22820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22821 }
22822 arg2 = static_cast< int >(val2);
22823 }
22824 {
22825 PyThreadState* __tstate = wxPyBeginAllowThreads();
22826 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22827 wxPyEndAllowThreads(__tstate);
22828 if (PyErr_Occurred()) SWIG_fail;
22829 }
22830 {
22831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22832 }
22833 return resultobj;
22834 fail:
22835 return NULL;
22836 }
22837
22838
22839 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22840 PyObject *resultobj = 0;
22841 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22842 int arg2 = (int) wxMOUSE_BTN_ANY ;
22843 bool result;
22844 void *argp1 = 0 ;
22845 int res1 = 0 ;
22846 int val2 ;
22847 int ecode2 = 0 ;
22848 PyObject * obj0 = 0 ;
22849 PyObject * obj1 = 0 ;
22850 char * kwnames[] = {
22851 (char *) "self",(char *) "but", NULL
22852 };
22853
22854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22856 if (!SWIG_IsOK(res1)) {
22857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22858 }
22859 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22860 if (obj1) {
22861 ecode2 = SWIG_AsVal_int(obj1, &val2);
22862 if (!SWIG_IsOK(ecode2)) {
22863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22864 }
22865 arg2 = static_cast< int >(val2);
22866 }
22867 {
22868 PyThreadState* __tstate = wxPyBeginAllowThreads();
22869 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22870 wxPyEndAllowThreads(__tstate);
22871 if (PyErr_Occurred()) SWIG_fail;
22872 }
22873 {
22874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22875 }
22876 return resultobj;
22877 fail:
22878 return NULL;
22879 }
22880
22881
22882 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22883 PyObject *resultobj = 0;
22884 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22885 int arg2 = (int) wxMOUSE_BTN_ANY ;
22886 bool result;
22887 void *argp1 = 0 ;
22888 int res1 = 0 ;
22889 int val2 ;
22890 int ecode2 = 0 ;
22891 PyObject * obj0 = 0 ;
22892 PyObject * obj1 = 0 ;
22893 char * kwnames[] = {
22894 (char *) "self",(char *) "but", NULL
22895 };
22896
22897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22899 if (!SWIG_IsOK(res1)) {
22900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22901 }
22902 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22903 if (obj1) {
22904 ecode2 = SWIG_AsVal_int(obj1, &val2);
22905 if (!SWIG_IsOK(ecode2)) {
22906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22907 }
22908 arg2 = static_cast< int >(val2);
22909 }
22910 {
22911 PyThreadState* __tstate = wxPyBeginAllowThreads();
22912 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22913 wxPyEndAllowThreads(__tstate);
22914 if (PyErr_Occurred()) SWIG_fail;
22915 }
22916 {
22917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22918 }
22919 return resultobj;
22920 fail:
22921 return NULL;
22922 }
22923
22924
22925 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22926 PyObject *resultobj = 0;
22927 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22928 int arg2 ;
22929 bool result;
22930 void *argp1 = 0 ;
22931 int res1 = 0 ;
22932 int val2 ;
22933 int ecode2 = 0 ;
22934 PyObject * obj0 = 0 ;
22935 PyObject * obj1 = 0 ;
22936 char * kwnames[] = {
22937 (char *) "self",(char *) "button", NULL
22938 };
22939
22940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
22941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22942 if (!SWIG_IsOK(res1)) {
22943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22944 }
22945 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22946 ecode2 = SWIG_AsVal_int(obj1, &val2);
22947 if (!SWIG_IsOK(ecode2)) {
22948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
22949 }
22950 arg2 = static_cast< int >(val2);
22951 {
22952 PyThreadState* __tstate = wxPyBeginAllowThreads();
22953 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
22954 wxPyEndAllowThreads(__tstate);
22955 if (PyErr_Occurred()) SWIG_fail;
22956 }
22957 {
22958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22959 }
22960 return resultobj;
22961 fail:
22962 return NULL;
22963 }
22964
22965
22966 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22967 PyObject *resultobj = 0;
22968 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22969 int arg2 ;
22970 bool result;
22971 void *argp1 = 0 ;
22972 int res1 = 0 ;
22973 int val2 ;
22974 int ecode2 = 0 ;
22975 PyObject * obj0 = 0 ;
22976 PyObject * obj1 = 0 ;
22977 char * kwnames[] = {
22978 (char *) "self",(char *) "but", NULL
22979 };
22980
22981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
22982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22983 if (!SWIG_IsOK(res1)) {
22984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22985 }
22986 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22987 ecode2 = SWIG_AsVal_int(obj1, &val2);
22988 if (!SWIG_IsOK(ecode2)) {
22989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
22990 }
22991 arg2 = static_cast< int >(val2);
22992 {
22993 PyThreadState* __tstate = wxPyBeginAllowThreads();
22994 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
22995 wxPyEndAllowThreads(__tstate);
22996 if (PyErr_Occurred()) SWIG_fail;
22997 }
22998 {
22999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23000 }
23001 return resultobj;
23002 fail:
23003 return NULL;
23004 }
23005
23006
23007 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23008 PyObject *resultobj = 0;
23009 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23010 int result;
23011 void *argp1 = 0 ;
23012 int res1 = 0 ;
23013 PyObject *swig_obj[1] ;
23014
23015 if (!args) SWIG_fail;
23016 swig_obj[0] = args;
23017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23018 if (!SWIG_IsOK(res1)) {
23019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23020 }
23021 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23022 {
23023 PyThreadState* __tstate = wxPyBeginAllowThreads();
23024 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23025 wxPyEndAllowThreads(__tstate);
23026 if (PyErr_Occurred()) SWIG_fail;
23027 }
23028 resultobj = SWIG_From_int(static_cast< int >(result));
23029 return resultobj;
23030 fail:
23031 return NULL;
23032 }
23033
23034
23035 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23036 PyObject *resultobj = 0;
23037 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23038 bool result;
23039 void *argp1 = 0 ;
23040 int res1 = 0 ;
23041 PyObject *swig_obj[1] ;
23042
23043 if (!args) SWIG_fail;
23044 swig_obj[0] = args;
23045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23046 if (!SWIG_IsOK(res1)) {
23047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23048 }
23049 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23050 {
23051 PyThreadState* __tstate = wxPyBeginAllowThreads();
23052 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23053 wxPyEndAllowThreads(__tstate);
23054 if (PyErr_Occurred()) SWIG_fail;
23055 }
23056 {
23057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23058 }
23059 return resultobj;
23060 fail:
23061 return NULL;
23062 }
23063
23064
23065 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23066 PyObject *resultobj = 0;
23067 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23068 bool result;
23069 void *argp1 = 0 ;
23070 int res1 = 0 ;
23071 PyObject *swig_obj[1] ;
23072
23073 if (!args) SWIG_fail;
23074 swig_obj[0] = args;
23075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23076 if (!SWIG_IsOK(res1)) {
23077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23078 }
23079 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23080 {
23081 PyThreadState* __tstate = wxPyBeginAllowThreads();
23082 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23083 wxPyEndAllowThreads(__tstate);
23084 if (PyErr_Occurred()) SWIG_fail;
23085 }
23086 {
23087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23088 }
23089 return resultobj;
23090 fail:
23091 return NULL;
23092 }
23093
23094
23095 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23096 PyObject *resultobj = 0;
23097 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23098 bool result;
23099 void *argp1 = 0 ;
23100 int res1 = 0 ;
23101 PyObject *swig_obj[1] ;
23102
23103 if (!args) SWIG_fail;
23104 swig_obj[0] = args;
23105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23106 if (!SWIG_IsOK(res1)) {
23107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23108 }
23109 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23110 {
23111 PyThreadState* __tstate = wxPyBeginAllowThreads();
23112 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23113 wxPyEndAllowThreads(__tstate);
23114 if (PyErr_Occurred()) SWIG_fail;
23115 }
23116 {
23117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23118 }
23119 return resultobj;
23120 fail:
23121 return NULL;
23122 }
23123
23124
23125 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23126 PyObject *resultobj = 0;
23127 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23128 bool result;
23129 void *argp1 = 0 ;
23130 int res1 = 0 ;
23131 PyObject *swig_obj[1] ;
23132
23133 if (!args) SWIG_fail;
23134 swig_obj[0] = args;
23135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23136 if (!SWIG_IsOK(res1)) {
23137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23138 }
23139 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23140 {
23141 PyThreadState* __tstate = wxPyBeginAllowThreads();
23142 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23143 wxPyEndAllowThreads(__tstate);
23144 if (PyErr_Occurred()) SWIG_fail;
23145 }
23146 {
23147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23148 }
23149 return resultobj;
23150 fail:
23151 return NULL;
23152 }
23153
23154
23155 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23156 PyObject *resultobj = 0;
23157 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23158 bool result;
23159 void *argp1 = 0 ;
23160 int res1 = 0 ;
23161 PyObject *swig_obj[1] ;
23162
23163 if (!args) SWIG_fail;
23164 swig_obj[0] = args;
23165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23166 if (!SWIG_IsOK(res1)) {
23167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23168 }
23169 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23170 {
23171 PyThreadState* __tstate = wxPyBeginAllowThreads();
23172 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23173 wxPyEndAllowThreads(__tstate);
23174 if (PyErr_Occurred()) SWIG_fail;
23175 }
23176 {
23177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23178 }
23179 return resultobj;
23180 fail:
23181 return NULL;
23182 }
23183
23184
23185 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23186 PyObject *resultobj = 0;
23187 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23188 bool result;
23189 void *argp1 = 0 ;
23190 int res1 = 0 ;
23191 PyObject *swig_obj[1] ;
23192
23193 if (!args) SWIG_fail;
23194 swig_obj[0] = args;
23195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23196 if (!SWIG_IsOK(res1)) {
23197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23198 }
23199 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23200 {
23201 PyThreadState* __tstate = wxPyBeginAllowThreads();
23202 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23203 wxPyEndAllowThreads(__tstate);
23204 if (PyErr_Occurred()) SWIG_fail;
23205 }
23206 {
23207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23208 }
23209 return resultobj;
23210 fail:
23211 return NULL;
23212 }
23213
23214
23215 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23216 PyObject *resultobj = 0;
23217 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23218 bool result;
23219 void *argp1 = 0 ;
23220 int res1 = 0 ;
23221 PyObject *swig_obj[1] ;
23222
23223 if (!args) SWIG_fail;
23224 swig_obj[0] = args;
23225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23226 if (!SWIG_IsOK(res1)) {
23227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23228 }
23229 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23230 {
23231 PyThreadState* __tstate = wxPyBeginAllowThreads();
23232 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23233 wxPyEndAllowThreads(__tstate);
23234 if (PyErr_Occurred()) SWIG_fail;
23235 }
23236 {
23237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23238 }
23239 return resultobj;
23240 fail:
23241 return NULL;
23242 }
23243
23244
23245 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23246 PyObject *resultobj = 0;
23247 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23248 bool result;
23249 void *argp1 = 0 ;
23250 int res1 = 0 ;
23251 PyObject *swig_obj[1] ;
23252
23253 if (!args) SWIG_fail;
23254 swig_obj[0] = args;
23255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23256 if (!SWIG_IsOK(res1)) {
23257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23258 }
23259 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23260 {
23261 PyThreadState* __tstate = wxPyBeginAllowThreads();
23262 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23263 wxPyEndAllowThreads(__tstate);
23264 if (PyErr_Occurred()) SWIG_fail;
23265 }
23266 {
23267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23268 }
23269 return resultobj;
23270 fail:
23271 return NULL;
23272 }
23273
23274
23275 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23276 PyObject *resultobj = 0;
23277 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23278 bool result;
23279 void *argp1 = 0 ;
23280 int res1 = 0 ;
23281 PyObject *swig_obj[1] ;
23282
23283 if (!args) SWIG_fail;
23284 swig_obj[0] = args;
23285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23286 if (!SWIG_IsOK(res1)) {
23287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23288 }
23289 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23290 {
23291 PyThreadState* __tstate = wxPyBeginAllowThreads();
23292 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23293 wxPyEndAllowThreads(__tstate);
23294 if (PyErr_Occurred()) SWIG_fail;
23295 }
23296 {
23297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23298 }
23299 return resultobj;
23300 fail:
23301 return NULL;
23302 }
23303
23304
23305 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23306 PyObject *resultobj = 0;
23307 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23308 bool result;
23309 void *argp1 = 0 ;
23310 int res1 = 0 ;
23311 PyObject *swig_obj[1] ;
23312
23313 if (!args) SWIG_fail;
23314 swig_obj[0] = args;
23315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23316 if (!SWIG_IsOK(res1)) {
23317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23318 }
23319 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23320 {
23321 PyThreadState* __tstate = wxPyBeginAllowThreads();
23322 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23323 wxPyEndAllowThreads(__tstate);
23324 if (PyErr_Occurred()) SWIG_fail;
23325 }
23326 {
23327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23328 }
23329 return resultobj;
23330 fail:
23331 return NULL;
23332 }
23333
23334
23335 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23336 PyObject *resultobj = 0;
23337 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23338 bool result;
23339 void *argp1 = 0 ;
23340 int res1 = 0 ;
23341 PyObject *swig_obj[1] ;
23342
23343 if (!args) SWIG_fail;
23344 swig_obj[0] = args;
23345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23346 if (!SWIG_IsOK(res1)) {
23347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23348 }
23349 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23350 {
23351 PyThreadState* __tstate = wxPyBeginAllowThreads();
23352 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23353 wxPyEndAllowThreads(__tstate);
23354 if (PyErr_Occurred()) SWIG_fail;
23355 }
23356 {
23357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23358 }
23359 return resultobj;
23360 fail:
23361 return NULL;
23362 }
23363
23364
23365 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23366 PyObject *resultobj = 0;
23367 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23368 bool result;
23369 void *argp1 = 0 ;
23370 int res1 = 0 ;
23371 PyObject *swig_obj[1] ;
23372
23373 if (!args) SWIG_fail;
23374 swig_obj[0] = args;
23375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23376 if (!SWIG_IsOK(res1)) {
23377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23378 }
23379 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23380 {
23381 PyThreadState* __tstate = wxPyBeginAllowThreads();
23382 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23383 wxPyEndAllowThreads(__tstate);
23384 if (PyErr_Occurred()) SWIG_fail;
23385 }
23386 {
23387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23388 }
23389 return resultobj;
23390 fail:
23391 return NULL;
23392 }
23393
23394
23395 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23396 PyObject *resultobj = 0;
23397 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23398 bool result;
23399 void *argp1 = 0 ;
23400 int res1 = 0 ;
23401 PyObject *swig_obj[1] ;
23402
23403 if (!args) SWIG_fail;
23404 swig_obj[0] = args;
23405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23406 if (!SWIG_IsOK(res1)) {
23407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23408 }
23409 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23410 {
23411 PyThreadState* __tstate = wxPyBeginAllowThreads();
23412 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23413 wxPyEndAllowThreads(__tstate);
23414 if (PyErr_Occurred()) SWIG_fail;
23415 }
23416 {
23417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23418 }
23419 return resultobj;
23420 fail:
23421 return NULL;
23422 }
23423
23424
23425 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23426 PyObject *resultobj = 0;
23427 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23428 bool result;
23429 void *argp1 = 0 ;
23430 int res1 = 0 ;
23431 PyObject *swig_obj[1] ;
23432
23433 if (!args) SWIG_fail;
23434 swig_obj[0] = args;
23435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23436 if (!SWIG_IsOK(res1)) {
23437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23438 }
23439 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23440 {
23441 PyThreadState* __tstate = wxPyBeginAllowThreads();
23442 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23443 wxPyEndAllowThreads(__tstate);
23444 if (PyErr_Occurred()) SWIG_fail;
23445 }
23446 {
23447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23448 }
23449 return resultobj;
23450 fail:
23451 return NULL;
23452 }
23453
23454
23455 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23456 PyObject *resultobj = 0;
23457 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23458 bool result;
23459 void *argp1 = 0 ;
23460 int res1 = 0 ;
23461 PyObject *swig_obj[1] ;
23462
23463 if (!args) SWIG_fail;
23464 swig_obj[0] = args;
23465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23466 if (!SWIG_IsOK(res1)) {
23467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23468 }
23469 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23470 {
23471 PyThreadState* __tstate = wxPyBeginAllowThreads();
23472 result = (bool)(arg1)->LeftIsDown();
23473 wxPyEndAllowThreads(__tstate);
23474 if (PyErr_Occurred()) SWIG_fail;
23475 }
23476 {
23477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23478 }
23479 return resultobj;
23480 fail:
23481 return NULL;
23482 }
23483
23484
23485 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23486 PyObject *resultobj = 0;
23487 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23488 bool result;
23489 void *argp1 = 0 ;
23490 int res1 = 0 ;
23491 PyObject *swig_obj[1] ;
23492
23493 if (!args) SWIG_fail;
23494 swig_obj[0] = args;
23495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23496 if (!SWIG_IsOK(res1)) {
23497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23498 }
23499 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23500 {
23501 PyThreadState* __tstate = wxPyBeginAllowThreads();
23502 result = (bool)(arg1)->MiddleIsDown();
23503 wxPyEndAllowThreads(__tstate);
23504 if (PyErr_Occurred()) SWIG_fail;
23505 }
23506 {
23507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23508 }
23509 return resultobj;
23510 fail:
23511 return NULL;
23512 }
23513
23514
23515 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23516 PyObject *resultobj = 0;
23517 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23518 bool result;
23519 void *argp1 = 0 ;
23520 int res1 = 0 ;
23521 PyObject *swig_obj[1] ;
23522
23523 if (!args) SWIG_fail;
23524 swig_obj[0] = args;
23525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23526 if (!SWIG_IsOK(res1)) {
23527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23528 }
23529 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23530 {
23531 PyThreadState* __tstate = wxPyBeginAllowThreads();
23532 result = (bool)(arg1)->RightIsDown();
23533 wxPyEndAllowThreads(__tstate);
23534 if (PyErr_Occurred()) SWIG_fail;
23535 }
23536 {
23537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23538 }
23539 return resultobj;
23540 fail:
23541 return NULL;
23542 }
23543
23544
23545 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23546 PyObject *resultobj = 0;
23547 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23548 bool result;
23549 void *argp1 = 0 ;
23550 int res1 = 0 ;
23551 PyObject *swig_obj[1] ;
23552
23553 if (!args) SWIG_fail;
23554 swig_obj[0] = args;
23555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23556 if (!SWIG_IsOK(res1)) {
23557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23558 }
23559 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23560 {
23561 PyThreadState* __tstate = wxPyBeginAllowThreads();
23562 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23563 wxPyEndAllowThreads(__tstate);
23564 if (PyErr_Occurred()) SWIG_fail;
23565 }
23566 {
23567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23568 }
23569 return resultobj;
23570 fail:
23571 return NULL;
23572 }
23573
23574
23575 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23576 PyObject *resultobj = 0;
23577 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23578 bool result;
23579 void *argp1 = 0 ;
23580 int res1 = 0 ;
23581 PyObject *swig_obj[1] ;
23582
23583 if (!args) SWIG_fail;
23584 swig_obj[0] = args;
23585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23586 if (!SWIG_IsOK(res1)) {
23587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23588 }
23589 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23590 {
23591 PyThreadState* __tstate = wxPyBeginAllowThreads();
23592 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23593 wxPyEndAllowThreads(__tstate);
23594 if (PyErr_Occurred()) SWIG_fail;
23595 }
23596 {
23597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23598 }
23599 return resultobj;
23600 fail:
23601 return NULL;
23602 }
23603
23604
23605 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23606 PyObject *resultobj = 0;
23607 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23608 bool result;
23609 void *argp1 = 0 ;
23610 int res1 = 0 ;
23611 PyObject *swig_obj[1] ;
23612
23613 if (!args) SWIG_fail;
23614 swig_obj[0] = args;
23615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23616 if (!SWIG_IsOK(res1)) {
23617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23618 }
23619 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23620 {
23621 PyThreadState* __tstate = wxPyBeginAllowThreads();
23622 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23623 wxPyEndAllowThreads(__tstate);
23624 if (PyErr_Occurred()) SWIG_fail;
23625 }
23626 {
23627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23628 }
23629 return resultobj;
23630 fail:
23631 return NULL;
23632 }
23633
23634
23635 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23636 PyObject *resultobj = 0;
23637 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23638 bool result;
23639 void *argp1 = 0 ;
23640 int res1 = 0 ;
23641 PyObject *swig_obj[1] ;
23642
23643 if (!args) SWIG_fail;
23644 swig_obj[0] = args;
23645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23646 if (!SWIG_IsOK(res1)) {
23647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23648 }
23649 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23650 {
23651 PyThreadState* __tstate = wxPyBeginAllowThreads();
23652 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23653 wxPyEndAllowThreads(__tstate);
23654 if (PyErr_Occurred()) SWIG_fail;
23655 }
23656 {
23657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23658 }
23659 return resultobj;
23660 fail:
23661 return NULL;
23662 }
23663
23664
23665 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23666 PyObject *resultobj = 0;
23667 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23668 wxPoint result;
23669 void *argp1 = 0 ;
23670 int res1 = 0 ;
23671 PyObject *swig_obj[1] ;
23672
23673 if (!args) SWIG_fail;
23674 swig_obj[0] = args;
23675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23676 if (!SWIG_IsOK(res1)) {
23677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23678 }
23679 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23680 {
23681 PyThreadState* __tstate = wxPyBeginAllowThreads();
23682 result = (arg1)->GetPosition();
23683 wxPyEndAllowThreads(__tstate);
23684 if (PyErr_Occurred()) SWIG_fail;
23685 }
23686 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23687 return resultobj;
23688 fail:
23689 return NULL;
23690 }
23691
23692
23693 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23694 PyObject *resultobj = 0;
23695 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23696 long *arg2 = (long *) 0 ;
23697 long *arg3 = (long *) 0 ;
23698 void *argp1 = 0 ;
23699 int res1 = 0 ;
23700 long temp2 ;
23701 int res2 = SWIG_TMPOBJ ;
23702 long temp3 ;
23703 int res3 = SWIG_TMPOBJ ;
23704 PyObject *swig_obj[1] ;
23705
23706 arg2 = &temp2;
23707 arg3 = &temp3;
23708 if (!args) SWIG_fail;
23709 swig_obj[0] = args;
23710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23711 if (!SWIG_IsOK(res1)) {
23712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23713 }
23714 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23715 {
23716 PyThreadState* __tstate = wxPyBeginAllowThreads();
23717 (arg1)->GetPosition(arg2,arg3);
23718 wxPyEndAllowThreads(__tstate);
23719 if (PyErr_Occurred()) SWIG_fail;
23720 }
23721 resultobj = SWIG_Py_Void();
23722 if (SWIG_IsTmpObj(res2)) {
23723 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23724 } else {
23725 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23726 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23727 }
23728 if (SWIG_IsTmpObj(res3)) {
23729 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23730 } else {
23731 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23732 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23733 }
23734 return resultobj;
23735 fail:
23736 return NULL;
23737 }
23738
23739
23740 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23741 PyObject *resultobj = 0;
23742 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23743 wxDC *arg2 = 0 ;
23744 wxPoint result;
23745 void *argp1 = 0 ;
23746 int res1 = 0 ;
23747 void *argp2 = 0 ;
23748 int res2 = 0 ;
23749 PyObject * obj0 = 0 ;
23750 PyObject * obj1 = 0 ;
23751 char * kwnames[] = {
23752 (char *) "self",(char *) "dc", NULL
23753 };
23754
23755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23757 if (!SWIG_IsOK(res1)) {
23758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23759 }
23760 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23761 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23762 if (!SWIG_IsOK(res2)) {
23763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23764 }
23765 if (!argp2) {
23766 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23767 }
23768 arg2 = reinterpret_cast< wxDC * >(argp2);
23769 {
23770 PyThreadState* __tstate = wxPyBeginAllowThreads();
23771 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23772 wxPyEndAllowThreads(__tstate);
23773 if (PyErr_Occurred()) SWIG_fail;
23774 }
23775 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23776 return resultobj;
23777 fail:
23778 return NULL;
23779 }
23780
23781
23782 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23783 PyObject *resultobj = 0;
23784 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23785 int result;
23786 void *argp1 = 0 ;
23787 int res1 = 0 ;
23788 PyObject *swig_obj[1] ;
23789
23790 if (!args) SWIG_fail;
23791 swig_obj[0] = args;
23792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23793 if (!SWIG_IsOK(res1)) {
23794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23795 }
23796 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23797 {
23798 PyThreadState* __tstate = wxPyBeginAllowThreads();
23799 result = (int)((wxMouseEvent const *)arg1)->GetX();
23800 wxPyEndAllowThreads(__tstate);
23801 if (PyErr_Occurred()) SWIG_fail;
23802 }
23803 resultobj = SWIG_From_int(static_cast< int >(result));
23804 return resultobj;
23805 fail:
23806 return NULL;
23807 }
23808
23809
23810 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23811 PyObject *resultobj = 0;
23812 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23813 int result;
23814 void *argp1 = 0 ;
23815 int res1 = 0 ;
23816 PyObject *swig_obj[1] ;
23817
23818 if (!args) SWIG_fail;
23819 swig_obj[0] = args;
23820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23821 if (!SWIG_IsOK(res1)) {
23822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23823 }
23824 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23825 {
23826 PyThreadState* __tstate = wxPyBeginAllowThreads();
23827 result = (int)((wxMouseEvent const *)arg1)->GetY();
23828 wxPyEndAllowThreads(__tstate);
23829 if (PyErr_Occurred()) SWIG_fail;
23830 }
23831 resultobj = SWIG_From_int(static_cast< int >(result));
23832 return resultobj;
23833 fail:
23834 return NULL;
23835 }
23836
23837
23838 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23839 PyObject *resultobj = 0;
23840 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23841 int result;
23842 void *argp1 = 0 ;
23843 int res1 = 0 ;
23844 PyObject *swig_obj[1] ;
23845
23846 if (!args) SWIG_fail;
23847 swig_obj[0] = args;
23848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23849 if (!SWIG_IsOK(res1)) {
23850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23851 }
23852 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23853 {
23854 PyThreadState* __tstate = wxPyBeginAllowThreads();
23855 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23856 wxPyEndAllowThreads(__tstate);
23857 if (PyErr_Occurred()) SWIG_fail;
23858 }
23859 resultobj = SWIG_From_int(static_cast< int >(result));
23860 return resultobj;
23861 fail:
23862 return NULL;
23863 }
23864
23865
23866 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23867 PyObject *resultobj = 0;
23868 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23869 int result;
23870 void *argp1 = 0 ;
23871 int res1 = 0 ;
23872 PyObject *swig_obj[1] ;
23873
23874 if (!args) SWIG_fail;
23875 swig_obj[0] = args;
23876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23877 if (!SWIG_IsOK(res1)) {
23878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23879 }
23880 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23881 {
23882 PyThreadState* __tstate = wxPyBeginAllowThreads();
23883 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23884 wxPyEndAllowThreads(__tstate);
23885 if (PyErr_Occurred()) SWIG_fail;
23886 }
23887 resultobj = SWIG_From_int(static_cast< int >(result));
23888 return resultobj;
23889 fail:
23890 return NULL;
23891 }
23892
23893
23894 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelAxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23895 PyObject *resultobj = 0;
23896 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23897 int result;
23898 void *argp1 = 0 ;
23899 int res1 = 0 ;
23900 PyObject *swig_obj[1] ;
23901
23902 if (!args) SWIG_fail;
23903 swig_obj[0] = args;
23904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23905 if (!SWIG_IsOK(res1)) {
23906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelAxis" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23907 }
23908 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23909 {
23910 PyThreadState* __tstate = wxPyBeginAllowThreads();
23911 result = (int)((wxMouseEvent const *)arg1)->GetWheelAxis();
23912 wxPyEndAllowThreads(__tstate);
23913 if (PyErr_Occurred()) SWIG_fail;
23914 }
23915 resultobj = SWIG_From_int(static_cast< int >(result));
23916 return resultobj;
23917 fail:
23918 return NULL;
23919 }
23920
23921
23922 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23923 PyObject *resultobj = 0;
23924 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23925 int result;
23926 void *argp1 = 0 ;
23927 int res1 = 0 ;
23928 PyObject *swig_obj[1] ;
23929
23930 if (!args) SWIG_fail;
23931 swig_obj[0] = args;
23932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23933 if (!SWIG_IsOK(res1)) {
23934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23935 }
23936 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23937 {
23938 PyThreadState* __tstate = wxPyBeginAllowThreads();
23939 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
23940 wxPyEndAllowThreads(__tstate);
23941 if (PyErr_Occurred()) SWIG_fail;
23942 }
23943 resultobj = SWIG_From_int(static_cast< int >(result));
23944 return resultobj;
23945 fail:
23946 return NULL;
23947 }
23948
23949
23950 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23951 PyObject *resultobj = 0;
23952 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23953 bool result;
23954 void *argp1 = 0 ;
23955 int res1 = 0 ;
23956 PyObject *swig_obj[1] ;
23957
23958 if (!args) SWIG_fail;
23959 swig_obj[0] = args;
23960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23961 if (!SWIG_IsOK(res1)) {
23962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23963 }
23964 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23965 {
23966 PyThreadState* __tstate = wxPyBeginAllowThreads();
23967 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
23968 wxPyEndAllowThreads(__tstate);
23969 if (PyErr_Occurred()) SWIG_fail;
23970 }
23971 {
23972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23973 }
23974 return resultobj;
23975 fail:
23976 return NULL;
23977 }
23978
23979
23980 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23981 PyObject *resultobj = 0;
23982 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23983 int arg2 ;
23984 void *argp1 = 0 ;
23985 int res1 = 0 ;
23986 int val2 ;
23987 int ecode2 = 0 ;
23988 PyObject *swig_obj[2] ;
23989
23990 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23992 if (!SWIG_IsOK(res1)) {
23993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23994 }
23995 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23996 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23997 if (!SWIG_IsOK(ecode2)) {
23998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23999 }
24000 arg2 = static_cast< int >(val2);
24001 if (arg1) (arg1)->m_x = arg2;
24002
24003 resultobj = SWIG_Py_Void();
24004 return resultobj;
24005 fail:
24006 return NULL;
24007 }
24008
24009
24010 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24011 PyObject *resultobj = 0;
24012 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24013 int result;
24014 void *argp1 = 0 ;
24015 int res1 = 0 ;
24016 PyObject *swig_obj[1] ;
24017
24018 if (!args) SWIG_fail;
24019 swig_obj[0] = args;
24020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24021 if (!SWIG_IsOK(res1)) {
24022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24023 }
24024 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24025 result = (int) ((arg1)->m_x);
24026 resultobj = SWIG_From_int(static_cast< int >(result));
24027 return resultobj;
24028 fail:
24029 return NULL;
24030 }
24031
24032
24033 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24034 PyObject *resultobj = 0;
24035 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24036 int arg2 ;
24037 void *argp1 = 0 ;
24038 int res1 = 0 ;
24039 int val2 ;
24040 int ecode2 = 0 ;
24041 PyObject *swig_obj[2] ;
24042
24043 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24045 if (!SWIG_IsOK(res1)) {
24046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24047 }
24048 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24049 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24050 if (!SWIG_IsOK(ecode2)) {
24051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24052 }
24053 arg2 = static_cast< int >(val2);
24054 if (arg1) (arg1)->m_y = arg2;
24055
24056 resultobj = SWIG_Py_Void();
24057 return resultobj;
24058 fail:
24059 return NULL;
24060 }
24061
24062
24063 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24064 PyObject *resultobj = 0;
24065 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24066 int result;
24067 void *argp1 = 0 ;
24068 int res1 = 0 ;
24069 PyObject *swig_obj[1] ;
24070
24071 if (!args) SWIG_fail;
24072 swig_obj[0] = args;
24073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24074 if (!SWIG_IsOK(res1)) {
24075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24076 }
24077 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24078 result = (int) ((arg1)->m_y);
24079 resultobj = SWIG_From_int(static_cast< int >(result));
24080 return resultobj;
24081 fail:
24082 return NULL;
24083 }
24084
24085
24086 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24087 PyObject *resultobj = 0;
24088 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24089 bool arg2 ;
24090 void *argp1 = 0 ;
24091 int res1 = 0 ;
24092 bool val2 ;
24093 int ecode2 = 0 ;
24094 PyObject *swig_obj[2] ;
24095
24096 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24098 if (!SWIG_IsOK(res1)) {
24099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24100 }
24101 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24102 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24103 if (!SWIG_IsOK(ecode2)) {
24104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24105 }
24106 arg2 = static_cast< bool >(val2);
24107 if (arg1) (arg1)->m_leftDown = arg2;
24108
24109 resultobj = SWIG_Py_Void();
24110 return resultobj;
24111 fail:
24112 return NULL;
24113 }
24114
24115
24116 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24117 PyObject *resultobj = 0;
24118 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24119 bool result;
24120 void *argp1 = 0 ;
24121 int res1 = 0 ;
24122 PyObject *swig_obj[1] ;
24123
24124 if (!args) SWIG_fail;
24125 swig_obj[0] = args;
24126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24127 if (!SWIG_IsOK(res1)) {
24128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24129 }
24130 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24131 result = (bool) ((arg1)->m_leftDown);
24132 {
24133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24134 }
24135 return resultobj;
24136 fail:
24137 return NULL;
24138 }
24139
24140
24141 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24142 PyObject *resultobj = 0;
24143 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24144 bool arg2 ;
24145 void *argp1 = 0 ;
24146 int res1 = 0 ;
24147 bool val2 ;
24148 int ecode2 = 0 ;
24149 PyObject *swig_obj[2] ;
24150
24151 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24153 if (!SWIG_IsOK(res1)) {
24154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24155 }
24156 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24157 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24158 if (!SWIG_IsOK(ecode2)) {
24159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24160 }
24161 arg2 = static_cast< bool >(val2);
24162 if (arg1) (arg1)->m_middleDown = arg2;
24163
24164 resultobj = SWIG_Py_Void();
24165 return resultobj;
24166 fail:
24167 return NULL;
24168 }
24169
24170
24171 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24172 PyObject *resultobj = 0;
24173 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24174 bool result;
24175 void *argp1 = 0 ;
24176 int res1 = 0 ;
24177 PyObject *swig_obj[1] ;
24178
24179 if (!args) SWIG_fail;
24180 swig_obj[0] = args;
24181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24182 if (!SWIG_IsOK(res1)) {
24183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24184 }
24185 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24186 result = (bool) ((arg1)->m_middleDown);
24187 {
24188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24189 }
24190 return resultobj;
24191 fail:
24192 return NULL;
24193 }
24194
24195
24196 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24197 PyObject *resultobj = 0;
24198 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24199 bool arg2 ;
24200 void *argp1 = 0 ;
24201 int res1 = 0 ;
24202 bool val2 ;
24203 int ecode2 = 0 ;
24204 PyObject *swig_obj[2] ;
24205
24206 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24208 if (!SWIG_IsOK(res1)) {
24209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24210 }
24211 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24212 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24213 if (!SWIG_IsOK(ecode2)) {
24214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24215 }
24216 arg2 = static_cast< bool >(val2);
24217 if (arg1) (arg1)->m_rightDown = arg2;
24218
24219 resultobj = SWIG_Py_Void();
24220 return resultobj;
24221 fail:
24222 return NULL;
24223 }
24224
24225
24226 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24227 PyObject *resultobj = 0;
24228 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24229 bool result;
24230 void *argp1 = 0 ;
24231 int res1 = 0 ;
24232 PyObject *swig_obj[1] ;
24233
24234 if (!args) SWIG_fail;
24235 swig_obj[0] = args;
24236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24237 if (!SWIG_IsOK(res1)) {
24238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24239 }
24240 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24241 result = (bool) ((arg1)->m_rightDown);
24242 {
24243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24244 }
24245 return resultobj;
24246 fail:
24247 return NULL;
24248 }
24249
24250
24251 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24252 PyObject *resultobj = 0;
24253 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24254 bool arg2 ;
24255 void *argp1 = 0 ;
24256 int res1 = 0 ;
24257 bool val2 ;
24258 int ecode2 = 0 ;
24259 PyObject *swig_obj[2] ;
24260
24261 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24263 if (!SWIG_IsOK(res1)) {
24264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24265 }
24266 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24267 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24268 if (!SWIG_IsOK(ecode2)) {
24269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24270 }
24271 arg2 = static_cast< bool >(val2);
24272 if (arg1) (arg1)->m_controlDown = arg2;
24273
24274 resultobj = SWIG_Py_Void();
24275 return resultobj;
24276 fail:
24277 return NULL;
24278 }
24279
24280
24281 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24282 PyObject *resultobj = 0;
24283 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24284 bool result;
24285 void *argp1 = 0 ;
24286 int res1 = 0 ;
24287 PyObject *swig_obj[1] ;
24288
24289 if (!args) SWIG_fail;
24290 swig_obj[0] = args;
24291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24292 if (!SWIG_IsOK(res1)) {
24293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24294 }
24295 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24296 result = (bool) ((arg1)->m_controlDown);
24297 {
24298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24299 }
24300 return resultobj;
24301 fail:
24302 return NULL;
24303 }
24304
24305
24306 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24307 PyObject *resultobj = 0;
24308 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24309 bool arg2 ;
24310 void *argp1 = 0 ;
24311 int res1 = 0 ;
24312 bool val2 ;
24313 int ecode2 = 0 ;
24314 PyObject *swig_obj[2] ;
24315
24316 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24318 if (!SWIG_IsOK(res1)) {
24319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24320 }
24321 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24322 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24323 if (!SWIG_IsOK(ecode2)) {
24324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24325 }
24326 arg2 = static_cast< bool >(val2);
24327 if (arg1) (arg1)->m_shiftDown = arg2;
24328
24329 resultobj = SWIG_Py_Void();
24330 return resultobj;
24331 fail:
24332 return NULL;
24333 }
24334
24335
24336 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24337 PyObject *resultobj = 0;
24338 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24339 bool result;
24340 void *argp1 = 0 ;
24341 int res1 = 0 ;
24342 PyObject *swig_obj[1] ;
24343
24344 if (!args) SWIG_fail;
24345 swig_obj[0] = args;
24346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24347 if (!SWIG_IsOK(res1)) {
24348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24349 }
24350 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24351 result = (bool) ((arg1)->m_shiftDown);
24352 {
24353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24354 }
24355 return resultobj;
24356 fail:
24357 return NULL;
24358 }
24359
24360
24361 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24362 PyObject *resultobj = 0;
24363 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24364 bool arg2 ;
24365 void *argp1 = 0 ;
24366 int res1 = 0 ;
24367 bool val2 ;
24368 int ecode2 = 0 ;
24369 PyObject *swig_obj[2] ;
24370
24371 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24373 if (!SWIG_IsOK(res1)) {
24374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24375 }
24376 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24377 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24378 if (!SWIG_IsOK(ecode2)) {
24379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24380 }
24381 arg2 = static_cast< bool >(val2);
24382 if (arg1) (arg1)->m_altDown = arg2;
24383
24384 resultobj = SWIG_Py_Void();
24385 return resultobj;
24386 fail:
24387 return NULL;
24388 }
24389
24390
24391 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24392 PyObject *resultobj = 0;
24393 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24394 bool result;
24395 void *argp1 = 0 ;
24396 int res1 = 0 ;
24397 PyObject *swig_obj[1] ;
24398
24399 if (!args) SWIG_fail;
24400 swig_obj[0] = args;
24401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24402 if (!SWIG_IsOK(res1)) {
24403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24404 }
24405 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24406 result = (bool) ((arg1)->m_altDown);
24407 {
24408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24409 }
24410 return resultobj;
24411 fail:
24412 return NULL;
24413 }
24414
24415
24416 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24417 PyObject *resultobj = 0;
24418 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24419 bool arg2 ;
24420 void *argp1 = 0 ;
24421 int res1 = 0 ;
24422 bool val2 ;
24423 int ecode2 = 0 ;
24424 PyObject *swig_obj[2] ;
24425
24426 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24428 if (!SWIG_IsOK(res1)) {
24429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24430 }
24431 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24432 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24433 if (!SWIG_IsOK(ecode2)) {
24434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24435 }
24436 arg2 = static_cast< bool >(val2);
24437 if (arg1) (arg1)->m_metaDown = arg2;
24438
24439 resultobj = SWIG_Py_Void();
24440 return resultobj;
24441 fail:
24442 return NULL;
24443 }
24444
24445
24446 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24447 PyObject *resultobj = 0;
24448 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24449 bool result;
24450 void *argp1 = 0 ;
24451 int res1 = 0 ;
24452 PyObject *swig_obj[1] ;
24453
24454 if (!args) SWIG_fail;
24455 swig_obj[0] = args;
24456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24457 if (!SWIG_IsOK(res1)) {
24458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24459 }
24460 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24461 result = (bool) ((arg1)->m_metaDown);
24462 {
24463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24464 }
24465 return resultobj;
24466 fail:
24467 return NULL;
24468 }
24469
24470
24471 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24472 PyObject *resultobj = 0;
24473 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24474 int arg2 ;
24475 void *argp1 = 0 ;
24476 int res1 = 0 ;
24477 int val2 ;
24478 int ecode2 = 0 ;
24479 PyObject *swig_obj[2] ;
24480
24481 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24483 if (!SWIG_IsOK(res1)) {
24484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24485 }
24486 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24487 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24488 if (!SWIG_IsOK(ecode2)) {
24489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24490 }
24491 arg2 = static_cast< int >(val2);
24492 if (arg1) (arg1)->m_wheelRotation = arg2;
24493
24494 resultobj = SWIG_Py_Void();
24495 return resultobj;
24496 fail:
24497 return NULL;
24498 }
24499
24500
24501 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24502 PyObject *resultobj = 0;
24503 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24504 int result;
24505 void *argp1 = 0 ;
24506 int res1 = 0 ;
24507 PyObject *swig_obj[1] ;
24508
24509 if (!args) SWIG_fail;
24510 swig_obj[0] = args;
24511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24512 if (!SWIG_IsOK(res1)) {
24513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24514 }
24515 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24516 result = (int) ((arg1)->m_wheelRotation);
24517 resultobj = SWIG_From_int(static_cast< int >(result));
24518 return resultobj;
24519 fail:
24520 return NULL;
24521 }
24522
24523
24524 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24525 PyObject *resultobj = 0;
24526 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24527 int arg2 ;
24528 void *argp1 = 0 ;
24529 int res1 = 0 ;
24530 int val2 ;
24531 int ecode2 = 0 ;
24532 PyObject *swig_obj[2] ;
24533
24534 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24536 if (!SWIG_IsOK(res1)) {
24537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24538 }
24539 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24540 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24541 if (!SWIG_IsOK(ecode2)) {
24542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24543 }
24544 arg2 = static_cast< int >(val2);
24545 if (arg1) (arg1)->m_wheelDelta = arg2;
24546
24547 resultobj = SWIG_Py_Void();
24548 return resultobj;
24549 fail:
24550 return NULL;
24551 }
24552
24553
24554 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24555 PyObject *resultobj = 0;
24556 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24557 int result;
24558 void *argp1 = 0 ;
24559 int res1 = 0 ;
24560 PyObject *swig_obj[1] ;
24561
24562 if (!args) SWIG_fail;
24563 swig_obj[0] = args;
24564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24565 if (!SWIG_IsOK(res1)) {
24566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24567 }
24568 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24569 result = (int) ((arg1)->m_wheelDelta);
24570 resultobj = SWIG_From_int(static_cast< int >(result));
24571 return resultobj;
24572 fail:
24573 return NULL;
24574 }
24575
24576
24577 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24578 PyObject *resultobj = 0;
24579 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24580 int arg2 ;
24581 void *argp1 = 0 ;
24582 int res1 = 0 ;
24583 int val2 ;
24584 int ecode2 = 0 ;
24585 PyObject *swig_obj[2] ;
24586
24587 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24589 if (!SWIG_IsOK(res1)) {
24590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24591 }
24592 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24593 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24594 if (!SWIG_IsOK(ecode2)) {
24595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24596 }
24597 arg2 = static_cast< int >(val2);
24598 if (arg1) (arg1)->m_linesPerAction = arg2;
24599
24600 resultobj = SWIG_Py_Void();
24601 return resultobj;
24602 fail:
24603 return NULL;
24604 }
24605
24606
24607 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24608 PyObject *resultobj = 0;
24609 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24610 int result;
24611 void *argp1 = 0 ;
24612 int res1 = 0 ;
24613 PyObject *swig_obj[1] ;
24614
24615 if (!args) SWIG_fail;
24616 swig_obj[0] = args;
24617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24618 if (!SWIG_IsOK(res1)) {
24619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24620 }
24621 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24622 result = (int) ((arg1)->m_linesPerAction);
24623 resultobj = SWIG_From_int(static_cast< int >(result));
24624 return resultobj;
24625 fail:
24626 return NULL;
24627 }
24628
24629
24630 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24631 PyObject *obj;
24632 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24633 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24634 return SWIG_Py_Void();
24635 }
24636
24637 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24638 return SWIG_Python_InitShadowInstance(args);
24639 }
24640
24641 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24642 PyObject *resultobj = 0;
24643 int arg1 = (int) 0 ;
24644 int arg2 = (int) 0 ;
24645 wxSetCursorEvent *result = 0 ;
24646 int val1 ;
24647 int ecode1 = 0 ;
24648 int val2 ;
24649 int ecode2 = 0 ;
24650 PyObject * obj0 = 0 ;
24651 PyObject * obj1 = 0 ;
24652 char * kwnames[] = {
24653 (char *) "x",(char *) "y", NULL
24654 };
24655
24656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24657 if (obj0) {
24658 ecode1 = SWIG_AsVal_int(obj0, &val1);
24659 if (!SWIG_IsOK(ecode1)) {
24660 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24661 }
24662 arg1 = static_cast< int >(val1);
24663 }
24664 if (obj1) {
24665 ecode2 = SWIG_AsVal_int(obj1, &val2);
24666 if (!SWIG_IsOK(ecode2)) {
24667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24668 }
24669 arg2 = static_cast< int >(val2);
24670 }
24671 {
24672 PyThreadState* __tstate = wxPyBeginAllowThreads();
24673 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24674 wxPyEndAllowThreads(__tstate);
24675 if (PyErr_Occurred()) SWIG_fail;
24676 }
24677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24678 return resultobj;
24679 fail:
24680 return NULL;
24681 }
24682
24683
24684 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24685 PyObject *resultobj = 0;
24686 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24687 int result;
24688 void *argp1 = 0 ;
24689 int res1 = 0 ;
24690 PyObject *swig_obj[1] ;
24691
24692 if (!args) SWIG_fail;
24693 swig_obj[0] = args;
24694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24695 if (!SWIG_IsOK(res1)) {
24696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24697 }
24698 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24699 {
24700 PyThreadState* __tstate = wxPyBeginAllowThreads();
24701 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24702 wxPyEndAllowThreads(__tstate);
24703 if (PyErr_Occurred()) SWIG_fail;
24704 }
24705 resultobj = SWIG_From_int(static_cast< int >(result));
24706 return resultobj;
24707 fail:
24708 return NULL;
24709 }
24710
24711
24712 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24713 PyObject *resultobj = 0;
24714 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24715 int result;
24716 void *argp1 = 0 ;
24717 int res1 = 0 ;
24718 PyObject *swig_obj[1] ;
24719
24720 if (!args) SWIG_fail;
24721 swig_obj[0] = args;
24722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24723 if (!SWIG_IsOK(res1)) {
24724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24725 }
24726 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24727 {
24728 PyThreadState* __tstate = wxPyBeginAllowThreads();
24729 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24730 wxPyEndAllowThreads(__tstate);
24731 if (PyErr_Occurred()) SWIG_fail;
24732 }
24733 resultobj = SWIG_From_int(static_cast< int >(result));
24734 return resultobj;
24735 fail:
24736 return NULL;
24737 }
24738
24739
24740 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24741 PyObject *resultobj = 0;
24742 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24743 wxCursor *arg2 = 0 ;
24744 void *argp1 = 0 ;
24745 int res1 = 0 ;
24746 void *argp2 = 0 ;
24747 int res2 = 0 ;
24748 PyObject * obj0 = 0 ;
24749 PyObject * obj1 = 0 ;
24750 char * kwnames[] = {
24751 (char *) "self",(char *) "cursor", NULL
24752 };
24753
24754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24756 if (!SWIG_IsOK(res1)) {
24757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24758 }
24759 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24760 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24761 if (!SWIG_IsOK(res2)) {
24762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24763 }
24764 if (!argp2) {
24765 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24766 }
24767 arg2 = reinterpret_cast< wxCursor * >(argp2);
24768 {
24769 PyThreadState* __tstate = wxPyBeginAllowThreads();
24770 (arg1)->SetCursor((wxCursor const &)*arg2);
24771 wxPyEndAllowThreads(__tstate);
24772 if (PyErr_Occurred()) SWIG_fail;
24773 }
24774 resultobj = SWIG_Py_Void();
24775 return resultobj;
24776 fail:
24777 return NULL;
24778 }
24779
24780
24781 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24782 PyObject *resultobj = 0;
24783 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24784 wxCursor *result = 0 ;
24785 void *argp1 = 0 ;
24786 int res1 = 0 ;
24787 PyObject *swig_obj[1] ;
24788
24789 if (!args) SWIG_fail;
24790 swig_obj[0] = args;
24791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24792 if (!SWIG_IsOK(res1)) {
24793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24794 }
24795 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24796 {
24797 PyThreadState* __tstate = wxPyBeginAllowThreads();
24798 {
24799 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24800 result = (wxCursor *) &_result_ref;
24801 }
24802 wxPyEndAllowThreads(__tstate);
24803 if (PyErr_Occurred()) SWIG_fail;
24804 }
24805 {
24806 wxCursor* resultptr = new wxCursor(*result);
24807 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24808 }
24809 return resultobj;
24810 fail:
24811 return NULL;
24812 }
24813
24814
24815 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24816 PyObject *resultobj = 0;
24817 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24818 bool result;
24819 void *argp1 = 0 ;
24820 int res1 = 0 ;
24821 PyObject *swig_obj[1] ;
24822
24823 if (!args) SWIG_fail;
24824 swig_obj[0] = args;
24825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24826 if (!SWIG_IsOK(res1)) {
24827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24828 }
24829 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24830 {
24831 PyThreadState* __tstate = wxPyBeginAllowThreads();
24832 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24833 wxPyEndAllowThreads(__tstate);
24834 if (PyErr_Occurred()) SWIG_fail;
24835 }
24836 {
24837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24838 }
24839 return resultobj;
24840 fail:
24841 return NULL;
24842 }
24843
24844
24845 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24846 PyObject *obj;
24847 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24848 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24849 return SWIG_Py_Void();
24850 }
24851
24852 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24853 return SWIG_Python_InitShadowInstance(args);
24854 }
24855
24856 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24857 PyObject *resultobj = 0;
24858 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24859 wxKeyEvent *result = 0 ;
24860 int val1 ;
24861 int ecode1 = 0 ;
24862 PyObject * obj0 = 0 ;
24863 char * kwnames[] = {
24864 (char *) "eventType", NULL
24865 };
24866
24867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24868 if (obj0) {
24869 ecode1 = SWIG_AsVal_int(obj0, &val1);
24870 if (!SWIG_IsOK(ecode1)) {
24871 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24872 }
24873 arg1 = static_cast< wxEventType >(val1);
24874 }
24875 {
24876 PyThreadState* __tstate = wxPyBeginAllowThreads();
24877 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24878 wxPyEndAllowThreads(__tstate);
24879 if (PyErr_Occurred()) SWIG_fail;
24880 }
24881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24882 return resultobj;
24883 fail:
24884 return NULL;
24885 }
24886
24887
24888 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24889 PyObject *resultobj = 0;
24890 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24891 int result;
24892 void *argp1 = 0 ;
24893 int res1 = 0 ;
24894 PyObject *swig_obj[1] ;
24895
24896 if (!args) SWIG_fail;
24897 swig_obj[0] = args;
24898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24899 if (!SWIG_IsOK(res1)) {
24900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24901 }
24902 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24903 {
24904 PyThreadState* __tstate = wxPyBeginAllowThreads();
24905 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24906 wxPyEndAllowThreads(__tstate);
24907 if (PyErr_Occurred()) SWIG_fail;
24908 }
24909 resultobj = SWIG_From_int(static_cast< int >(result));
24910 return resultobj;
24911 fail:
24912 return NULL;
24913 }
24914
24915
24916 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24917 PyObject *resultobj = 0;
24918 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24919 bool result;
24920 void *argp1 = 0 ;
24921 int res1 = 0 ;
24922 PyObject *swig_obj[1] ;
24923
24924 if (!args) SWIG_fail;
24925 swig_obj[0] = args;
24926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24927 if (!SWIG_IsOK(res1)) {
24928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24929 }
24930 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24931 {
24932 PyThreadState* __tstate = wxPyBeginAllowThreads();
24933 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
24934 wxPyEndAllowThreads(__tstate);
24935 if (PyErr_Occurred()) SWIG_fail;
24936 }
24937 {
24938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24939 }
24940 return resultobj;
24941 fail:
24942 return NULL;
24943 }
24944
24945
24946 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24947 PyObject *resultobj = 0;
24948 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24949 bool result;
24950 void *argp1 = 0 ;
24951 int res1 = 0 ;
24952 PyObject *swig_obj[1] ;
24953
24954 if (!args) SWIG_fail;
24955 swig_obj[0] = args;
24956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24957 if (!SWIG_IsOK(res1)) {
24958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24959 }
24960 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24961 {
24962 PyThreadState* __tstate = wxPyBeginAllowThreads();
24963 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
24964 wxPyEndAllowThreads(__tstate);
24965 if (PyErr_Occurred()) SWIG_fail;
24966 }
24967 {
24968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24969 }
24970 return resultobj;
24971 fail:
24972 return NULL;
24973 }
24974
24975
24976 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24977 PyObject *resultobj = 0;
24978 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24979 bool result;
24980 void *argp1 = 0 ;
24981 int res1 = 0 ;
24982 PyObject *swig_obj[1] ;
24983
24984 if (!args) SWIG_fail;
24985 swig_obj[0] = args;
24986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24987 if (!SWIG_IsOK(res1)) {
24988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24989 }
24990 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24991 {
24992 PyThreadState* __tstate = wxPyBeginAllowThreads();
24993 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
24994 wxPyEndAllowThreads(__tstate);
24995 if (PyErr_Occurred()) SWIG_fail;
24996 }
24997 {
24998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24999 }
25000 return resultobj;
25001 fail:
25002 return NULL;
25003 }
25004
25005
25006 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25007 PyObject *resultobj = 0;
25008 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25009 bool result;
25010 void *argp1 = 0 ;
25011 int res1 = 0 ;
25012 PyObject *swig_obj[1] ;
25013
25014 if (!args) SWIG_fail;
25015 swig_obj[0] = args;
25016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25017 if (!SWIG_IsOK(res1)) {
25018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25019 }
25020 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25021 {
25022 PyThreadState* __tstate = wxPyBeginAllowThreads();
25023 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
25024 wxPyEndAllowThreads(__tstate);
25025 if (PyErr_Occurred()) SWIG_fail;
25026 }
25027 {
25028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25029 }
25030 return resultobj;
25031 fail:
25032 return NULL;
25033 }
25034
25035
25036 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25037 PyObject *resultobj = 0;
25038 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25039 bool result;
25040 void *argp1 = 0 ;
25041 int res1 = 0 ;
25042 PyObject *swig_obj[1] ;
25043
25044 if (!args) SWIG_fail;
25045 swig_obj[0] = args;
25046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25047 if (!SWIG_IsOK(res1)) {
25048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25049 }
25050 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25051 {
25052 PyThreadState* __tstate = wxPyBeginAllowThreads();
25053 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25054 wxPyEndAllowThreads(__tstate);
25055 if (PyErr_Occurred()) SWIG_fail;
25056 }
25057 {
25058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25059 }
25060 return resultobj;
25061 fail:
25062 return NULL;
25063 }
25064
25065
25066 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25067 PyObject *resultobj = 0;
25068 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25069 bool result;
25070 void *argp1 = 0 ;
25071 int res1 = 0 ;
25072 PyObject *swig_obj[1] ;
25073
25074 if (!args) SWIG_fail;
25075 swig_obj[0] = args;
25076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25077 if (!SWIG_IsOK(res1)) {
25078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25079 }
25080 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25081 {
25082 PyThreadState* __tstate = wxPyBeginAllowThreads();
25083 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25084 wxPyEndAllowThreads(__tstate);
25085 if (PyErr_Occurred()) SWIG_fail;
25086 }
25087 {
25088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25089 }
25090 return resultobj;
25091 fail:
25092 return NULL;
25093 }
25094
25095
25096 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25097 PyObject *resultobj = 0;
25098 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25099 int result;
25100 void *argp1 = 0 ;
25101 int res1 = 0 ;
25102 PyObject *swig_obj[1] ;
25103
25104 if (!args) SWIG_fail;
25105 swig_obj[0] = args;
25106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25107 if (!SWIG_IsOK(res1)) {
25108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25109 }
25110 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25111 {
25112 PyThreadState* __tstate = wxPyBeginAllowThreads();
25113 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25114 wxPyEndAllowThreads(__tstate);
25115 if (PyErr_Occurred()) SWIG_fail;
25116 }
25117 resultobj = SWIG_From_int(static_cast< int >(result));
25118 return resultobj;
25119 fail:
25120 return NULL;
25121 }
25122
25123
25124 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25125 PyObject *resultobj = 0;
25126 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25127 int result;
25128 void *argp1 = 0 ;
25129 int res1 = 0 ;
25130 PyObject *swig_obj[1] ;
25131
25132 if (!args) SWIG_fail;
25133 swig_obj[0] = args;
25134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25135 if (!SWIG_IsOK(res1)) {
25136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25137 }
25138 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25139 {
25140 PyThreadState* __tstate = wxPyBeginAllowThreads();
25141 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25142 wxPyEndAllowThreads(__tstate);
25143 if (PyErr_Occurred()) SWIG_fail;
25144 }
25145 resultobj = SWIG_From_int(static_cast< int >(result));
25146 return resultobj;
25147 fail:
25148 return NULL;
25149 }
25150
25151
25152 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25153 PyObject *resultobj = 0;
25154 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25155 int arg2 ;
25156 void *argp1 = 0 ;
25157 int res1 = 0 ;
25158 int val2 ;
25159 int ecode2 = 0 ;
25160 PyObject * obj0 = 0 ;
25161 PyObject * obj1 = 0 ;
25162 char * kwnames[] = {
25163 (char *) "self",(char *) "uniChar", NULL
25164 };
25165
25166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25168 if (!SWIG_IsOK(res1)) {
25169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25170 }
25171 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25172 ecode2 = SWIG_AsVal_int(obj1, &val2);
25173 if (!SWIG_IsOK(ecode2)) {
25174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25175 }
25176 arg2 = static_cast< int >(val2);
25177 {
25178 PyThreadState* __tstate = wxPyBeginAllowThreads();
25179 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25180 wxPyEndAllowThreads(__tstate);
25181 if (PyErr_Occurred()) SWIG_fail;
25182 }
25183 resultobj = SWIG_Py_Void();
25184 return resultobj;
25185 fail:
25186 return NULL;
25187 }
25188
25189
25190 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25191 PyObject *resultobj = 0;
25192 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25193 unsigned int result;
25194 void *argp1 = 0 ;
25195 int res1 = 0 ;
25196 PyObject *swig_obj[1] ;
25197
25198 if (!args) SWIG_fail;
25199 swig_obj[0] = args;
25200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25201 if (!SWIG_IsOK(res1)) {
25202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25203 }
25204 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25205 {
25206 PyThreadState* __tstate = wxPyBeginAllowThreads();
25207 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25208 wxPyEndAllowThreads(__tstate);
25209 if (PyErr_Occurred()) SWIG_fail;
25210 }
25211 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25212 return resultobj;
25213 fail:
25214 return NULL;
25215 }
25216
25217
25218 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25219 PyObject *resultobj = 0;
25220 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25221 unsigned int result;
25222 void *argp1 = 0 ;
25223 int res1 = 0 ;
25224 PyObject *swig_obj[1] ;
25225
25226 if (!args) SWIG_fail;
25227 swig_obj[0] = args;
25228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25229 if (!SWIG_IsOK(res1)) {
25230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25231 }
25232 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25233 {
25234 PyThreadState* __tstate = wxPyBeginAllowThreads();
25235 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25236 wxPyEndAllowThreads(__tstate);
25237 if (PyErr_Occurred()) SWIG_fail;
25238 }
25239 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25240 return resultobj;
25241 fail:
25242 return NULL;
25243 }
25244
25245
25246 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25247 PyObject *resultobj = 0;
25248 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25249 wxPoint result;
25250 void *argp1 = 0 ;
25251 int res1 = 0 ;
25252 PyObject *swig_obj[1] ;
25253
25254 if (!args) SWIG_fail;
25255 swig_obj[0] = args;
25256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25257 if (!SWIG_IsOK(res1)) {
25258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25259 }
25260 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25261 {
25262 PyThreadState* __tstate = wxPyBeginAllowThreads();
25263 result = (arg1)->GetPosition();
25264 wxPyEndAllowThreads(__tstate);
25265 if (PyErr_Occurred()) SWIG_fail;
25266 }
25267 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25268 return resultobj;
25269 fail:
25270 return NULL;
25271 }
25272
25273
25274 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25275 PyObject *resultobj = 0;
25276 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25277 long *arg2 = (long *) 0 ;
25278 long *arg3 = (long *) 0 ;
25279 void *argp1 = 0 ;
25280 int res1 = 0 ;
25281 long temp2 ;
25282 int res2 = SWIG_TMPOBJ ;
25283 long temp3 ;
25284 int res3 = SWIG_TMPOBJ ;
25285 PyObject *swig_obj[1] ;
25286
25287 arg2 = &temp2;
25288 arg3 = &temp3;
25289 if (!args) SWIG_fail;
25290 swig_obj[0] = args;
25291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25292 if (!SWIG_IsOK(res1)) {
25293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25294 }
25295 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25296 {
25297 PyThreadState* __tstate = wxPyBeginAllowThreads();
25298 (arg1)->GetPosition(arg2,arg3);
25299 wxPyEndAllowThreads(__tstate);
25300 if (PyErr_Occurred()) SWIG_fail;
25301 }
25302 resultobj = SWIG_Py_Void();
25303 if (SWIG_IsTmpObj(res2)) {
25304 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25305 } else {
25306 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25307 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25308 }
25309 if (SWIG_IsTmpObj(res3)) {
25310 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25311 } else {
25312 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25313 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25314 }
25315 return resultobj;
25316 fail:
25317 return NULL;
25318 }
25319
25320
25321 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25322 PyObject *resultobj = 0;
25323 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25324 int result;
25325 void *argp1 = 0 ;
25326 int res1 = 0 ;
25327 PyObject *swig_obj[1] ;
25328
25329 if (!args) SWIG_fail;
25330 swig_obj[0] = args;
25331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25332 if (!SWIG_IsOK(res1)) {
25333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25334 }
25335 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25336 {
25337 PyThreadState* __tstate = wxPyBeginAllowThreads();
25338 result = (int)((wxKeyEvent const *)arg1)->GetX();
25339 wxPyEndAllowThreads(__tstate);
25340 if (PyErr_Occurred()) SWIG_fail;
25341 }
25342 resultobj = SWIG_From_int(static_cast< int >(result));
25343 return resultobj;
25344 fail:
25345 return NULL;
25346 }
25347
25348
25349 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25350 PyObject *resultobj = 0;
25351 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25352 int result;
25353 void *argp1 = 0 ;
25354 int res1 = 0 ;
25355 PyObject *swig_obj[1] ;
25356
25357 if (!args) SWIG_fail;
25358 swig_obj[0] = args;
25359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25360 if (!SWIG_IsOK(res1)) {
25361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25362 }
25363 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25364 {
25365 PyThreadState* __tstate = wxPyBeginAllowThreads();
25366 result = (int)((wxKeyEvent const *)arg1)->GetY();
25367 wxPyEndAllowThreads(__tstate);
25368 if (PyErr_Occurred()) SWIG_fail;
25369 }
25370 resultobj = SWIG_From_int(static_cast< int >(result));
25371 return resultobj;
25372 fail:
25373 return NULL;
25374 }
25375
25376
25377 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25378 PyObject *resultobj = 0;
25379 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25380 int arg2 ;
25381 void *argp1 = 0 ;
25382 int res1 = 0 ;
25383 int val2 ;
25384 int ecode2 = 0 ;
25385 PyObject *swig_obj[2] ;
25386
25387 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25389 if (!SWIG_IsOK(res1)) {
25390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25391 }
25392 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25393 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25394 if (!SWIG_IsOK(ecode2)) {
25395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25396 }
25397 arg2 = static_cast< int >(val2);
25398 if (arg1) (arg1)->m_x = arg2;
25399
25400 resultobj = SWIG_Py_Void();
25401 return resultobj;
25402 fail:
25403 return NULL;
25404 }
25405
25406
25407 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25408 PyObject *resultobj = 0;
25409 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25410 int result;
25411 void *argp1 = 0 ;
25412 int res1 = 0 ;
25413 PyObject *swig_obj[1] ;
25414
25415 if (!args) SWIG_fail;
25416 swig_obj[0] = args;
25417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25418 if (!SWIG_IsOK(res1)) {
25419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25420 }
25421 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25422 result = (int) ((arg1)->m_x);
25423 resultobj = SWIG_From_int(static_cast< int >(result));
25424 return resultobj;
25425 fail:
25426 return NULL;
25427 }
25428
25429
25430 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25431 PyObject *resultobj = 0;
25432 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25433 int arg2 ;
25434 void *argp1 = 0 ;
25435 int res1 = 0 ;
25436 int val2 ;
25437 int ecode2 = 0 ;
25438 PyObject *swig_obj[2] ;
25439
25440 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25442 if (!SWIG_IsOK(res1)) {
25443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25444 }
25445 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25446 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25447 if (!SWIG_IsOK(ecode2)) {
25448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25449 }
25450 arg2 = static_cast< int >(val2);
25451 if (arg1) (arg1)->m_y = arg2;
25452
25453 resultobj = SWIG_Py_Void();
25454 return resultobj;
25455 fail:
25456 return NULL;
25457 }
25458
25459
25460 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25461 PyObject *resultobj = 0;
25462 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25463 int result;
25464 void *argp1 = 0 ;
25465 int res1 = 0 ;
25466 PyObject *swig_obj[1] ;
25467
25468 if (!args) SWIG_fail;
25469 swig_obj[0] = args;
25470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25471 if (!SWIG_IsOK(res1)) {
25472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25473 }
25474 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25475 result = (int) ((arg1)->m_y);
25476 resultobj = SWIG_From_int(static_cast< int >(result));
25477 return resultobj;
25478 fail:
25479 return NULL;
25480 }
25481
25482
25483 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25484 PyObject *resultobj = 0;
25485 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25486 long arg2 ;
25487 void *argp1 = 0 ;
25488 int res1 = 0 ;
25489 long val2 ;
25490 int ecode2 = 0 ;
25491 PyObject *swig_obj[2] ;
25492
25493 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25495 if (!SWIG_IsOK(res1)) {
25496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25497 }
25498 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25499 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25500 if (!SWIG_IsOK(ecode2)) {
25501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25502 }
25503 arg2 = static_cast< long >(val2);
25504 if (arg1) (arg1)->m_keyCode = arg2;
25505
25506 resultobj = SWIG_Py_Void();
25507 return resultobj;
25508 fail:
25509 return NULL;
25510 }
25511
25512
25513 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25514 PyObject *resultobj = 0;
25515 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25516 long result;
25517 void *argp1 = 0 ;
25518 int res1 = 0 ;
25519 PyObject *swig_obj[1] ;
25520
25521 if (!args) SWIG_fail;
25522 swig_obj[0] = args;
25523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25524 if (!SWIG_IsOK(res1)) {
25525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25526 }
25527 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25528 result = (long) ((arg1)->m_keyCode);
25529 resultobj = SWIG_From_long(static_cast< long >(result));
25530 return resultobj;
25531 fail:
25532 return NULL;
25533 }
25534
25535
25536 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25537 PyObject *resultobj = 0;
25538 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25539 bool arg2 ;
25540 void *argp1 = 0 ;
25541 int res1 = 0 ;
25542 bool val2 ;
25543 int ecode2 = 0 ;
25544 PyObject *swig_obj[2] ;
25545
25546 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25548 if (!SWIG_IsOK(res1)) {
25549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25550 }
25551 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25552 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25553 if (!SWIG_IsOK(ecode2)) {
25554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25555 }
25556 arg2 = static_cast< bool >(val2);
25557 if (arg1) (arg1)->m_controlDown = arg2;
25558
25559 resultobj = SWIG_Py_Void();
25560 return resultobj;
25561 fail:
25562 return NULL;
25563 }
25564
25565
25566 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25567 PyObject *resultobj = 0;
25568 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25569 bool result;
25570 void *argp1 = 0 ;
25571 int res1 = 0 ;
25572 PyObject *swig_obj[1] ;
25573
25574 if (!args) SWIG_fail;
25575 swig_obj[0] = args;
25576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25577 if (!SWIG_IsOK(res1)) {
25578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25579 }
25580 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25581 result = (bool) ((arg1)->m_controlDown);
25582 {
25583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25584 }
25585 return resultobj;
25586 fail:
25587 return NULL;
25588 }
25589
25590
25591 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25592 PyObject *resultobj = 0;
25593 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25594 bool arg2 ;
25595 void *argp1 = 0 ;
25596 int res1 = 0 ;
25597 bool val2 ;
25598 int ecode2 = 0 ;
25599 PyObject *swig_obj[2] ;
25600
25601 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25603 if (!SWIG_IsOK(res1)) {
25604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25605 }
25606 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25607 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25608 if (!SWIG_IsOK(ecode2)) {
25609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25610 }
25611 arg2 = static_cast< bool >(val2);
25612 if (arg1) (arg1)->m_shiftDown = arg2;
25613
25614 resultobj = SWIG_Py_Void();
25615 return resultobj;
25616 fail:
25617 return NULL;
25618 }
25619
25620
25621 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25622 PyObject *resultobj = 0;
25623 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25624 bool result;
25625 void *argp1 = 0 ;
25626 int res1 = 0 ;
25627 PyObject *swig_obj[1] ;
25628
25629 if (!args) SWIG_fail;
25630 swig_obj[0] = args;
25631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25632 if (!SWIG_IsOK(res1)) {
25633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25634 }
25635 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25636 result = (bool) ((arg1)->m_shiftDown);
25637 {
25638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25639 }
25640 return resultobj;
25641 fail:
25642 return NULL;
25643 }
25644
25645
25646 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25647 PyObject *resultobj = 0;
25648 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25649 bool arg2 ;
25650 void *argp1 = 0 ;
25651 int res1 = 0 ;
25652 bool val2 ;
25653 int ecode2 = 0 ;
25654 PyObject *swig_obj[2] ;
25655
25656 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25658 if (!SWIG_IsOK(res1)) {
25659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25660 }
25661 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25662 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25663 if (!SWIG_IsOK(ecode2)) {
25664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25665 }
25666 arg2 = static_cast< bool >(val2);
25667 if (arg1) (arg1)->m_altDown = arg2;
25668
25669 resultobj = SWIG_Py_Void();
25670 return resultobj;
25671 fail:
25672 return NULL;
25673 }
25674
25675
25676 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25677 PyObject *resultobj = 0;
25678 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25679 bool result;
25680 void *argp1 = 0 ;
25681 int res1 = 0 ;
25682 PyObject *swig_obj[1] ;
25683
25684 if (!args) SWIG_fail;
25685 swig_obj[0] = args;
25686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25687 if (!SWIG_IsOK(res1)) {
25688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25689 }
25690 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25691 result = (bool) ((arg1)->m_altDown);
25692 {
25693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25694 }
25695 return resultobj;
25696 fail:
25697 return NULL;
25698 }
25699
25700
25701 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25702 PyObject *resultobj = 0;
25703 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25704 bool arg2 ;
25705 void *argp1 = 0 ;
25706 int res1 = 0 ;
25707 bool val2 ;
25708 int ecode2 = 0 ;
25709 PyObject *swig_obj[2] ;
25710
25711 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25713 if (!SWIG_IsOK(res1)) {
25714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25715 }
25716 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25717 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25718 if (!SWIG_IsOK(ecode2)) {
25719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25720 }
25721 arg2 = static_cast< bool >(val2);
25722 if (arg1) (arg1)->m_metaDown = arg2;
25723
25724 resultobj = SWIG_Py_Void();
25725 return resultobj;
25726 fail:
25727 return NULL;
25728 }
25729
25730
25731 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25732 PyObject *resultobj = 0;
25733 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25734 bool result;
25735 void *argp1 = 0 ;
25736 int res1 = 0 ;
25737 PyObject *swig_obj[1] ;
25738
25739 if (!args) SWIG_fail;
25740 swig_obj[0] = args;
25741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25742 if (!SWIG_IsOK(res1)) {
25743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25744 }
25745 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25746 result = (bool) ((arg1)->m_metaDown);
25747 {
25748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25749 }
25750 return resultobj;
25751 fail:
25752 return NULL;
25753 }
25754
25755
25756 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25757 PyObject *resultobj = 0;
25758 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25759 bool arg2 ;
25760 void *argp1 = 0 ;
25761 int res1 = 0 ;
25762 bool val2 ;
25763 int ecode2 = 0 ;
25764 PyObject *swig_obj[2] ;
25765
25766 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25768 if (!SWIG_IsOK(res1)) {
25769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25770 }
25771 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25772 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25773 if (!SWIG_IsOK(ecode2)) {
25774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25775 }
25776 arg2 = static_cast< bool >(val2);
25777 if (arg1) (arg1)->m_scanCode = arg2;
25778
25779 resultobj = SWIG_Py_Void();
25780 return resultobj;
25781 fail:
25782 return NULL;
25783 }
25784
25785
25786 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25787 PyObject *resultobj = 0;
25788 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25789 bool result;
25790 void *argp1 = 0 ;
25791 int res1 = 0 ;
25792 PyObject *swig_obj[1] ;
25793
25794 if (!args) SWIG_fail;
25795 swig_obj[0] = args;
25796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25797 if (!SWIG_IsOK(res1)) {
25798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25799 }
25800 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25801 result = (bool) ((arg1)->m_scanCode);
25802 {
25803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25804 }
25805 return resultobj;
25806 fail:
25807 return NULL;
25808 }
25809
25810
25811 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25812 PyObject *resultobj = 0;
25813 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25814 unsigned int arg2 ;
25815 void *argp1 = 0 ;
25816 int res1 = 0 ;
25817 unsigned int val2 ;
25818 int ecode2 = 0 ;
25819 PyObject *swig_obj[2] ;
25820
25821 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25823 if (!SWIG_IsOK(res1)) {
25824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25825 }
25826 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25827 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25828 if (!SWIG_IsOK(ecode2)) {
25829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25830 }
25831 arg2 = static_cast< unsigned int >(val2);
25832 if (arg1) (arg1)->m_rawCode = arg2;
25833
25834 resultobj = SWIG_Py_Void();
25835 return resultobj;
25836 fail:
25837 return NULL;
25838 }
25839
25840
25841 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25842 PyObject *resultobj = 0;
25843 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25844 unsigned int result;
25845 void *argp1 = 0 ;
25846 int res1 = 0 ;
25847 PyObject *swig_obj[1] ;
25848
25849 if (!args) SWIG_fail;
25850 swig_obj[0] = args;
25851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25852 if (!SWIG_IsOK(res1)) {
25853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25854 }
25855 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25856 result = (unsigned int) ((arg1)->m_rawCode);
25857 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25858 return resultobj;
25859 fail:
25860 return NULL;
25861 }
25862
25863
25864 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25865 PyObject *resultobj = 0;
25866 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25867 unsigned int arg2 ;
25868 void *argp1 = 0 ;
25869 int res1 = 0 ;
25870 unsigned int val2 ;
25871 int ecode2 = 0 ;
25872 PyObject *swig_obj[2] ;
25873
25874 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25876 if (!SWIG_IsOK(res1)) {
25877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25878 }
25879 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25880 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25881 if (!SWIG_IsOK(ecode2)) {
25882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25883 }
25884 arg2 = static_cast< unsigned int >(val2);
25885 if (arg1) (arg1)->m_rawFlags = arg2;
25886
25887 resultobj = SWIG_Py_Void();
25888 return resultobj;
25889 fail:
25890 return NULL;
25891 }
25892
25893
25894 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25895 PyObject *resultobj = 0;
25896 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25897 unsigned int result;
25898 void *argp1 = 0 ;
25899 int res1 = 0 ;
25900 PyObject *swig_obj[1] ;
25901
25902 if (!args) SWIG_fail;
25903 swig_obj[0] = args;
25904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25905 if (!SWIG_IsOK(res1)) {
25906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25907 }
25908 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25909 result = (unsigned int) ((arg1)->m_rawFlags);
25910 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25911 return resultobj;
25912 fail:
25913 return NULL;
25914 }
25915
25916
25917 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25918 PyObject *obj;
25919 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25920 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25921 return SWIG_Py_Void();
25922 }
25923
25924 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25925 return SWIG_Python_InitShadowInstance(args);
25926 }
25927
25928 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25929 PyObject *resultobj = 0;
25930 wxSize const &arg1_defvalue = wxDefaultSize ;
25931 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
25932 int arg2 = (int) 0 ;
25933 wxSizeEvent *result = 0 ;
25934 wxSize temp1 ;
25935 int val2 ;
25936 int ecode2 = 0 ;
25937 PyObject * obj0 = 0 ;
25938 PyObject * obj1 = 0 ;
25939 char * kwnames[] = {
25940 (char *) "sz",(char *) "winid", NULL
25941 };
25942
25943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25944 if (obj0) {
25945 {
25946 arg1 = &temp1;
25947 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
25948 }
25949 }
25950 if (obj1) {
25951 ecode2 = SWIG_AsVal_int(obj1, &val2);
25952 if (!SWIG_IsOK(ecode2)) {
25953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
25954 }
25955 arg2 = static_cast< int >(val2);
25956 }
25957 {
25958 PyThreadState* __tstate = wxPyBeginAllowThreads();
25959 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
25960 wxPyEndAllowThreads(__tstate);
25961 if (PyErr_Occurred()) SWIG_fail;
25962 }
25963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
25964 return resultobj;
25965 fail:
25966 return NULL;
25967 }
25968
25969
25970 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25971 PyObject *resultobj = 0;
25972 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25973 wxSize result;
25974 void *argp1 = 0 ;
25975 int res1 = 0 ;
25976 PyObject *swig_obj[1] ;
25977
25978 if (!args) SWIG_fail;
25979 swig_obj[0] = args;
25980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
25981 if (!SWIG_IsOK(res1)) {
25982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25983 }
25984 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25985 {
25986 PyThreadState* __tstate = wxPyBeginAllowThreads();
25987 result = ((wxSizeEvent const *)arg1)->GetSize();
25988 wxPyEndAllowThreads(__tstate);
25989 if (PyErr_Occurred()) SWIG_fail;
25990 }
25991 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
25992 return resultobj;
25993 fail:
25994 return NULL;
25995 }
25996
25997
25998 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25999 PyObject *resultobj = 0;
26000 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26001 wxRect result;
26002 void *argp1 = 0 ;
26003 int res1 = 0 ;
26004 PyObject *swig_obj[1] ;
26005
26006 if (!args) SWIG_fail;
26007 swig_obj[0] = args;
26008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26009 if (!SWIG_IsOK(res1)) {
26010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26011 }
26012 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26013 {
26014 PyThreadState* __tstate = wxPyBeginAllowThreads();
26015 result = ((wxSizeEvent const *)arg1)->GetRect();
26016 wxPyEndAllowThreads(__tstate);
26017 if (PyErr_Occurred()) SWIG_fail;
26018 }
26019 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26020 return resultobj;
26021 fail:
26022 return NULL;
26023 }
26024
26025
26026 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26027 PyObject *resultobj = 0;
26028 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26029 wxRect arg2 ;
26030 void *argp1 = 0 ;
26031 int res1 = 0 ;
26032 void *argp2 ;
26033 int res2 = 0 ;
26034 PyObject * obj0 = 0 ;
26035 PyObject * obj1 = 0 ;
26036 char * kwnames[] = {
26037 (char *) "self",(char *) "rect", NULL
26038 };
26039
26040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26042 if (!SWIG_IsOK(res1)) {
26043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26044 }
26045 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26046 {
26047 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26048 if (!SWIG_IsOK(res2)) {
26049 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26050 }
26051 if (!argp2) {
26052 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26053 } else {
26054 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26055 arg2 = *temp;
26056 if (SWIG_IsNewObj(res2)) delete temp;
26057 }
26058 }
26059 {
26060 PyThreadState* __tstate = wxPyBeginAllowThreads();
26061 (arg1)->SetRect(arg2);
26062 wxPyEndAllowThreads(__tstate);
26063 if (PyErr_Occurred()) SWIG_fail;
26064 }
26065 resultobj = SWIG_Py_Void();
26066 return resultobj;
26067 fail:
26068 return NULL;
26069 }
26070
26071
26072 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26073 PyObject *resultobj = 0;
26074 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26075 wxSize arg2 ;
26076 void *argp1 = 0 ;
26077 int res1 = 0 ;
26078 void *argp2 ;
26079 int res2 = 0 ;
26080 PyObject * obj0 = 0 ;
26081 PyObject * obj1 = 0 ;
26082 char * kwnames[] = {
26083 (char *) "self",(char *) "size", NULL
26084 };
26085
26086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26088 if (!SWIG_IsOK(res1)) {
26089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26090 }
26091 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26092 {
26093 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26094 if (!SWIG_IsOK(res2)) {
26095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26096 }
26097 if (!argp2) {
26098 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26099 } else {
26100 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26101 arg2 = *temp;
26102 if (SWIG_IsNewObj(res2)) delete temp;
26103 }
26104 }
26105 {
26106 PyThreadState* __tstate = wxPyBeginAllowThreads();
26107 wxSizeEvent_SetSize(arg1,arg2);
26108 wxPyEndAllowThreads(__tstate);
26109 if (PyErr_Occurred()) SWIG_fail;
26110 }
26111 resultobj = SWIG_Py_Void();
26112 return resultobj;
26113 fail:
26114 return NULL;
26115 }
26116
26117
26118 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26119 PyObject *resultobj = 0;
26120 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26121 wxSize *arg2 = (wxSize *) 0 ;
26122 void *argp1 = 0 ;
26123 int res1 = 0 ;
26124 void *argp2 = 0 ;
26125 int res2 = 0 ;
26126 PyObject *swig_obj[2] ;
26127
26128 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26130 if (!SWIG_IsOK(res1)) {
26131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26132 }
26133 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26134 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26135 if (!SWIG_IsOK(res2)) {
26136 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26137 }
26138 arg2 = reinterpret_cast< wxSize * >(argp2);
26139 if (arg1) (arg1)->m_size = *arg2;
26140
26141 resultobj = SWIG_Py_Void();
26142 return resultobj;
26143 fail:
26144 return NULL;
26145 }
26146
26147
26148 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26149 PyObject *resultobj = 0;
26150 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26151 wxSize *result = 0 ;
26152 void *argp1 = 0 ;
26153 int res1 = 0 ;
26154 PyObject *swig_obj[1] ;
26155
26156 if (!args) SWIG_fail;
26157 swig_obj[0] = args;
26158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26159 if (!SWIG_IsOK(res1)) {
26160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26161 }
26162 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26163 result = (wxSize *)& ((arg1)->m_size);
26164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26165 return resultobj;
26166 fail:
26167 return NULL;
26168 }
26169
26170
26171 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26172 PyObject *resultobj = 0;
26173 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26174 wxRect *arg2 = (wxRect *) 0 ;
26175 void *argp1 = 0 ;
26176 int res1 = 0 ;
26177 void *argp2 = 0 ;
26178 int res2 = 0 ;
26179 PyObject *swig_obj[2] ;
26180
26181 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26183 if (!SWIG_IsOK(res1)) {
26184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26185 }
26186 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26187 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26188 if (!SWIG_IsOK(res2)) {
26189 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26190 }
26191 arg2 = reinterpret_cast< wxRect * >(argp2);
26192 if (arg1) (arg1)->m_rect = *arg2;
26193
26194 resultobj = SWIG_Py_Void();
26195 return resultobj;
26196 fail:
26197 return NULL;
26198 }
26199
26200
26201 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26202 PyObject *resultobj = 0;
26203 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26204 wxRect *result = 0 ;
26205 void *argp1 = 0 ;
26206 int res1 = 0 ;
26207 PyObject *swig_obj[1] ;
26208
26209 if (!args) SWIG_fail;
26210 swig_obj[0] = args;
26211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26212 if (!SWIG_IsOK(res1)) {
26213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26214 }
26215 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26216 result = (wxRect *)& ((arg1)->m_rect);
26217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26218 return resultobj;
26219 fail:
26220 return NULL;
26221 }
26222
26223
26224 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26225 PyObject *obj;
26226 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26227 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26228 return SWIG_Py_Void();
26229 }
26230
26231 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26232 return SWIG_Python_InitShadowInstance(args);
26233 }
26234
26235 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26236 PyObject *resultobj = 0;
26237 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26238 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26239 int arg2 = (int) 0 ;
26240 wxMoveEvent *result = 0 ;
26241 wxPoint temp1 ;
26242 int val2 ;
26243 int ecode2 = 0 ;
26244 PyObject * obj0 = 0 ;
26245 PyObject * obj1 = 0 ;
26246 char * kwnames[] = {
26247 (char *) "pos",(char *) "winid", NULL
26248 };
26249
26250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26251 if (obj0) {
26252 {
26253 arg1 = &temp1;
26254 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26255 }
26256 }
26257 if (obj1) {
26258 ecode2 = SWIG_AsVal_int(obj1, &val2);
26259 if (!SWIG_IsOK(ecode2)) {
26260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26261 }
26262 arg2 = static_cast< int >(val2);
26263 }
26264 {
26265 PyThreadState* __tstate = wxPyBeginAllowThreads();
26266 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26267 wxPyEndAllowThreads(__tstate);
26268 if (PyErr_Occurred()) SWIG_fail;
26269 }
26270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26271 return resultobj;
26272 fail:
26273 return NULL;
26274 }
26275
26276
26277 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26278 PyObject *resultobj = 0;
26279 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26280 wxPoint result;
26281 void *argp1 = 0 ;
26282 int res1 = 0 ;
26283 PyObject *swig_obj[1] ;
26284
26285 if (!args) SWIG_fail;
26286 swig_obj[0] = args;
26287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26288 if (!SWIG_IsOK(res1)) {
26289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26290 }
26291 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26292 {
26293 PyThreadState* __tstate = wxPyBeginAllowThreads();
26294 result = ((wxMoveEvent const *)arg1)->GetPosition();
26295 wxPyEndAllowThreads(__tstate);
26296 if (PyErr_Occurred()) SWIG_fail;
26297 }
26298 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26299 return resultobj;
26300 fail:
26301 return NULL;
26302 }
26303
26304
26305 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26306 PyObject *resultobj = 0;
26307 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26308 wxRect result;
26309 void *argp1 = 0 ;
26310 int res1 = 0 ;
26311 PyObject *swig_obj[1] ;
26312
26313 if (!args) SWIG_fail;
26314 swig_obj[0] = args;
26315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26316 if (!SWIG_IsOK(res1)) {
26317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26318 }
26319 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26320 {
26321 PyThreadState* __tstate = wxPyBeginAllowThreads();
26322 result = ((wxMoveEvent const *)arg1)->GetRect();
26323 wxPyEndAllowThreads(__tstate);
26324 if (PyErr_Occurred()) SWIG_fail;
26325 }
26326 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26327 return resultobj;
26328 fail:
26329 return NULL;
26330 }
26331
26332
26333 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26334 PyObject *resultobj = 0;
26335 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26336 wxRect *arg2 = 0 ;
26337 void *argp1 = 0 ;
26338 int res1 = 0 ;
26339 wxRect temp2 ;
26340 PyObject * obj0 = 0 ;
26341 PyObject * obj1 = 0 ;
26342 char * kwnames[] = {
26343 (char *) "self",(char *) "rect", NULL
26344 };
26345
26346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26348 if (!SWIG_IsOK(res1)) {
26349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26350 }
26351 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26352 {
26353 arg2 = &temp2;
26354 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26355 }
26356 {
26357 PyThreadState* __tstate = wxPyBeginAllowThreads();
26358 (arg1)->SetRect((wxRect const &)*arg2);
26359 wxPyEndAllowThreads(__tstate);
26360 if (PyErr_Occurred()) SWIG_fail;
26361 }
26362 resultobj = SWIG_Py_Void();
26363 return resultobj;
26364 fail:
26365 return NULL;
26366 }
26367
26368
26369 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26370 PyObject *resultobj = 0;
26371 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26372 wxPoint *arg2 = 0 ;
26373 void *argp1 = 0 ;
26374 int res1 = 0 ;
26375 wxPoint temp2 ;
26376 PyObject * obj0 = 0 ;
26377 PyObject * obj1 = 0 ;
26378 char * kwnames[] = {
26379 (char *) "self",(char *) "pos", NULL
26380 };
26381
26382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26384 if (!SWIG_IsOK(res1)) {
26385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26386 }
26387 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26388 {
26389 arg2 = &temp2;
26390 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26391 }
26392 {
26393 PyThreadState* __tstate = wxPyBeginAllowThreads();
26394 (arg1)->SetPosition((wxPoint const &)*arg2);
26395 wxPyEndAllowThreads(__tstate);
26396 if (PyErr_Occurred()) SWIG_fail;
26397 }
26398 resultobj = SWIG_Py_Void();
26399 return resultobj;
26400 fail:
26401 return NULL;
26402 }
26403
26404
26405 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26406 PyObject *obj;
26407 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26408 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26409 return SWIG_Py_Void();
26410 }
26411
26412 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26413 return SWIG_Python_InitShadowInstance(args);
26414 }
26415
26416 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26417 PyObject *resultobj = 0;
26418 int arg1 = (int) 0 ;
26419 wxPaintEvent *result = 0 ;
26420 int val1 ;
26421 int ecode1 = 0 ;
26422 PyObject * obj0 = 0 ;
26423 char * kwnames[] = {
26424 (char *) "Id", NULL
26425 };
26426
26427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26428 if (obj0) {
26429 ecode1 = SWIG_AsVal_int(obj0, &val1);
26430 if (!SWIG_IsOK(ecode1)) {
26431 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26432 }
26433 arg1 = static_cast< int >(val1);
26434 }
26435 {
26436 PyThreadState* __tstate = wxPyBeginAllowThreads();
26437 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26438 wxPyEndAllowThreads(__tstate);
26439 if (PyErr_Occurred()) SWIG_fail;
26440 }
26441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26442 return resultobj;
26443 fail:
26444 return NULL;
26445 }
26446
26447
26448 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26449 PyObject *obj;
26450 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26451 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26452 return SWIG_Py_Void();
26453 }
26454
26455 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26456 return SWIG_Python_InitShadowInstance(args);
26457 }
26458
26459 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26460 PyObject *resultobj = 0;
26461 int arg1 = (int) 0 ;
26462 wxNcPaintEvent *result = 0 ;
26463 int val1 ;
26464 int ecode1 = 0 ;
26465 PyObject * obj0 = 0 ;
26466 char * kwnames[] = {
26467 (char *) "winid", NULL
26468 };
26469
26470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26471 if (obj0) {
26472 ecode1 = SWIG_AsVal_int(obj0, &val1);
26473 if (!SWIG_IsOK(ecode1)) {
26474 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26475 }
26476 arg1 = static_cast< int >(val1);
26477 }
26478 {
26479 PyThreadState* __tstate = wxPyBeginAllowThreads();
26480 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26481 wxPyEndAllowThreads(__tstate);
26482 if (PyErr_Occurred()) SWIG_fail;
26483 }
26484 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26485 return resultobj;
26486 fail:
26487 return NULL;
26488 }
26489
26490
26491 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26492 PyObject *obj;
26493 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26494 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26495 return SWIG_Py_Void();
26496 }
26497
26498 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26499 return SWIG_Python_InitShadowInstance(args);
26500 }
26501
26502 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26503 PyObject *resultobj = 0;
26504 int arg1 = (int) 0 ;
26505 wxDC *arg2 = (wxDC *) NULL ;
26506 wxEraseEvent *result = 0 ;
26507 int val1 ;
26508 int ecode1 = 0 ;
26509 void *argp2 = 0 ;
26510 int res2 = 0 ;
26511 PyObject * obj0 = 0 ;
26512 PyObject * obj1 = 0 ;
26513 char * kwnames[] = {
26514 (char *) "Id",(char *) "dc", NULL
26515 };
26516
26517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26518 if (obj0) {
26519 ecode1 = SWIG_AsVal_int(obj0, &val1);
26520 if (!SWIG_IsOK(ecode1)) {
26521 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26522 }
26523 arg1 = static_cast< int >(val1);
26524 }
26525 if (obj1) {
26526 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26527 if (!SWIG_IsOK(res2)) {
26528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26529 }
26530 arg2 = reinterpret_cast< wxDC * >(argp2);
26531 }
26532 {
26533 PyThreadState* __tstate = wxPyBeginAllowThreads();
26534 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26535 wxPyEndAllowThreads(__tstate);
26536 if (PyErr_Occurred()) SWIG_fail;
26537 }
26538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26539 return resultobj;
26540 fail:
26541 return NULL;
26542 }
26543
26544
26545 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26546 PyObject *resultobj = 0;
26547 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26548 wxDC *result = 0 ;
26549 void *argp1 = 0 ;
26550 int res1 = 0 ;
26551 PyObject *swig_obj[1] ;
26552
26553 if (!args) SWIG_fail;
26554 swig_obj[0] = args;
26555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26556 if (!SWIG_IsOK(res1)) {
26557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26558 }
26559 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26560 {
26561 PyThreadState* __tstate = wxPyBeginAllowThreads();
26562 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26563 wxPyEndAllowThreads(__tstate);
26564 if (PyErr_Occurred()) SWIG_fail;
26565 }
26566 {
26567 resultobj = wxPyMake_wxObject(result, (bool)0);
26568 }
26569 return resultobj;
26570 fail:
26571 return NULL;
26572 }
26573
26574
26575 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26576 PyObject *obj;
26577 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26578 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26579 return SWIG_Py_Void();
26580 }
26581
26582 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26583 return SWIG_Python_InitShadowInstance(args);
26584 }
26585
26586 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26587 PyObject *resultobj = 0;
26588 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26589 int arg2 = (int) 0 ;
26590 wxFocusEvent *result = 0 ;
26591 int val1 ;
26592 int ecode1 = 0 ;
26593 int val2 ;
26594 int ecode2 = 0 ;
26595 PyObject * obj0 = 0 ;
26596 PyObject * obj1 = 0 ;
26597 char * kwnames[] = {
26598 (char *) "type",(char *) "winid", NULL
26599 };
26600
26601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26602 if (obj0) {
26603 ecode1 = SWIG_AsVal_int(obj0, &val1);
26604 if (!SWIG_IsOK(ecode1)) {
26605 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26606 }
26607 arg1 = static_cast< wxEventType >(val1);
26608 }
26609 if (obj1) {
26610 ecode2 = SWIG_AsVal_int(obj1, &val2);
26611 if (!SWIG_IsOK(ecode2)) {
26612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26613 }
26614 arg2 = static_cast< int >(val2);
26615 }
26616 {
26617 PyThreadState* __tstate = wxPyBeginAllowThreads();
26618 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26619 wxPyEndAllowThreads(__tstate);
26620 if (PyErr_Occurred()) SWIG_fail;
26621 }
26622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26623 return resultobj;
26624 fail:
26625 return NULL;
26626 }
26627
26628
26629 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26630 PyObject *resultobj = 0;
26631 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26632 wxWindow *result = 0 ;
26633 void *argp1 = 0 ;
26634 int res1 = 0 ;
26635 PyObject *swig_obj[1] ;
26636
26637 if (!args) SWIG_fail;
26638 swig_obj[0] = args;
26639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26640 if (!SWIG_IsOK(res1)) {
26641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26642 }
26643 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26644 {
26645 PyThreadState* __tstate = wxPyBeginAllowThreads();
26646 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26647 wxPyEndAllowThreads(__tstate);
26648 if (PyErr_Occurred()) SWIG_fail;
26649 }
26650 {
26651 resultobj = wxPyMake_wxObject(result, (bool)0);
26652 }
26653 return resultobj;
26654 fail:
26655 return NULL;
26656 }
26657
26658
26659 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26660 PyObject *resultobj = 0;
26661 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26662 wxWindow *arg2 = (wxWindow *) 0 ;
26663 void *argp1 = 0 ;
26664 int res1 = 0 ;
26665 void *argp2 = 0 ;
26666 int res2 = 0 ;
26667 PyObject * obj0 = 0 ;
26668 PyObject * obj1 = 0 ;
26669 char * kwnames[] = {
26670 (char *) "self",(char *) "win", NULL
26671 };
26672
26673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26675 if (!SWIG_IsOK(res1)) {
26676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26677 }
26678 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26679 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26680 if (!SWIG_IsOK(res2)) {
26681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26682 }
26683 arg2 = reinterpret_cast< wxWindow * >(argp2);
26684 {
26685 PyThreadState* __tstate = wxPyBeginAllowThreads();
26686 (arg1)->SetWindow(arg2);
26687 wxPyEndAllowThreads(__tstate);
26688 if (PyErr_Occurred()) SWIG_fail;
26689 }
26690 resultobj = SWIG_Py_Void();
26691 return resultobj;
26692 fail:
26693 return NULL;
26694 }
26695
26696
26697 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26698 PyObject *obj;
26699 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26700 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26701 return SWIG_Py_Void();
26702 }
26703
26704 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26705 return SWIG_Python_InitShadowInstance(args);
26706 }
26707
26708 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26709 PyObject *resultobj = 0;
26710 wxWindow *arg1 = (wxWindow *) NULL ;
26711 wxChildFocusEvent *result = 0 ;
26712 void *argp1 = 0 ;
26713 int res1 = 0 ;
26714 PyObject * obj0 = 0 ;
26715 char * kwnames[] = {
26716 (char *) "win", NULL
26717 };
26718
26719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26720 if (obj0) {
26721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26722 if (!SWIG_IsOK(res1)) {
26723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26724 }
26725 arg1 = reinterpret_cast< wxWindow * >(argp1);
26726 }
26727 {
26728 PyThreadState* __tstate = wxPyBeginAllowThreads();
26729 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26730 wxPyEndAllowThreads(__tstate);
26731 if (PyErr_Occurred()) SWIG_fail;
26732 }
26733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26734 return resultobj;
26735 fail:
26736 return NULL;
26737 }
26738
26739
26740 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26741 PyObject *resultobj = 0;
26742 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26743 wxWindow *result = 0 ;
26744 void *argp1 = 0 ;
26745 int res1 = 0 ;
26746 PyObject *swig_obj[1] ;
26747
26748 if (!args) SWIG_fail;
26749 swig_obj[0] = args;
26750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26751 if (!SWIG_IsOK(res1)) {
26752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26753 }
26754 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26755 {
26756 PyThreadState* __tstate = wxPyBeginAllowThreads();
26757 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26758 wxPyEndAllowThreads(__tstate);
26759 if (PyErr_Occurred()) SWIG_fail;
26760 }
26761 {
26762 resultobj = wxPyMake_wxObject(result, (bool)0);
26763 }
26764 return resultobj;
26765 fail:
26766 return NULL;
26767 }
26768
26769
26770 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26771 PyObject *obj;
26772 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26773 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26774 return SWIG_Py_Void();
26775 }
26776
26777 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26778 return SWIG_Python_InitShadowInstance(args);
26779 }
26780
26781 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26782 PyObject *resultobj = 0;
26783 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26784 bool arg2 = (bool) true ;
26785 int arg3 = (int) 0 ;
26786 wxActivateEvent *result = 0 ;
26787 int val1 ;
26788 int ecode1 = 0 ;
26789 bool val2 ;
26790 int ecode2 = 0 ;
26791 int val3 ;
26792 int ecode3 = 0 ;
26793 PyObject * obj0 = 0 ;
26794 PyObject * obj1 = 0 ;
26795 PyObject * obj2 = 0 ;
26796 char * kwnames[] = {
26797 (char *) "type",(char *) "active",(char *) "Id", NULL
26798 };
26799
26800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26801 if (obj0) {
26802 ecode1 = SWIG_AsVal_int(obj0, &val1);
26803 if (!SWIG_IsOK(ecode1)) {
26804 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26805 }
26806 arg1 = static_cast< wxEventType >(val1);
26807 }
26808 if (obj1) {
26809 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26810 if (!SWIG_IsOK(ecode2)) {
26811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26812 }
26813 arg2 = static_cast< bool >(val2);
26814 }
26815 if (obj2) {
26816 ecode3 = SWIG_AsVal_int(obj2, &val3);
26817 if (!SWIG_IsOK(ecode3)) {
26818 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26819 }
26820 arg3 = static_cast< int >(val3);
26821 }
26822 {
26823 PyThreadState* __tstate = wxPyBeginAllowThreads();
26824 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26825 wxPyEndAllowThreads(__tstate);
26826 if (PyErr_Occurred()) SWIG_fail;
26827 }
26828 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26829 return resultobj;
26830 fail:
26831 return NULL;
26832 }
26833
26834
26835 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26836 PyObject *resultobj = 0;
26837 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26838 bool result;
26839 void *argp1 = 0 ;
26840 int res1 = 0 ;
26841 PyObject *swig_obj[1] ;
26842
26843 if (!args) SWIG_fail;
26844 swig_obj[0] = args;
26845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26846 if (!SWIG_IsOK(res1)) {
26847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26848 }
26849 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26850 {
26851 PyThreadState* __tstate = wxPyBeginAllowThreads();
26852 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26853 wxPyEndAllowThreads(__tstate);
26854 if (PyErr_Occurred()) SWIG_fail;
26855 }
26856 {
26857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26858 }
26859 return resultobj;
26860 fail:
26861 return NULL;
26862 }
26863
26864
26865 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26866 PyObject *obj;
26867 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26868 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26869 return SWIG_Py_Void();
26870 }
26871
26872 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26873 return SWIG_Python_InitShadowInstance(args);
26874 }
26875
26876 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26877 PyObject *resultobj = 0;
26878 int arg1 = (int) 0 ;
26879 wxInitDialogEvent *result = 0 ;
26880 int val1 ;
26881 int ecode1 = 0 ;
26882 PyObject * obj0 = 0 ;
26883 char * kwnames[] = {
26884 (char *) "Id", NULL
26885 };
26886
26887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26888 if (obj0) {
26889 ecode1 = SWIG_AsVal_int(obj0, &val1);
26890 if (!SWIG_IsOK(ecode1)) {
26891 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26892 }
26893 arg1 = static_cast< int >(val1);
26894 }
26895 {
26896 PyThreadState* __tstate = wxPyBeginAllowThreads();
26897 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26898 wxPyEndAllowThreads(__tstate);
26899 if (PyErr_Occurred()) SWIG_fail;
26900 }
26901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26902 return resultobj;
26903 fail:
26904 return NULL;
26905 }
26906
26907
26908 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26909 PyObject *obj;
26910 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26911 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26912 return SWIG_Py_Void();
26913 }
26914
26915 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26916 return SWIG_Python_InitShadowInstance(args);
26917 }
26918
26919 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26920 PyObject *resultobj = 0;
26921 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26922 int arg2 = (int) 0 ;
26923 wxMenu *arg3 = (wxMenu *) NULL ;
26924 wxMenuEvent *result = 0 ;
26925 int val1 ;
26926 int ecode1 = 0 ;
26927 int val2 ;
26928 int ecode2 = 0 ;
26929 void *argp3 = 0 ;
26930 int res3 = 0 ;
26931 PyObject * obj0 = 0 ;
26932 PyObject * obj1 = 0 ;
26933 PyObject * obj2 = 0 ;
26934 char * kwnames[] = {
26935 (char *) "type",(char *) "winid",(char *) "menu", NULL
26936 };
26937
26938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26939 if (obj0) {
26940 ecode1 = SWIG_AsVal_int(obj0, &val1);
26941 if (!SWIG_IsOK(ecode1)) {
26942 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26943 }
26944 arg1 = static_cast< wxEventType >(val1);
26945 }
26946 if (obj1) {
26947 ecode2 = SWIG_AsVal_int(obj1, &val2);
26948 if (!SWIG_IsOK(ecode2)) {
26949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
26950 }
26951 arg2 = static_cast< int >(val2);
26952 }
26953 if (obj2) {
26954 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
26955 if (!SWIG_IsOK(res3)) {
26956 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
26957 }
26958 arg3 = reinterpret_cast< wxMenu * >(argp3);
26959 }
26960 {
26961 PyThreadState* __tstate = wxPyBeginAllowThreads();
26962 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
26963 wxPyEndAllowThreads(__tstate);
26964 if (PyErr_Occurred()) SWIG_fail;
26965 }
26966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
26967 return resultobj;
26968 fail:
26969 return NULL;
26970 }
26971
26972
26973 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26974 PyObject *resultobj = 0;
26975 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26976 int result;
26977 void *argp1 = 0 ;
26978 int res1 = 0 ;
26979 PyObject *swig_obj[1] ;
26980
26981 if (!args) SWIG_fail;
26982 swig_obj[0] = args;
26983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26984 if (!SWIG_IsOK(res1)) {
26985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26986 }
26987 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
26988 {
26989 PyThreadState* __tstate = wxPyBeginAllowThreads();
26990 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
26991 wxPyEndAllowThreads(__tstate);
26992 if (PyErr_Occurred()) SWIG_fail;
26993 }
26994 resultobj = SWIG_From_int(static_cast< int >(result));
26995 return resultobj;
26996 fail:
26997 return NULL;
26998 }
26999
27000
27001 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27002 PyObject *resultobj = 0;
27003 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27004 bool result;
27005 void *argp1 = 0 ;
27006 int res1 = 0 ;
27007 PyObject *swig_obj[1] ;
27008
27009 if (!args) SWIG_fail;
27010 swig_obj[0] = args;
27011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27012 if (!SWIG_IsOK(res1)) {
27013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27014 }
27015 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27016 {
27017 PyThreadState* __tstate = wxPyBeginAllowThreads();
27018 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
27019 wxPyEndAllowThreads(__tstate);
27020 if (PyErr_Occurred()) SWIG_fail;
27021 }
27022 {
27023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27024 }
27025 return resultobj;
27026 fail:
27027 return NULL;
27028 }
27029
27030
27031 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27032 PyObject *resultobj = 0;
27033 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27034 wxMenu *result = 0 ;
27035 void *argp1 = 0 ;
27036 int res1 = 0 ;
27037 PyObject *swig_obj[1] ;
27038
27039 if (!args) SWIG_fail;
27040 swig_obj[0] = args;
27041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27042 if (!SWIG_IsOK(res1)) {
27043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27044 }
27045 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27046 {
27047 PyThreadState* __tstate = wxPyBeginAllowThreads();
27048 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27049 wxPyEndAllowThreads(__tstate);
27050 if (PyErr_Occurred()) SWIG_fail;
27051 }
27052 {
27053 resultobj = wxPyMake_wxObject(result, (bool)0);
27054 }
27055 return resultobj;
27056 fail:
27057 return NULL;
27058 }
27059
27060
27061 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27062 PyObject *obj;
27063 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27064 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27065 return SWIG_Py_Void();
27066 }
27067
27068 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27069 return SWIG_Python_InitShadowInstance(args);
27070 }
27071
27072 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27073 PyObject *resultobj = 0;
27074 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27075 int arg2 = (int) 0 ;
27076 wxCloseEvent *result = 0 ;
27077 int val1 ;
27078 int ecode1 = 0 ;
27079 int val2 ;
27080 int ecode2 = 0 ;
27081 PyObject * obj0 = 0 ;
27082 PyObject * obj1 = 0 ;
27083 char * kwnames[] = {
27084 (char *) "type",(char *) "winid", NULL
27085 };
27086
27087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27088 if (obj0) {
27089 ecode1 = SWIG_AsVal_int(obj0, &val1);
27090 if (!SWIG_IsOK(ecode1)) {
27091 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27092 }
27093 arg1 = static_cast< wxEventType >(val1);
27094 }
27095 if (obj1) {
27096 ecode2 = SWIG_AsVal_int(obj1, &val2);
27097 if (!SWIG_IsOK(ecode2)) {
27098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27099 }
27100 arg2 = static_cast< int >(val2);
27101 }
27102 {
27103 PyThreadState* __tstate = wxPyBeginAllowThreads();
27104 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27105 wxPyEndAllowThreads(__tstate);
27106 if (PyErr_Occurred()) SWIG_fail;
27107 }
27108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27109 return resultobj;
27110 fail:
27111 return NULL;
27112 }
27113
27114
27115 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27116 PyObject *resultobj = 0;
27117 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27118 bool arg2 ;
27119 void *argp1 = 0 ;
27120 int res1 = 0 ;
27121 bool val2 ;
27122 int ecode2 = 0 ;
27123 PyObject * obj0 = 0 ;
27124 PyObject * obj1 = 0 ;
27125 char * kwnames[] = {
27126 (char *) "self",(char *) "logOff", NULL
27127 };
27128
27129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27131 if (!SWIG_IsOK(res1)) {
27132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27133 }
27134 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27135 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27136 if (!SWIG_IsOK(ecode2)) {
27137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27138 }
27139 arg2 = static_cast< bool >(val2);
27140 {
27141 PyThreadState* __tstate = wxPyBeginAllowThreads();
27142 (arg1)->SetLoggingOff(arg2);
27143 wxPyEndAllowThreads(__tstate);
27144 if (PyErr_Occurred()) SWIG_fail;
27145 }
27146 resultobj = SWIG_Py_Void();
27147 return resultobj;
27148 fail:
27149 return NULL;
27150 }
27151
27152
27153 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27154 PyObject *resultobj = 0;
27155 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27156 bool result;
27157 void *argp1 = 0 ;
27158 int res1 = 0 ;
27159 PyObject *swig_obj[1] ;
27160
27161 if (!args) SWIG_fail;
27162 swig_obj[0] = args;
27163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27164 if (!SWIG_IsOK(res1)) {
27165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27166 }
27167 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27168 {
27169 PyThreadState* __tstate = wxPyBeginAllowThreads();
27170 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27171 wxPyEndAllowThreads(__tstate);
27172 if (PyErr_Occurred()) SWIG_fail;
27173 }
27174 {
27175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27176 }
27177 return resultobj;
27178 fail:
27179 return NULL;
27180 }
27181
27182
27183 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27184 PyObject *resultobj = 0;
27185 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27186 bool arg2 = (bool) true ;
27187 void *argp1 = 0 ;
27188 int res1 = 0 ;
27189 bool val2 ;
27190 int ecode2 = 0 ;
27191 PyObject * obj0 = 0 ;
27192 PyObject * obj1 = 0 ;
27193 char * kwnames[] = {
27194 (char *) "self",(char *) "veto", NULL
27195 };
27196
27197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27199 if (!SWIG_IsOK(res1)) {
27200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27201 }
27202 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27203 if (obj1) {
27204 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27205 if (!SWIG_IsOK(ecode2)) {
27206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27207 }
27208 arg2 = static_cast< bool >(val2);
27209 }
27210 {
27211 PyThreadState* __tstate = wxPyBeginAllowThreads();
27212 (arg1)->Veto(arg2);
27213 wxPyEndAllowThreads(__tstate);
27214 if (PyErr_Occurred()) SWIG_fail;
27215 }
27216 resultobj = SWIG_Py_Void();
27217 return resultobj;
27218 fail:
27219 return NULL;
27220 }
27221
27222
27223 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27224 PyObject *resultobj = 0;
27225 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27226 bool result;
27227 void *argp1 = 0 ;
27228 int res1 = 0 ;
27229 PyObject *swig_obj[1] ;
27230
27231 if (!args) SWIG_fail;
27232 swig_obj[0] = args;
27233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27234 if (!SWIG_IsOK(res1)) {
27235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27236 }
27237 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27238 {
27239 PyThreadState* __tstate = wxPyBeginAllowThreads();
27240 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27241 wxPyEndAllowThreads(__tstate);
27242 if (PyErr_Occurred()) SWIG_fail;
27243 }
27244 {
27245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27246 }
27247 return resultobj;
27248 fail:
27249 return NULL;
27250 }
27251
27252
27253 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27254 PyObject *resultobj = 0;
27255 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27256 bool arg2 ;
27257 void *argp1 = 0 ;
27258 int res1 = 0 ;
27259 bool val2 ;
27260 int ecode2 = 0 ;
27261 PyObject * obj0 = 0 ;
27262 PyObject * obj1 = 0 ;
27263 char * kwnames[] = {
27264 (char *) "self",(char *) "canVeto", NULL
27265 };
27266
27267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27269 if (!SWIG_IsOK(res1)) {
27270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27271 }
27272 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27273 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27274 if (!SWIG_IsOK(ecode2)) {
27275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27276 }
27277 arg2 = static_cast< bool >(val2);
27278 {
27279 PyThreadState* __tstate = wxPyBeginAllowThreads();
27280 (arg1)->SetCanVeto(arg2);
27281 wxPyEndAllowThreads(__tstate);
27282 if (PyErr_Occurred()) SWIG_fail;
27283 }
27284 resultobj = SWIG_Py_Void();
27285 return resultobj;
27286 fail:
27287 return NULL;
27288 }
27289
27290
27291 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27292 PyObject *resultobj = 0;
27293 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27294 bool result;
27295 void *argp1 = 0 ;
27296 int res1 = 0 ;
27297 PyObject *swig_obj[1] ;
27298
27299 if (!args) SWIG_fail;
27300 swig_obj[0] = args;
27301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27302 if (!SWIG_IsOK(res1)) {
27303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27304 }
27305 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27306 {
27307 PyThreadState* __tstate = wxPyBeginAllowThreads();
27308 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27309 wxPyEndAllowThreads(__tstate);
27310 if (PyErr_Occurred()) SWIG_fail;
27311 }
27312 {
27313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27314 }
27315 return resultobj;
27316 fail:
27317 return NULL;
27318 }
27319
27320
27321 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27322 PyObject *obj;
27323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27324 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27325 return SWIG_Py_Void();
27326 }
27327
27328 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27329 return SWIG_Python_InitShadowInstance(args);
27330 }
27331
27332 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27333 PyObject *resultobj = 0;
27334 int arg1 = (int) 0 ;
27335 bool arg2 = (bool) false ;
27336 wxShowEvent *result = 0 ;
27337 int val1 ;
27338 int ecode1 = 0 ;
27339 bool val2 ;
27340 int ecode2 = 0 ;
27341 PyObject * obj0 = 0 ;
27342 PyObject * obj1 = 0 ;
27343 char * kwnames[] = {
27344 (char *) "winid",(char *) "show", NULL
27345 };
27346
27347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27348 if (obj0) {
27349 ecode1 = SWIG_AsVal_int(obj0, &val1);
27350 if (!SWIG_IsOK(ecode1)) {
27351 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27352 }
27353 arg1 = static_cast< int >(val1);
27354 }
27355 if (obj1) {
27356 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27357 if (!SWIG_IsOK(ecode2)) {
27358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27359 }
27360 arg2 = static_cast< bool >(val2);
27361 }
27362 {
27363 PyThreadState* __tstate = wxPyBeginAllowThreads();
27364 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27365 wxPyEndAllowThreads(__tstate);
27366 if (PyErr_Occurred()) SWIG_fail;
27367 }
27368 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27369 return resultobj;
27370 fail:
27371 return NULL;
27372 }
27373
27374
27375 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27376 PyObject *resultobj = 0;
27377 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27378 bool arg2 ;
27379 void *argp1 = 0 ;
27380 int res1 = 0 ;
27381 bool val2 ;
27382 int ecode2 = 0 ;
27383 PyObject * obj0 = 0 ;
27384 PyObject * obj1 = 0 ;
27385 char * kwnames[] = {
27386 (char *) "self",(char *) "show", NULL
27387 };
27388
27389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27391 if (!SWIG_IsOK(res1)) {
27392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27393 }
27394 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27395 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27396 if (!SWIG_IsOK(ecode2)) {
27397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27398 }
27399 arg2 = static_cast< bool >(val2);
27400 {
27401 PyThreadState* __tstate = wxPyBeginAllowThreads();
27402 (arg1)->SetShow(arg2);
27403 wxPyEndAllowThreads(__tstate);
27404 if (PyErr_Occurred()) SWIG_fail;
27405 }
27406 resultobj = SWIG_Py_Void();
27407 return resultobj;
27408 fail:
27409 return NULL;
27410 }
27411
27412
27413 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27414 PyObject *resultobj = 0;
27415 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27416 bool result;
27417 void *argp1 = 0 ;
27418 int res1 = 0 ;
27419 PyObject *swig_obj[1] ;
27420
27421 if (!args) SWIG_fail;
27422 swig_obj[0] = args;
27423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27424 if (!SWIG_IsOK(res1)) {
27425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27426 }
27427 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27428 {
27429 PyThreadState* __tstate = wxPyBeginAllowThreads();
27430 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27431 wxPyEndAllowThreads(__tstate);
27432 if (PyErr_Occurred()) SWIG_fail;
27433 }
27434 {
27435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27436 }
27437 return resultobj;
27438 fail:
27439 return NULL;
27440 }
27441
27442
27443 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27444 PyObject *obj;
27445 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27446 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27447 return SWIG_Py_Void();
27448 }
27449
27450 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27451 return SWIG_Python_InitShadowInstance(args);
27452 }
27453
27454 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27455 PyObject *resultobj = 0;
27456 int arg1 = (int) 0 ;
27457 bool arg2 = (bool) true ;
27458 wxIconizeEvent *result = 0 ;
27459 int val1 ;
27460 int ecode1 = 0 ;
27461 bool val2 ;
27462 int ecode2 = 0 ;
27463 PyObject * obj0 = 0 ;
27464 PyObject * obj1 = 0 ;
27465 char * kwnames[] = {
27466 (char *) "id",(char *) "iconized", NULL
27467 };
27468
27469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27470 if (obj0) {
27471 ecode1 = SWIG_AsVal_int(obj0, &val1);
27472 if (!SWIG_IsOK(ecode1)) {
27473 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27474 }
27475 arg1 = static_cast< int >(val1);
27476 }
27477 if (obj1) {
27478 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27479 if (!SWIG_IsOK(ecode2)) {
27480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27481 }
27482 arg2 = static_cast< bool >(val2);
27483 }
27484 {
27485 PyThreadState* __tstate = wxPyBeginAllowThreads();
27486 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27487 wxPyEndAllowThreads(__tstate);
27488 if (PyErr_Occurred()) SWIG_fail;
27489 }
27490 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27491 return resultobj;
27492 fail:
27493 return NULL;
27494 }
27495
27496
27497 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27498 PyObject *resultobj = 0;
27499 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27500 bool result;
27501 void *argp1 = 0 ;
27502 int res1 = 0 ;
27503 PyObject *swig_obj[1] ;
27504
27505 if (!args) SWIG_fail;
27506 swig_obj[0] = args;
27507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27508 if (!SWIG_IsOK(res1)) {
27509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27510 }
27511 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27512 {
27513 PyThreadState* __tstate = wxPyBeginAllowThreads();
27514 result = (bool)(arg1)->Iconized();
27515 wxPyEndAllowThreads(__tstate);
27516 if (PyErr_Occurred()) SWIG_fail;
27517 }
27518 {
27519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27520 }
27521 return resultobj;
27522 fail:
27523 return NULL;
27524 }
27525
27526
27527 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27528 PyObject *obj;
27529 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27530 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27531 return SWIG_Py_Void();
27532 }
27533
27534 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27535 return SWIG_Python_InitShadowInstance(args);
27536 }
27537
27538 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27539 PyObject *resultobj = 0;
27540 int arg1 = (int) 0 ;
27541 wxMaximizeEvent *result = 0 ;
27542 int val1 ;
27543 int ecode1 = 0 ;
27544 PyObject * obj0 = 0 ;
27545 char * kwnames[] = {
27546 (char *) "id", NULL
27547 };
27548
27549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27550 if (obj0) {
27551 ecode1 = SWIG_AsVal_int(obj0, &val1);
27552 if (!SWIG_IsOK(ecode1)) {
27553 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27554 }
27555 arg1 = static_cast< int >(val1);
27556 }
27557 {
27558 PyThreadState* __tstate = wxPyBeginAllowThreads();
27559 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27560 wxPyEndAllowThreads(__tstate);
27561 if (PyErr_Occurred()) SWIG_fail;
27562 }
27563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27564 return resultobj;
27565 fail:
27566 return NULL;
27567 }
27568
27569
27570 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27571 PyObject *obj;
27572 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27573 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27574 return SWIG_Py_Void();
27575 }
27576
27577 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27578 return SWIG_Python_InitShadowInstance(args);
27579 }
27580
27581 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27582 PyObject *resultobj = 0;
27583 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27584 wxPoint result;
27585 void *argp1 = 0 ;
27586 int res1 = 0 ;
27587 PyObject *swig_obj[1] ;
27588
27589 if (!args) SWIG_fail;
27590 swig_obj[0] = args;
27591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27592 if (!SWIG_IsOK(res1)) {
27593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27594 }
27595 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27596 {
27597 PyThreadState* __tstate = wxPyBeginAllowThreads();
27598 result = (arg1)->GetPosition();
27599 wxPyEndAllowThreads(__tstate);
27600 if (PyErr_Occurred()) SWIG_fail;
27601 }
27602 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27603 return resultobj;
27604 fail:
27605 return NULL;
27606 }
27607
27608
27609 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27610 PyObject *resultobj = 0;
27611 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27612 int result;
27613 void *argp1 = 0 ;
27614 int res1 = 0 ;
27615 PyObject *swig_obj[1] ;
27616
27617 if (!args) SWIG_fail;
27618 swig_obj[0] = args;
27619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27620 if (!SWIG_IsOK(res1)) {
27621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27622 }
27623 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27624 {
27625 PyThreadState* __tstate = wxPyBeginAllowThreads();
27626 result = (int)(arg1)->GetNumberOfFiles();
27627 wxPyEndAllowThreads(__tstate);
27628 if (PyErr_Occurred()) SWIG_fail;
27629 }
27630 resultobj = SWIG_From_int(static_cast< int >(result));
27631 return resultobj;
27632 fail:
27633 return NULL;
27634 }
27635
27636
27637 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27638 PyObject *resultobj = 0;
27639 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27640 PyObject *result = 0 ;
27641 void *argp1 = 0 ;
27642 int res1 = 0 ;
27643 PyObject *swig_obj[1] ;
27644
27645 if (!args) SWIG_fail;
27646 swig_obj[0] = args;
27647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27648 if (!SWIG_IsOK(res1)) {
27649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27650 }
27651 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27652 {
27653 PyThreadState* __tstate = wxPyBeginAllowThreads();
27654 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27655 wxPyEndAllowThreads(__tstate);
27656 if (PyErr_Occurred()) SWIG_fail;
27657 }
27658 resultobj = result;
27659 return resultobj;
27660 fail:
27661 return NULL;
27662 }
27663
27664
27665 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27666 PyObject *obj;
27667 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27668 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27669 return SWIG_Py_Void();
27670 }
27671
27672 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27673 PyObject *resultobj = 0;
27674 int arg1 = (int) 0 ;
27675 wxUpdateUIEvent *result = 0 ;
27676 int val1 ;
27677 int ecode1 = 0 ;
27678 PyObject * obj0 = 0 ;
27679 char * kwnames[] = {
27680 (char *) "commandId", NULL
27681 };
27682
27683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27684 if (obj0) {
27685 ecode1 = SWIG_AsVal_int(obj0, &val1);
27686 if (!SWIG_IsOK(ecode1)) {
27687 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27688 }
27689 arg1 = static_cast< int >(val1);
27690 }
27691 {
27692 PyThreadState* __tstate = wxPyBeginAllowThreads();
27693 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27694 wxPyEndAllowThreads(__tstate);
27695 if (PyErr_Occurred()) SWIG_fail;
27696 }
27697 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27698 return resultobj;
27699 fail:
27700 return NULL;
27701 }
27702
27703
27704 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27705 PyObject *resultobj = 0;
27706 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27707 bool result;
27708 void *argp1 = 0 ;
27709 int res1 = 0 ;
27710 PyObject *swig_obj[1] ;
27711
27712 if (!args) SWIG_fail;
27713 swig_obj[0] = args;
27714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27715 if (!SWIG_IsOK(res1)) {
27716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27717 }
27718 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27719 {
27720 PyThreadState* __tstate = wxPyBeginAllowThreads();
27721 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27722 wxPyEndAllowThreads(__tstate);
27723 if (PyErr_Occurred()) SWIG_fail;
27724 }
27725 {
27726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27727 }
27728 return resultobj;
27729 fail:
27730 return NULL;
27731 }
27732
27733
27734 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27735 PyObject *resultobj = 0;
27736 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27737 bool result;
27738 void *argp1 = 0 ;
27739 int res1 = 0 ;
27740 PyObject *swig_obj[1] ;
27741
27742 if (!args) SWIG_fail;
27743 swig_obj[0] = args;
27744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27745 if (!SWIG_IsOK(res1)) {
27746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27747 }
27748 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27749 {
27750 PyThreadState* __tstate = wxPyBeginAllowThreads();
27751 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27752 wxPyEndAllowThreads(__tstate);
27753 if (PyErr_Occurred()) SWIG_fail;
27754 }
27755 {
27756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27757 }
27758 return resultobj;
27759 fail:
27760 return NULL;
27761 }
27762
27763
27764 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27765 PyObject *resultobj = 0;
27766 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27767 bool result;
27768 void *argp1 = 0 ;
27769 int res1 = 0 ;
27770 PyObject *swig_obj[1] ;
27771
27772 if (!args) SWIG_fail;
27773 swig_obj[0] = args;
27774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27775 if (!SWIG_IsOK(res1)) {
27776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27777 }
27778 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27779 {
27780 PyThreadState* __tstate = wxPyBeginAllowThreads();
27781 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27782 wxPyEndAllowThreads(__tstate);
27783 if (PyErr_Occurred()) SWIG_fail;
27784 }
27785 {
27786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27787 }
27788 return resultobj;
27789 fail:
27790 return NULL;
27791 }
27792
27793
27794 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27795 PyObject *resultobj = 0;
27796 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27797 wxString result;
27798 void *argp1 = 0 ;
27799 int res1 = 0 ;
27800 PyObject *swig_obj[1] ;
27801
27802 if (!args) SWIG_fail;
27803 swig_obj[0] = args;
27804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27805 if (!SWIG_IsOK(res1)) {
27806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27807 }
27808 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27809 {
27810 PyThreadState* __tstate = wxPyBeginAllowThreads();
27811 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27812 wxPyEndAllowThreads(__tstate);
27813 if (PyErr_Occurred()) SWIG_fail;
27814 }
27815 {
27816 #if wxUSE_UNICODE
27817 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27818 #else
27819 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27820 #endif
27821 }
27822 return resultobj;
27823 fail:
27824 return NULL;
27825 }
27826
27827
27828 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27829 PyObject *resultobj = 0;
27830 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27831 bool result;
27832 void *argp1 = 0 ;
27833 int res1 = 0 ;
27834 PyObject *swig_obj[1] ;
27835
27836 if (!args) SWIG_fail;
27837 swig_obj[0] = args;
27838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27839 if (!SWIG_IsOK(res1)) {
27840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27841 }
27842 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27843 {
27844 PyThreadState* __tstate = wxPyBeginAllowThreads();
27845 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27846 wxPyEndAllowThreads(__tstate);
27847 if (PyErr_Occurred()) SWIG_fail;
27848 }
27849 {
27850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27851 }
27852 return resultobj;
27853 fail:
27854 return NULL;
27855 }
27856
27857
27858 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27859 PyObject *resultobj = 0;
27860 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27861 bool result;
27862 void *argp1 = 0 ;
27863 int res1 = 0 ;
27864 PyObject *swig_obj[1] ;
27865
27866 if (!args) SWIG_fail;
27867 swig_obj[0] = args;
27868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27869 if (!SWIG_IsOK(res1)) {
27870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27871 }
27872 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27873 {
27874 PyThreadState* __tstate = wxPyBeginAllowThreads();
27875 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27876 wxPyEndAllowThreads(__tstate);
27877 if (PyErr_Occurred()) SWIG_fail;
27878 }
27879 {
27880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27881 }
27882 return resultobj;
27883 fail:
27884 return NULL;
27885 }
27886
27887
27888 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27889 PyObject *resultobj = 0;
27890 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27891 bool result;
27892 void *argp1 = 0 ;
27893 int res1 = 0 ;
27894 PyObject *swig_obj[1] ;
27895
27896 if (!args) SWIG_fail;
27897 swig_obj[0] = args;
27898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27899 if (!SWIG_IsOK(res1)) {
27900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27901 }
27902 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27903 {
27904 PyThreadState* __tstate = wxPyBeginAllowThreads();
27905 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27906 wxPyEndAllowThreads(__tstate);
27907 if (PyErr_Occurred()) SWIG_fail;
27908 }
27909 {
27910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27911 }
27912 return resultobj;
27913 fail:
27914 return NULL;
27915 }
27916
27917
27918 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27919 PyObject *resultobj = 0;
27920 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27921 bool result;
27922 void *argp1 = 0 ;
27923 int res1 = 0 ;
27924 PyObject *swig_obj[1] ;
27925
27926 if (!args) SWIG_fail;
27927 swig_obj[0] = args;
27928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27929 if (!SWIG_IsOK(res1)) {
27930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27931 }
27932 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27933 {
27934 PyThreadState* __tstate = wxPyBeginAllowThreads();
27935 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
27936 wxPyEndAllowThreads(__tstate);
27937 if (PyErr_Occurred()) SWIG_fail;
27938 }
27939 {
27940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27941 }
27942 return resultobj;
27943 fail:
27944 return NULL;
27945 }
27946
27947
27948 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27949 PyObject *resultobj = 0;
27950 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27951 bool arg2 ;
27952 void *argp1 = 0 ;
27953 int res1 = 0 ;
27954 bool val2 ;
27955 int ecode2 = 0 ;
27956 PyObject * obj0 = 0 ;
27957 PyObject * obj1 = 0 ;
27958 char * kwnames[] = {
27959 (char *) "self",(char *) "check", NULL
27960 };
27961
27962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
27963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27964 if (!SWIG_IsOK(res1)) {
27965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27966 }
27967 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27968 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27969 if (!SWIG_IsOK(ecode2)) {
27970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
27971 }
27972 arg2 = static_cast< bool >(val2);
27973 {
27974 PyThreadState* __tstate = wxPyBeginAllowThreads();
27975 (arg1)->Check(arg2);
27976 wxPyEndAllowThreads(__tstate);
27977 if (PyErr_Occurred()) SWIG_fail;
27978 }
27979 resultobj = SWIG_Py_Void();
27980 return resultobj;
27981 fail:
27982 return NULL;
27983 }
27984
27985
27986 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27987 PyObject *resultobj = 0;
27988 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27989 bool arg2 ;
27990 void *argp1 = 0 ;
27991 int res1 = 0 ;
27992 bool val2 ;
27993 int ecode2 = 0 ;
27994 PyObject * obj0 = 0 ;
27995 PyObject * obj1 = 0 ;
27996 char * kwnames[] = {
27997 (char *) "self",(char *) "enable", NULL
27998 };
27999
28000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
28001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28002 if (!SWIG_IsOK(res1)) {
28003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28004 }
28005 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28006 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28007 if (!SWIG_IsOK(ecode2)) {
28008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
28009 }
28010 arg2 = static_cast< bool >(val2);
28011 {
28012 PyThreadState* __tstate = wxPyBeginAllowThreads();
28013 (arg1)->Enable(arg2);
28014 wxPyEndAllowThreads(__tstate);
28015 if (PyErr_Occurred()) SWIG_fail;
28016 }
28017 resultobj = SWIG_Py_Void();
28018 return resultobj;
28019 fail:
28020 return NULL;
28021 }
28022
28023
28024 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28025 PyObject *resultobj = 0;
28026 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28027 bool arg2 ;
28028 void *argp1 = 0 ;
28029 int res1 = 0 ;
28030 bool val2 ;
28031 int ecode2 = 0 ;
28032 PyObject * obj0 = 0 ;
28033 PyObject * obj1 = 0 ;
28034 char * kwnames[] = {
28035 (char *) "self",(char *) "show", NULL
28036 };
28037
28038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28040 if (!SWIG_IsOK(res1)) {
28041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28042 }
28043 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28044 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28045 if (!SWIG_IsOK(ecode2)) {
28046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28047 }
28048 arg2 = static_cast< bool >(val2);
28049 {
28050 PyThreadState* __tstate = wxPyBeginAllowThreads();
28051 (arg1)->Show(arg2);
28052 wxPyEndAllowThreads(__tstate);
28053 if (PyErr_Occurred()) SWIG_fail;
28054 }
28055 resultobj = SWIG_Py_Void();
28056 return resultobj;
28057 fail:
28058 return NULL;
28059 }
28060
28061
28062 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28063 PyObject *resultobj = 0;
28064 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28065 wxString *arg2 = 0 ;
28066 void *argp1 = 0 ;
28067 int res1 = 0 ;
28068 bool temp2 = false ;
28069 PyObject * obj0 = 0 ;
28070 PyObject * obj1 = 0 ;
28071 char * kwnames[] = {
28072 (char *) "self",(char *) "text", NULL
28073 };
28074
28075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28077 if (!SWIG_IsOK(res1)) {
28078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28079 }
28080 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28081 {
28082 arg2 = wxString_in_helper(obj1);
28083 if (arg2 == NULL) SWIG_fail;
28084 temp2 = true;
28085 }
28086 {
28087 PyThreadState* __tstate = wxPyBeginAllowThreads();
28088 (arg1)->SetText((wxString const &)*arg2);
28089 wxPyEndAllowThreads(__tstate);
28090 if (PyErr_Occurred()) SWIG_fail;
28091 }
28092 resultobj = SWIG_Py_Void();
28093 {
28094 if (temp2)
28095 delete arg2;
28096 }
28097 return resultobj;
28098 fail:
28099 {
28100 if (temp2)
28101 delete arg2;
28102 }
28103 return NULL;
28104 }
28105
28106
28107 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28108 PyObject *resultobj = 0;
28109 long arg1 ;
28110 long val1 ;
28111 int ecode1 = 0 ;
28112 PyObject * obj0 = 0 ;
28113 char * kwnames[] = {
28114 (char *) "updateInterval", NULL
28115 };
28116
28117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28118 ecode1 = SWIG_AsVal_long(obj0, &val1);
28119 if (!SWIG_IsOK(ecode1)) {
28120 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28121 }
28122 arg1 = static_cast< long >(val1);
28123 {
28124 PyThreadState* __tstate = wxPyBeginAllowThreads();
28125 wxUpdateUIEvent::SetUpdateInterval(arg1);
28126 wxPyEndAllowThreads(__tstate);
28127 if (PyErr_Occurred()) SWIG_fail;
28128 }
28129 resultobj = SWIG_Py_Void();
28130 return resultobj;
28131 fail:
28132 return NULL;
28133 }
28134
28135
28136 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28137 PyObject *resultobj = 0;
28138 long result;
28139
28140 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28141 {
28142 PyThreadState* __tstate = wxPyBeginAllowThreads();
28143 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28144 wxPyEndAllowThreads(__tstate);
28145 if (PyErr_Occurred()) SWIG_fail;
28146 }
28147 resultobj = SWIG_From_long(static_cast< long >(result));
28148 return resultobj;
28149 fail:
28150 return NULL;
28151 }
28152
28153
28154 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28155 PyObject *resultobj = 0;
28156 wxWindow *arg1 = (wxWindow *) 0 ;
28157 bool result;
28158 void *argp1 = 0 ;
28159 int res1 = 0 ;
28160 PyObject * obj0 = 0 ;
28161 char * kwnames[] = {
28162 (char *) "win", NULL
28163 };
28164
28165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28167 if (!SWIG_IsOK(res1)) {
28168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28169 }
28170 arg1 = reinterpret_cast< wxWindow * >(argp1);
28171 {
28172 PyThreadState* __tstate = wxPyBeginAllowThreads();
28173 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28174 wxPyEndAllowThreads(__tstate);
28175 if (PyErr_Occurred()) SWIG_fail;
28176 }
28177 {
28178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28179 }
28180 return resultobj;
28181 fail:
28182 return NULL;
28183 }
28184
28185
28186 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28187 PyObject *resultobj = 0;
28188
28189 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28190 {
28191 PyThreadState* __tstate = wxPyBeginAllowThreads();
28192 wxUpdateUIEvent::ResetUpdateTime();
28193 wxPyEndAllowThreads(__tstate);
28194 if (PyErr_Occurred()) SWIG_fail;
28195 }
28196 resultobj = SWIG_Py_Void();
28197 return resultobj;
28198 fail:
28199 return NULL;
28200 }
28201
28202
28203 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28204 PyObject *resultobj = 0;
28205 wxUpdateUIMode arg1 ;
28206 int val1 ;
28207 int ecode1 = 0 ;
28208 PyObject * obj0 = 0 ;
28209 char * kwnames[] = {
28210 (char *) "mode", NULL
28211 };
28212
28213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28214 ecode1 = SWIG_AsVal_int(obj0, &val1);
28215 if (!SWIG_IsOK(ecode1)) {
28216 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28217 }
28218 arg1 = static_cast< wxUpdateUIMode >(val1);
28219 {
28220 PyThreadState* __tstate = wxPyBeginAllowThreads();
28221 wxUpdateUIEvent::SetMode(arg1);
28222 wxPyEndAllowThreads(__tstate);
28223 if (PyErr_Occurred()) SWIG_fail;
28224 }
28225 resultobj = SWIG_Py_Void();
28226 return resultobj;
28227 fail:
28228 return NULL;
28229 }
28230
28231
28232 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28233 PyObject *resultobj = 0;
28234 wxUpdateUIMode result;
28235
28236 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28237 {
28238 PyThreadState* __tstate = wxPyBeginAllowThreads();
28239 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28240 wxPyEndAllowThreads(__tstate);
28241 if (PyErr_Occurred()) SWIG_fail;
28242 }
28243 resultobj = SWIG_From_int(static_cast< int >(result));
28244 return resultobj;
28245 fail:
28246 return NULL;
28247 }
28248
28249
28250 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28251 PyObject *obj;
28252 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28253 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28254 return SWIG_Py_Void();
28255 }
28256
28257 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28258 return SWIG_Python_InitShadowInstance(args);
28259 }
28260
28261 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28262 PyObject *resultobj = 0;
28263 wxSysColourChangedEvent *result = 0 ;
28264
28265 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28266 {
28267 PyThreadState* __tstate = wxPyBeginAllowThreads();
28268 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28269 wxPyEndAllowThreads(__tstate);
28270 if (PyErr_Occurred()) SWIG_fail;
28271 }
28272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28273 return resultobj;
28274 fail:
28275 return NULL;
28276 }
28277
28278
28279 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28280 PyObject *obj;
28281 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28282 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28283 return SWIG_Py_Void();
28284 }
28285
28286 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28287 return SWIG_Python_InitShadowInstance(args);
28288 }
28289
28290 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28291 PyObject *resultobj = 0;
28292 int arg1 = (int) 0 ;
28293 wxWindow *arg2 = (wxWindow *) NULL ;
28294 wxMouseCaptureChangedEvent *result = 0 ;
28295 int val1 ;
28296 int ecode1 = 0 ;
28297 void *argp2 = 0 ;
28298 int res2 = 0 ;
28299 PyObject * obj0 = 0 ;
28300 PyObject * obj1 = 0 ;
28301 char * kwnames[] = {
28302 (char *) "winid",(char *) "gainedCapture", NULL
28303 };
28304
28305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28306 if (obj0) {
28307 ecode1 = SWIG_AsVal_int(obj0, &val1);
28308 if (!SWIG_IsOK(ecode1)) {
28309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28310 }
28311 arg1 = static_cast< int >(val1);
28312 }
28313 if (obj1) {
28314 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28315 if (!SWIG_IsOK(res2)) {
28316 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28317 }
28318 arg2 = reinterpret_cast< wxWindow * >(argp2);
28319 }
28320 {
28321 PyThreadState* __tstate = wxPyBeginAllowThreads();
28322 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28323 wxPyEndAllowThreads(__tstate);
28324 if (PyErr_Occurred()) SWIG_fail;
28325 }
28326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28327 return resultobj;
28328 fail:
28329 return NULL;
28330 }
28331
28332
28333 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28334 PyObject *resultobj = 0;
28335 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28336 wxWindow *result = 0 ;
28337 void *argp1 = 0 ;
28338 int res1 = 0 ;
28339 PyObject *swig_obj[1] ;
28340
28341 if (!args) SWIG_fail;
28342 swig_obj[0] = args;
28343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28344 if (!SWIG_IsOK(res1)) {
28345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28346 }
28347 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28348 {
28349 PyThreadState* __tstate = wxPyBeginAllowThreads();
28350 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28351 wxPyEndAllowThreads(__tstate);
28352 if (PyErr_Occurred()) SWIG_fail;
28353 }
28354 {
28355 resultobj = wxPyMake_wxObject(result, (bool)0);
28356 }
28357 return resultobj;
28358 fail:
28359 return NULL;
28360 }
28361
28362
28363 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28364 PyObject *obj;
28365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28366 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28367 return SWIG_Py_Void();
28368 }
28369
28370 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28371 return SWIG_Python_InitShadowInstance(args);
28372 }
28373
28374 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28375 PyObject *resultobj = 0;
28376 int arg1 = (int) 0 ;
28377 wxMouseCaptureLostEvent *result = 0 ;
28378 int val1 ;
28379 int ecode1 = 0 ;
28380 PyObject * obj0 = 0 ;
28381 char * kwnames[] = {
28382 (char *) "winid", NULL
28383 };
28384
28385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28386 if (obj0) {
28387 ecode1 = SWIG_AsVal_int(obj0, &val1);
28388 if (!SWIG_IsOK(ecode1)) {
28389 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28390 }
28391 arg1 = static_cast< int >(val1);
28392 }
28393 {
28394 PyThreadState* __tstate = wxPyBeginAllowThreads();
28395 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28396 wxPyEndAllowThreads(__tstate);
28397 if (PyErr_Occurred()) SWIG_fail;
28398 }
28399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28400 return resultobj;
28401 fail:
28402 return NULL;
28403 }
28404
28405
28406 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28407 PyObject *obj;
28408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28409 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28410 return SWIG_Py_Void();
28411 }
28412
28413 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28414 return SWIG_Python_InitShadowInstance(args);
28415 }
28416
28417 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28418 PyObject *resultobj = 0;
28419 wxDisplayChangedEvent *result = 0 ;
28420
28421 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28422 {
28423 PyThreadState* __tstate = wxPyBeginAllowThreads();
28424 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28425 wxPyEndAllowThreads(__tstate);
28426 if (PyErr_Occurred()) SWIG_fail;
28427 }
28428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28429 return resultobj;
28430 fail:
28431 return NULL;
28432 }
28433
28434
28435 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28436 PyObject *obj;
28437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28438 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28439 return SWIG_Py_Void();
28440 }
28441
28442 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28443 return SWIG_Python_InitShadowInstance(args);
28444 }
28445
28446 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28447 PyObject *resultobj = 0;
28448 int arg1 = (int) 0 ;
28449 wxPaletteChangedEvent *result = 0 ;
28450 int val1 ;
28451 int ecode1 = 0 ;
28452 PyObject * obj0 = 0 ;
28453 char * kwnames[] = {
28454 (char *) "id", NULL
28455 };
28456
28457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28458 if (obj0) {
28459 ecode1 = SWIG_AsVal_int(obj0, &val1);
28460 if (!SWIG_IsOK(ecode1)) {
28461 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28462 }
28463 arg1 = static_cast< int >(val1);
28464 }
28465 {
28466 PyThreadState* __tstate = wxPyBeginAllowThreads();
28467 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28468 wxPyEndAllowThreads(__tstate);
28469 if (PyErr_Occurred()) SWIG_fail;
28470 }
28471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28472 return resultobj;
28473 fail:
28474 return NULL;
28475 }
28476
28477
28478 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28479 PyObject *resultobj = 0;
28480 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28481 wxWindow *arg2 = (wxWindow *) 0 ;
28482 void *argp1 = 0 ;
28483 int res1 = 0 ;
28484 void *argp2 = 0 ;
28485 int res2 = 0 ;
28486 PyObject * obj0 = 0 ;
28487 PyObject * obj1 = 0 ;
28488 char * kwnames[] = {
28489 (char *) "self",(char *) "win", NULL
28490 };
28491
28492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28494 if (!SWIG_IsOK(res1)) {
28495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28496 }
28497 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28498 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28499 if (!SWIG_IsOK(res2)) {
28500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28501 }
28502 arg2 = reinterpret_cast< wxWindow * >(argp2);
28503 {
28504 PyThreadState* __tstate = wxPyBeginAllowThreads();
28505 (arg1)->SetChangedWindow(arg2);
28506 wxPyEndAllowThreads(__tstate);
28507 if (PyErr_Occurred()) SWIG_fail;
28508 }
28509 resultobj = SWIG_Py_Void();
28510 return resultobj;
28511 fail:
28512 return NULL;
28513 }
28514
28515
28516 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28517 PyObject *resultobj = 0;
28518 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28519 wxWindow *result = 0 ;
28520 void *argp1 = 0 ;
28521 int res1 = 0 ;
28522 PyObject *swig_obj[1] ;
28523
28524 if (!args) SWIG_fail;
28525 swig_obj[0] = args;
28526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28527 if (!SWIG_IsOK(res1)) {
28528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28529 }
28530 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28531 {
28532 PyThreadState* __tstate = wxPyBeginAllowThreads();
28533 result = (wxWindow *)(arg1)->GetChangedWindow();
28534 wxPyEndAllowThreads(__tstate);
28535 if (PyErr_Occurred()) SWIG_fail;
28536 }
28537 {
28538 resultobj = wxPyMake_wxObject(result, (bool)0);
28539 }
28540 return resultobj;
28541 fail:
28542 return NULL;
28543 }
28544
28545
28546 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28547 PyObject *obj;
28548 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28549 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28550 return SWIG_Py_Void();
28551 }
28552
28553 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28554 return SWIG_Python_InitShadowInstance(args);
28555 }
28556
28557 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28558 PyObject *resultobj = 0;
28559 int arg1 = (int) 0 ;
28560 wxQueryNewPaletteEvent *result = 0 ;
28561 int val1 ;
28562 int ecode1 = 0 ;
28563 PyObject * obj0 = 0 ;
28564 char * kwnames[] = {
28565 (char *) "winid", NULL
28566 };
28567
28568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28569 if (obj0) {
28570 ecode1 = SWIG_AsVal_int(obj0, &val1);
28571 if (!SWIG_IsOK(ecode1)) {
28572 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28573 }
28574 arg1 = static_cast< int >(val1);
28575 }
28576 {
28577 PyThreadState* __tstate = wxPyBeginAllowThreads();
28578 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28579 wxPyEndAllowThreads(__tstate);
28580 if (PyErr_Occurred()) SWIG_fail;
28581 }
28582 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28583 return resultobj;
28584 fail:
28585 return NULL;
28586 }
28587
28588
28589 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28590 PyObject *resultobj = 0;
28591 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28592 bool arg2 ;
28593 void *argp1 = 0 ;
28594 int res1 = 0 ;
28595 bool val2 ;
28596 int ecode2 = 0 ;
28597 PyObject * obj0 = 0 ;
28598 PyObject * obj1 = 0 ;
28599 char * kwnames[] = {
28600 (char *) "self",(char *) "realized", NULL
28601 };
28602
28603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28605 if (!SWIG_IsOK(res1)) {
28606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28607 }
28608 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28609 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28610 if (!SWIG_IsOK(ecode2)) {
28611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28612 }
28613 arg2 = static_cast< bool >(val2);
28614 {
28615 PyThreadState* __tstate = wxPyBeginAllowThreads();
28616 (arg1)->SetPaletteRealized(arg2);
28617 wxPyEndAllowThreads(__tstate);
28618 if (PyErr_Occurred()) SWIG_fail;
28619 }
28620 resultobj = SWIG_Py_Void();
28621 return resultobj;
28622 fail:
28623 return NULL;
28624 }
28625
28626
28627 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28628 PyObject *resultobj = 0;
28629 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28630 bool result;
28631 void *argp1 = 0 ;
28632 int res1 = 0 ;
28633 PyObject *swig_obj[1] ;
28634
28635 if (!args) SWIG_fail;
28636 swig_obj[0] = args;
28637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28638 if (!SWIG_IsOK(res1)) {
28639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28640 }
28641 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28642 {
28643 PyThreadState* __tstate = wxPyBeginAllowThreads();
28644 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28645 wxPyEndAllowThreads(__tstate);
28646 if (PyErr_Occurred()) SWIG_fail;
28647 }
28648 {
28649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28650 }
28651 return resultobj;
28652 fail:
28653 return NULL;
28654 }
28655
28656
28657 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28658 PyObject *obj;
28659 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28660 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28661 return SWIG_Py_Void();
28662 }
28663
28664 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28665 return SWIG_Python_InitShadowInstance(args);
28666 }
28667
28668 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28669 PyObject *resultobj = 0;
28670 wxNavigationKeyEvent *result = 0 ;
28671
28672 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28673 {
28674 PyThreadState* __tstate = wxPyBeginAllowThreads();
28675 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28676 wxPyEndAllowThreads(__tstate);
28677 if (PyErr_Occurred()) SWIG_fail;
28678 }
28679 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28680 return resultobj;
28681 fail:
28682 return NULL;
28683 }
28684
28685
28686 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28687 PyObject *resultobj = 0;
28688 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28689 bool result;
28690 void *argp1 = 0 ;
28691 int res1 = 0 ;
28692 PyObject *swig_obj[1] ;
28693
28694 if (!args) SWIG_fail;
28695 swig_obj[0] = args;
28696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28697 if (!SWIG_IsOK(res1)) {
28698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28699 }
28700 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28701 {
28702 PyThreadState* __tstate = wxPyBeginAllowThreads();
28703 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28704 wxPyEndAllowThreads(__tstate);
28705 if (PyErr_Occurred()) SWIG_fail;
28706 }
28707 {
28708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28709 }
28710 return resultobj;
28711 fail:
28712 return NULL;
28713 }
28714
28715
28716 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28717 PyObject *resultobj = 0;
28718 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28719 bool arg2 ;
28720 void *argp1 = 0 ;
28721 int res1 = 0 ;
28722 bool val2 ;
28723 int ecode2 = 0 ;
28724 PyObject * obj0 = 0 ;
28725 PyObject * obj1 = 0 ;
28726 char * kwnames[] = {
28727 (char *) "self",(char *) "forward", NULL
28728 };
28729
28730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28732 if (!SWIG_IsOK(res1)) {
28733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28734 }
28735 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28736 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28737 if (!SWIG_IsOK(ecode2)) {
28738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28739 }
28740 arg2 = static_cast< bool >(val2);
28741 {
28742 PyThreadState* __tstate = wxPyBeginAllowThreads();
28743 (arg1)->SetDirection(arg2);
28744 wxPyEndAllowThreads(__tstate);
28745 if (PyErr_Occurred()) SWIG_fail;
28746 }
28747 resultobj = SWIG_Py_Void();
28748 return resultobj;
28749 fail:
28750 return NULL;
28751 }
28752
28753
28754 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28755 PyObject *resultobj = 0;
28756 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28757 bool result;
28758 void *argp1 = 0 ;
28759 int res1 = 0 ;
28760 PyObject *swig_obj[1] ;
28761
28762 if (!args) SWIG_fail;
28763 swig_obj[0] = args;
28764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28765 if (!SWIG_IsOK(res1)) {
28766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28767 }
28768 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28769 {
28770 PyThreadState* __tstate = wxPyBeginAllowThreads();
28771 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28772 wxPyEndAllowThreads(__tstate);
28773 if (PyErr_Occurred()) SWIG_fail;
28774 }
28775 {
28776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28777 }
28778 return resultobj;
28779 fail:
28780 return NULL;
28781 }
28782
28783
28784 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28785 PyObject *resultobj = 0;
28786 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28787 bool arg2 ;
28788 void *argp1 = 0 ;
28789 int res1 = 0 ;
28790 bool val2 ;
28791 int ecode2 = 0 ;
28792 PyObject * obj0 = 0 ;
28793 PyObject * obj1 = 0 ;
28794 char * kwnames[] = {
28795 (char *) "self",(char *) "ischange", NULL
28796 };
28797
28798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28800 if (!SWIG_IsOK(res1)) {
28801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28802 }
28803 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28804 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28805 if (!SWIG_IsOK(ecode2)) {
28806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28807 }
28808 arg2 = static_cast< bool >(val2);
28809 {
28810 PyThreadState* __tstate = wxPyBeginAllowThreads();
28811 (arg1)->SetWindowChange(arg2);
28812 wxPyEndAllowThreads(__tstate);
28813 if (PyErr_Occurred()) SWIG_fail;
28814 }
28815 resultobj = SWIG_Py_Void();
28816 return resultobj;
28817 fail:
28818 return NULL;
28819 }
28820
28821
28822 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28823 PyObject *resultobj = 0;
28824 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28825 bool result;
28826 void *argp1 = 0 ;
28827 int res1 = 0 ;
28828 PyObject *swig_obj[1] ;
28829
28830 if (!args) SWIG_fail;
28831 swig_obj[0] = args;
28832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28833 if (!SWIG_IsOK(res1)) {
28834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28835 }
28836 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28837 {
28838 PyThreadState* __tstate = wxPyBeginAllowThreads();
28839 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28840 wxPyEndAllowThreads(__tstate);
28841 if (PyErr_Occurred()) SWIG_fail;
28842 }
28843 {
28844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28845 }
28846 return resultobj;
28847 fail:
28848 return NULL;
28849 }
28850
28851
28852 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28853 PyObject *resultobj = 0;
28854 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28855 bool arg2 ;
28856 void *argp1 = 0 ;
28857 int res1 = 0 ;
28858 bool val2 ;
28859 int ecode2 = 0 ;
28860 PyObject * obj0 = 0 ;
28861 PyObject * obj1 = 0 ;
28862 char * kwnames[] = {
28863 (char *) "self",(char *) "bIs", NULL
28864 };
28865
28866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28868 if (!SWIG_IsOK(res1)) {
28869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28870 }
28871 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28872 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28873 if (!SWIG_IsOK(ecode2)) {
28874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28875 }
28876 arg2 = static_cast< bool >(val2);
28877 {
28878 PyThreadState* __tstate = wxPyBeginAllowThreads();
28879 (arg1)->SetFromTab(arg2);
28880 wxPyEndAllowThreads(__tstate);
28881 if (PyErr_Occurred()) SWIG_fail;
28882 }
28883 resultobj = SWIG_Py_Void();
28884 return resultobj;
28885 fail:
28886 return NULL;
28887 }
28888
28889
28890 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28891 PyObject *resultobj = 0;
28892 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28893 long arg2 ;
28894 void *argp1 = 0 ;
28895 int res1 = 0 ;
28896 long val2 ;
28897 int ecode2 = 0 ;
28898 PyObject * obj0 = 0 ;
28899 PyObject * obj1 = 0 ;
28900 char * kwnames[] = {
28901 (char *) "self",(char *) "flags", NULL
28902 };
28903
28904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28906 if (!SWIG_IsOK(res1)) {
28907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28908 }
28909 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28910 ecode2 = SWIG_AsVal_long(obj1, &val2);
28911 if (!SWIG_IsOK(ecode2)) {
28912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28913 }
28914 arg2 = static_cast< long >(val2);
28915 {
28916 PyThreadState* __tstate = wxPyBeginAllowThreads();
28917 (arg1)->SetFlags(arg2);
28918 wxPyEndAllowThreads(__tstate);
28919 if (PyErr_Occurred()) SWIG_fail;
28920 }
28921 resultobj = SWIG_Py_Void();
28922 return resultobj;
28923 fail:
28924 return NULL;
28925 }
28926
28927
28928 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28929 PyObject *resultobj = 0;
28930 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28931 wxWindow *result = 0 ;
28932 void *argp1 = 0 ;
28933 int res1 = 0 ;
28934 PyObject *swig_obj[1] ;
28935
28936 if (!args) SWIG_fail;
28937 swig_obj[0] = args;
28938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28939 if (!SWIG_IsOK(res1)) {
28940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28941 }
28942 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28943 {
28944 PyThreadState* __tstate = wxPyBeginAllowThreads();
28945 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
28946 wxPyEndAllowThreads(__tstate);
28947 if (PyErr_Occurred()) SWIG_fail;
28948 }
28949 {
28950 resultobj = wxPyMake_wxObject(result, (bool)0);
28951 }
28952 return resultobj;
28953 fail:
28954 return NULL;
28955 }
28956
28957
28958 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28959 PyObject *resultobj = 0;
28960 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28961 wxWindow *arg2 = (wxWindow *) 0 ;
28962 void *argp1 = 0 ;
28963 int res1 = 0 ;
28964 void *argp2 = 0 ;
28965 int res2 = 0 ;
28966 PyObject * obj0 = 0 ;
28967 PyObject * obj1 = 0 ;
28968 char * kwnames[] = {
28969 (char *) "self",(char *) "win", NULL
28970 };
28971
28972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
28973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28974 if (!SWIG_IsOK(res1)) {
28975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28976 }
28977 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28978 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28979 if (!SWIG_IsOK(res2)) {
28980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
28981 }
28982 arg2 = reinterpret_cast< wxWindow * >(argp2);
28983 {
28984 PyThreadState* __tstate = wxPyBeginAllowThreads();
28985 (arg1)->SetCurrentFocus(arg2);
28986 wxPyEndAllowThreads(__tstate);
28987 if (PyErr_Occurred()) SWIG_fail;
28988 }
28989 resultobj = SWIG_Py_Void();
28990 return resultobj;
28991 fail:
28992 return NULL;
28993 }
28994
28995
28996 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28997 PyObject *obj;
28998 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28999 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
29000 return SWIG_Py_Void();
29001 }
29002
29003 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29004 return SWIG_Python_InitShadowInstance(args);
29005 }
29006
29007 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29008 PyObject *resultobj = 0;
29009 wxWindow *arg1 = (wxWindow *) NULL ;
29010 wxWindowCreateEvent *result = 0 ;
29011 void *argp1 = 0 ;
29012 int res1 = 0 ;
29013 PyObject * obj0 = 0 ;
29014 char * kwnames[] = {
29015 (char *) "win", NULL
29016 };
29017
29018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
29019 if (obj0) {
29020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29021 if (!SWIG_IsOK(res1)) {
29022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29023 }
29024 arg1 = reinterpret_cast< wxWindow * >(argp1);
29025 }
29026 {
29027 PyThreadState* __tstate = wxPyBeginAllowThreads();
29028 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29029 wxPyEndAllowThreads(__tstate);
29030 if (PyErr_Occurred()) SWIG_fail;
29031 }
29032 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29033 return resultobj;
29034 fail:
29035 return NULL;
29036 }
29037
29038
29039 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29040 PyObject *resultobj = 0;
29041 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29042 wxWindow *result = 0 ;
29043 void *argp1 = 0 ;
29044 int res1 = 0 ;
29045 PyObject *swig_obj[1] ;
29046
29047 if (!args) SWIG_fail;
29048 swig_obj[0] = args;
29049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29050 if (!SWIG_IsOK(res1)) {
29051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29052 }
29053 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29054 {
29055 PyThreadState* __tstate = wxPyBeginAllowThreads();
29056 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29057 wxPyEndAllowThreads(__tstate);
29058 if (PyErr_Occurred()) SWIG_fail;
29059 }
29060 {
29061 resultobj = wxPyMake_wxObject(result, (bool)0);
29062 }
29063 return resultobj;
29064 fail:
29065 return NULL;
29066 }
29067
29068
29069 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29070 PyObject *obj;
29071 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29072 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29073 return SWIG_Py_Void();
29074 }
29075
29076 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29077 return SWIG_Python_InitShadowInstance(args);
29078 }
29079
29080 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29081 PyObject *resultobj = 0;
29082 wxWindow *arg1 = (wxWindow *) NULL ;
29083 wxWindowDestroyEvent *result = 0 ;
29084 void *argp1 = 0 ;
29085 int res1 = 0 ;
29086 PyObject * obj0 = 0 ;
29087 char * kwnames[] = {
29088 (char *) "win", NULL
29089 };
29090
29091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29092 if (obj0) {
29093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29094 if (!SWIG_IsOK(res1)) {
29095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29096 }
29097 arg1 = reinterpret_cast< wxWindow * >(argp1);
29098 }
29099 {
29100 PyThreadState* __tstate = wxPyBeginAllowThreads();
29101 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29102 wxPyEndAllowThreads(__tstate);
29103 if (PyErr_Occurred()) SWIG_fail;
29104 }
29105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29106 return resultobj;
29107 fail:
29108 return NULL;
29109 }
29110
29111
29112 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29113 PyObject *resultobj = 0;
29114 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29115 wxWindow *result = 0 ;
29116 void *argp1 = 0 ;
29117 int res1 = 0 ;
29118 PyObject *swig_obj[1] ;
29119
29120 if (!args) SWIG_fail;
29121 swig_obj[0] = args;
29122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29123 if (!SWIG_IsOK(res1)) {
29124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29125 }
29126 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29127 {
29128 PyThreadState* __tstate = wxPyBeginAllowThreads();
29129 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29130 wxPyEndAllowThreads(__tstate);
29131 if (PyErr_Occurred()) SWIG_fail;
29132 }
29133 {
29134 resultobj = wxPyMake_wxObject(result, (bool)0);
29135 }
29136 return resultobj;
29137 fail:
29138 return NULL;
29139 }
29140
29141
29142 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29143 PyObject *obj;
29144 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29145 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29146 return SWIG_Py_Void();
29147 }
29148
29149 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29150 return SWIG_Python_InitShadowInstance(args);
29151 }
29152
29153 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29154 PyObject *resultobj = 0;
29155 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29156 int arg2 = (int) 0 ;
29157 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29158 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29159 wxContextMenuEvent *result = 0 ;
29160 int val1 ;
29161 int ecode1 = 0 ;
29162 int val2 ;
29163 int ecode2 = 0 ;
29164 wxPoint temp3 ;
29165 PyObject * obj0 = 0 ;
29166 PyObject * obj1 = 0 ;
29167 PyObject * obj2 = 0 ;
29168 char * kwnames[] = {
29169 (char *) "type",(char *) "winid",(char *) "pt", NULL
29170 };
29171
29172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29173 if (obj0) {
29174 ecode1 = SWIG_AsVal_int(obj0, &val1);
29175 if (!SWIG_IsOK(ecode1)) {
29176 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29177 }
29178 arg1 = static_cast< wxEventType >(val1);
29179 }
29180 if (obj1) {
29181 ecode2 = SWIG_AsVal_int(obj1, &val2);
29182 if (!SWIG_IsOK(ecode2)) {
29183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29184 }
29185 arg2 = static_cast< int >(val2);
29186 }
29187 if (obj2) {
29188 {
29189 arg3 = &temp3;
29190 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29191 }
29192 }
29193 {
29194 PyThreadState* __tstate = wxPyBeginAllowThreads();
29195 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29196 wxPyEndAllowThreads(__tstate);
29197 if (PyErr_Occurred()) SWIG_fail;
29198 }
29199 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29200 return resultobj;
29201 fail:
29202 return NULL;
29203 }
29204
29205
29206 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29207 PyObject *resultobj = 0;
29208 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29209 wxPoint *result = 0 ;
29210 void *argp1 = 0 ;
29211 int res1 = 0 ;
29212 PyObject *swig_obj[1] ;
29213
29214 if (!args) SWIG_fail;
29215 swig_obj[0] = args;
29216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29217 if (!SWIG_IsOK(res1)) {
29218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29219 }
29220 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29221 {
29222 PyThreadState* __tstate = wxPyBeginAllowThreads();
29223 {
29224 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29225 result = (wxPoint *) &_result_ref;
29226 }
29227 wxPyEndAllowThreads(__tstate);
29228 if (PyErr_Occurred()) SWIG_fail;
29229 }
29230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29231 return resultobj;
29232 fail:
29233 return NULL;
29234 }
29235
29236
29237 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29238 PyObject *resultobj = 0;
29239 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29240 wxPoint *arg2 = 0 ;
29241 void *argp1 = 0 ;
29242 int res1 = 0 ;
29243 wxPoint temp2 ;
29244 PyObject * obj0 = 0 ;
29245 PyObject * obj1 = 0 ;
29246 char * kwnames[] = {
29247 (char *) "self",(char *) "pos", NULL
29248 };
29249
29250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29252 if (!SWIG_IsOK(res1)) {
29253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29254 }
29255 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29256 {
29257 arg2 = &temp2;
29258 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29259 }
29260 {
29261 PyThreadState* __tstate = wxPyBeginAllowThreads();
29262 (arg1)->SetPosition((wxPoint const &)*arg2);
29263 wxPyEndAllowThreads(__tstate);
29264 if (PyErr_Occurred()) SWIG_fail;
29265 }
29266 resultobj = SWIG_Py_Void();
29267 return resultobj;
29268 fail:
29269 return NULL;
29270 }
29271
29272
29273 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29274 PyObject *obj;
29275 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29276 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29277 return SWIG_Py_Void();
29278 }
29279
29280 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29281 return SWIG_Python_InitShadowInstance(args);
29282 }
29283
29284 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29285 PyObject *resultobj = 0;
29286 wxIdleEvent *result = 0 ;
29287
29288 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29289 {
29290 PyThreadState* __tstate = wxPyBeginAllowThreads();
29291 result = (wxIdleEvent *)new wxIdleEvent();
29292 wxPyEndAllowThreads(__tstate);
29293 if (PyErr_Occurred()) SWIG_fail;
29294 }
29295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29296 return resultobj;
29297 fail:
29298 return NULL;
29299 }
29300
29301
29302 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29303 PyObject *resultobj = 0;
29304 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29305 bool arg2 = (bool) true ;
29306 void *argp1 = 0 ;
29307 int res1 = 0 ;
29308 bool val2 ;
29309 int ecode2 = 0 ;
29310 PyObject * obj0 = 0 ;
29311 PyObject * obj1 = 0 ;
29312 char * kwnames[] = {
29313 (char *) "self",(char *) "needMore", NULL
29314 };
29315
29316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29318 if (!SWIG_IsOK(res1)) {
29319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29320 }
29321 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29322 if (obj1) {
29323 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29324 if (!SWIG_IsOK(ecode2)) {
29325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29326 }
29327 arg2 = static_cast< bool >(val2);
29328 }
29329 {
29330 PyThreadState* __tstate = wxPyBeginAllowThreads();
29331 (arg1)->RequestMore(arg2);
29332 wxPyEndAllowThreads(__tstate);
29333 if (PyErr_Occurred()) SWIG_fail;
29334 }
29335 resultobj = SWIG_Py_Void();
29336 return resultobj;
29337 fail:
29338 return NULL;
29339 }
29340
29341
29342 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29343 PyObject *resultobj = 0;
29344 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29345 bool result;
29346 void *argp1 = 0 ;
29347 int res1 = 0 ;
29348 PyObject *swig_obj[1] ;
29349
29350 if (!args) SWIG_fail;
29351 swig_obj[0] = args;
29352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29353 if (!SWIG_IsOK(res1)) {
29354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29355 }
29356 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29357 {
29358 PyThreadState* __tstate = wxPyBeginAllowThreads();
29359 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29360 wxPyEndAllowThreads(__tstate);
29361 if (PyErr_Occurred()) SWIG_fail;
29362 }
29363 {
29364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29365 }
29366 return resultobj;
29367 fail:
29368 return NULL;
29369 }
29370
29371
29372 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29373 PyObject *resultobj = 0;
29374 wxIdleMode arg1 ;
29375 int val1 ;
29376 int ecode1 = 0 ;
29377 PyObject * obj0 = 0 ;
29378 char * kwnames[] = {
29379 (char *) "mode", NULL
29380 };
29381
29382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29383 ecode1 = SWIG_AsVal_int(obj0, &val1);
29384 if (!SWIG_IsOK(ecode1)) {
29385 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29386 }
29387 arg1 = static_cast< wxIdleMode >(val1);
29388 {
29389 PyThreadState* __tstate = wxPyBeginAllowThreads();
29390 wxIdleEvent::SetMode(arg1);
29391 wxPyEndAllowThreads(__tstate);
29392 if (PyErr_Occurred()) SWIG_fail;
29393 }
29394 resultobj = SWIG_Py_Void();
29395 return resultobj;
29396 fail:
29397 return NULL;
29398 }
29399
29400
29401 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29402 PyObject *resultobj = 0;
29403 wxIdleMode result;
29404
29405 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29406 {
29407 PyThreadState* __tstate = wxPyBeginAllowThreads();
29408 result = (wxIdleMode)wxIdleEvent::GetMode();
29409 wxPyEndAllowThreads(__tstate);
29410 if (PyErr_Occurred()) SWIG_fail;
29411 }
29412 resultobj = SWIG_From_int(static_cast< int >(result));
29413 return resultobj;
29414 fail:
29415 return NULL;
29416 }
29417
29418
29419 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29420 PyObject *resultobj = 0;
29421 wxWindow *arg1 = (wxWindow *) 0 ;
29422 bool result;
29423 void *argp1 = 0 ;
29424 int res1 = 0 ;
29425 PyObject * obj0 = 0 ;
29426 char * kwnames[] = {
29427 (char *) "win", NULL
29428 };
29429
29430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29432 if (!SWIG_IsOK(res1)) {
29433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29434 }
29435 arg1 = reinterpret_cast< wxWindow * >(argp1);
29436 {
29437 PyThreadState* __tstate = wxPyBeginAllowThreads();
29438 result = (bool)wxIdleEvent::CanSend(arg1);
29439 wxPyEndAllowThreads(__tstate);
29440 if (PyErr_Occurred()) SWIG_fail;
29441 }
29442 {
29443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29444 }
29445 return resultobj;
29446 fail:
29447 return NULL;
29448 }
29449
29450
29451 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29452 PyObject *obj;
29453 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29454 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29455 return SWIG_Py_Void();
29456 }
29457
29458 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29459 return SWIG_Python_InitShadowInstance(args);
29460 }
29461
29462 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29463 PyObject *resultobj = 0;
29464 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29465 int arg2 = (int) 0 ;
29466 wxClipboardTextEvent *result = 0 ;
29467 int val1 ;
29468 int ecode1 = 0 ;
29469 int val2 ;
29470 int ecode2 = 0 ;
29471 PyObject * obj0 = 0 ;
29472 PyObject * obj1 = 0 ;
29473 char * kwnames[] = {
29474 (char *) "type",(char *) "winid", NULL
29475 };
29476
29477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29478 if (obj0) {
29479 ecode1 = SWIG_AsVal_int(obj0, &val1);
29480 if (!SWIG_IsOK(ecode1)) {
29481 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29482 }
29483 arg1 = static_cast< wxEventType >(val1);
29484 }
29485 if (obj1) {
29486 ecode2 = SWIG_AsVal_int(obj1, &val2);
29487 if (!SWIG_IsOK(ecode2)) {
29488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29489 }
29490 arg2 = static_cast< int >(val2);
29491 }
29492 {
29493 PyThreadState* __tstate = wxPyBeginAllowThreads();
29494 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29495 wxPyEndAllowThreads(__tstate);
29496 if (PyErr_Occurred()) SWIG_fail;
29497 }
29498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29499 return resultobj;
29500 fail:
29501 return NULL;
29502 }
29503
29504
29505 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29506 PyObject *obj;
29507 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29508 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29509 return SWIG_Py_Void();
29510 }
29511
29512 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29513 return SWIG_Python_InitShadowInstance(args);
29514 }
29515
29516 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29517 PyObject *resultobj = 0;
29518 int arg1 = (int) 0 ;
29519 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29520 wxPyEvent *result = 0 ;
29521 int val1 ;
29522 int ecode1 = 0 ;
29523 int val2 ;
29524 int ecode2 = 0 ;
29525 PyObject * obj0 = 0 ;
29526 PyObject * obj1 = 0 ;
29527 char * kwnames[] = {
29528 (char *) "winid",(char *) "eventType", NULL
29529 };
29530
29531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29532 if (obj0) {
29533 ecode1 = SWIG_AsVal_int(obj0, &val1);
29534 if (!SWIG_IsOK(ecode1)) {
29535 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29536 }
29537 arg1 = static_cast< int >(val1);
29538 }
29539 if (obj1) {
29540 ecode2 = SWIG_AsVal_int(obj1, &val2);
29541 if (!SWIG_IsOK(ecode2)) {
29542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29543 }
29544 arg2 = static_cast< wxEventType >(val2);
29545 }
29546 {
29547 PyThreadState* __tstate = wxPyBeginAllowThreads();
29548 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29549 wxPyEndAllowThreads(__tstate);
29550 if (PyErr_Occurred()) SWIG_fail;
29551 }
29552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29553 return resultobj;
29554 fail:
29555 return NULL;
29556 }
29557
29558
29559 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29560 PyObject *resultobj = 0;
29561 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29562 void *argp1 = 0 ;
29563 int res1 = 0 ;
29564 PyObject *swig_obj[1] ;
29565
29566 if (!args) SWIG_fail;
29567 swig_obj[0] = args;
29568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29569 if (!SWIG_IsOK(res1)) {
29570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29571 }
29572 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29573 {
29574 PyThreadState* __tstate = wxPyBeginAllowThreads();
29575 delete arg1;
29576
29577 wxPyEndAllowThreads(__tstate);
29578 if (PyErr_Occurred()) SWIG_fail;
29579 }
29580 resultobj = SWIG_Py_Void();
29581 return resultobj;
29582 fail:
29583 return NULL;
29584 }
29585
29586
29587 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29588 PyObject *resultobj = 0;
29589 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29590 PyObject *arg2 = (PyObject *) 0 ;
29591 void *argp1 = 0 ;
29592 int res1 = 0 ;
29593 PyObject * obj0 = 0 ;
29594 PyObject * obj1 = 0 ;
29595 char * kwnames[] = {
29596 (char *) "self",(char *) "self", NULL
29597 };
29598
29599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29601 if (!SWIG_IsOK(res1)) {
29602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29603 }
29604 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29605 arg2 = obj1;
29606 {
29607 PyThreadState* __tstate = wxPyBeginAllowThreads();
29608 (arg1)->SetSelf(arg2);
29609 wxPyEndAllowThreads(__tstate);
29610 if (PyErr_Occurred()) SWIG_fail;
29611 }
29612 resultobj = SWIG_Py_Void();
29613 return resultobj;
29614 fail:
29615 return NULL;
29616 }
29617
29618
29619 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29620 PyObject *resultobj = 0;
29621 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29622 PyObject *result = 0 ;
29623 void *argp1 = 0 ;
29624 int res1 = 0 ;
29625 PyObject *swig_obj[1] ;
29626
29627 if (!args) SWIG_fail;
29628 swig_obj[0] = args;
29629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29630 if (!SWIG_IsOK(res1)) {
29631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29632 }
29633 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29634 {
29635 PyThreadState* __tstate = wxPyBeginAllowThreads();
29636 result = (PyObject *)(arg1)->GetSelf();
29637 wxPyEndAllowThreads(__tstate);
29638 if (PyErr_Occurred()) SWIG_fail;
29639 }
29640 resultobj = result;
29641 return resultobj;
29642 fail:
29643 return NULL;
29644 }
29645
29646
29647 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29648 PyObject *obj;
29649 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29650 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29651 return SWIG_Py_Void();
29652 }
29653
29654 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29655 return SWIG_Python_InitShadowInstance(args);
29656 }
29657
29658 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29659 PyObject *resultobj = 0;
29660 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29661 int arg2 = (int) 0 ;
29662 wxPyCommandEvent *result = 0 ;
29663 int val1 ;
29664 int ecode1 = 0 ;
29665 int val2 ;
29666 int ecode2 = 0 ;
29667 PyObject * obj0 = 0 ;
29668 PyObject * obj1 = 0 ;
29669 char * kwnames[] = {
29670 (char *) "eventType",(char *) "id", NULL
29671 };
29672
29673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29674 if (obj0) {
29675 ecode1 = SWIG_AsVal_int(obj0, &val1);
29676 if (!SWIG_IsOK(ecode1)) {
29677 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29678 }
29679 arg1 = static_cast< wxEventType >(val1);
29680 }
29681 if (obj1) {
29682 ecode2 = SWIG_AsVal_int(obj1, &val2);
29683 if (!SWIG_IsOK(ecode2)) {
29684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29685 }
29686 arg2 = static_cast< int >(val2);
29687 }
29688 {
29689 PyThreadState* __tstate = wxPyBeginAllowThreads();
29690 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29691 wxPyEndAllowThreads(__tstate);
29692 if (PyErr_Occurred()) SWIG_fail;
29693 }
29694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29695 return resultobj;
29696 fail:
29697 return NULL;
29698 }
29699
29700
29701 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29702 PyObject *resultobj = 0;
29703 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29704 void *argp1 = 0 ;
29705 int res1 = 0 ;
29706 PyObject *swig_obj[1] ;
29707
29708 if (!args) SWIG_fail;
29709 swig_obj[0] = args;
29710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29711 if (!SWIG_IsOK(res1)) {
29712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29713 }
29714 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29715 {
29716 PyThreadState* __tstate = wxPyBeginAllowThreads();
29717 delete arg1;
29718
29719 wxPyEndAllowThreads(__tstate);
29720 if (PyErr_Occurred()) SWIG_fail;
29721 }
29722 resultobj = SWIG_Py_Void();
29723 return resultobj;
29724 fail:
29725 return NULL;
29726 }
29727
29728
29729 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29730 PyObject *resultobj = 0;
29731 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29732 PyObject *arg2 = (PyObject *) 0 ;
29733 void *argp1 = 0 ;
29734 int res1 = 0 ;
29735 PyObject * obj0 = 0 ;
29736 PyObject * obj1 = 0 ;
29737 char * kwnames[] = {
29738 (char *) "self",(char *) "self", NULL
29739 };
29740
29741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29743 if (!SWIG_IsOK(res1)) {
29744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29745 }
29746 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29747 arg2 = obj1;
29748 {
29749 PyThreadState* __tstate = wxPyBeginAllowThreads();
29750 (arg1)->SetSelf(arg2);
29751 wxPyEndAllowThreads(__tstate);
29752 if (PyErr_Occurred()) SWIG_fail;
29753 }
29754 resultobj = SWIG_Py_Void();
29755 return resultobj;
29756 fail:
29757 return NULL;
29758 }
29759
29760
29761 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29762 PyObject *resultobj = 0;
29763 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29764 PyObject *result = 0 ;
29765 void *argp1 = 0 ;
29766 int res1 = 0 ;
29767 PyObject *swig_obj[1] ;
29768
29769 if (!args) SWIG_fail;
29770 swig_obj[0] = args;
29771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29772 if (!SWIG_IsOK(res1)) {
29773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29774 }
29775 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29776 {
29777 PyThreadState* __tstate = wxPyBeginAllowThreads();
29778 result = (PyObject *)(arg1)->GetSelf();
29779 wxPyEndAllowThreads(__tstate);
29780 if (PyErr_Occurred()) SWIG_fail;
29781 }
29782 resultobj = result;
29783 return resultobj;
29784 fail:
29785 return NULL;
29786 }
29787
29788
29789 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29790 PyObject *obj;
29791 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29792 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29793 return SWIG_Py_Void();
29794 }
29795
29796 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29797 return SWIG_Python_InitShadowInstance(args);
29798 }
29799
29800 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29801 PyObject *resultobj = 0;
29802 wxWindow *arg1 = (wxWindow *) 0 ;
29803 wxDateTime *arg2 = 0 ;
29804 wxEventType arg3 ;
29805 wxDateEvent *result = 0 ;
29806 void *argp1 = 0 ;
29807 int res1 = 0 ;
29808 void *argp2 = 0 ;
29809 int res2 = 0 ;
29810 int val3 ;
29811 int ecode3 = 0 ;
29812 PyObject * obj0 = 0 ;
29813 PyObject * obj1 = 0 ;
29814 PyObject * obj2 = 0 ;
29815 char * kwnames[] = {
29816 (char *) "win",(char *) "dt",(char *) "type", NULL
29817 };
29818
29819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29821 if (!SWIG_IsOK(res1)) {
29822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29823 }
29824 arg1 = reinterpret_cast< wxWindow * >(argp1);
29825 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29826 if (!SWIG_IsOK(res2)) {
29827 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29828 }
29829 if (!argp2) {
29830 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29831 }
29832 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29833 ecode3 = SWIG_AsVal_int(obj2, &val3);
29834 if (!SWIG_IsOK(ecode3)) {
29835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29836 }
29837 arg3 = static_cast< wxEventType >(val3);
29838 {
29839 PyThreadState* __tstate = wxPyBeginAllowThreads();
29840 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29841 wxPyEndAllowThreads(__tstate);
29842 if (PyErr_Occurred()) SWIG_fail;
29843 }
29844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29845 return resultobj;
29846 fail:
29847 return NULL;
29848 }
29849
29850
29851 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29852 PyObject *resultobj = 0;
29853 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29854 wxDateTime *result = 0 ;
29855 void *argp1 = 0 ;
29856 int res1 = 0 ;
29857 PyObject *swig_obj[1] ;
29858
29859 if (!args) SWIG_fail;
29860 swig_obj[0] = args;
29861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29862 if (!SWIG_IsOK(res1)) {
29863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29864 }
29865 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29866 {
29867 PyThreadState* __tstate = wxPyBeginAllowThreads();
29868 {
29869 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29870 result = (wxDateTime *) &_result_ref;
29871 }
29872 wxPyEndAllowThreads(__tstate);
29873 if (PyErr_Occurred()) SWIG_fail;
29874 }
29875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29876 return resultobj;
29877 fail:
29878 return NULL;
29879 }
29880
29881
29882 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29883 PyObject *resultobj = 0;
29884 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29885 wxDateTime *arg2 = 0 ;
29886 void *argp1 = 0 ;
29887 int res1 = 0 ;
29888 void *argp2 = 0 ;
29889 int res2 = 0 ;
29890 PyObject * obj0 = 0 ;
29891 PyObject * obj1 = 0 ;
29892 char * kwnames[] = {
29893 (char *) "self",(char *) "date", NULL
29894 };
29895
29896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29898 if (!SWIG_IsOK(res1)) {
29899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29900 }
29901 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29902 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29903 if (!SWIG_IsOK(res2)) {
29904 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29905 }
29906 if (!argp2) {
29907 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29908 }
29909 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29910 {
29911 PyThreadState* __tstate = wxPyBeginAllowThreads();
29912 (arg1)->SetDate((wxDateTime const &)*arg2);
29913 wxPyEndAllowThreads(__tstate);
29914 if (PyErr_Occurred()) SWIG_fail;
29915 }
29916 resultobj = SWIG_Py_Void();
29917 return resultobj;
29918 fail:
29919 return NULL;
29920 }
29921
29922
29923 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29924 PyObject *obj;
29925 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29926 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
29927 return SWIG_Py_Void();
29928 }
29929
29930 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29931 return SWIG_Python_InitShadowInstance(args);
29932 }
29933
29934 SWIGINTERN PyObject *_wrap_new_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29935 PyObject *resultobj = 0;
29936 wxWindow *arg1 = (wxWindow *) 0 ;
29937 wxEventType arg2 = (wxEventType) wxEVT_ANY ;
29938 wxEventBlocker *result = 0 ;
29939 void *argp1 = 0 ;
29940 int res1 = 0 ;
29941 int val2 ;
29942 int ecode2 = 0 ;
29943 PyObject * obj0 = 0 ;
29944 PyObject * obj1 = 0 ;
29945 char * kwnames[] = {
29946 (char *) "win",(char *) "type", NULL
29947 };
29948
29949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_EventBlocker",kwnames,&obj0,&obj1)) SWIG_fail;
29950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29951 if (!SWIG_IsOK(res1)) {
29952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventBlocker" "', expected argument " "1"" of type '" "wxWindow *""'");
29953 }
29954 arg1 = reinterpret_cast< wxWindow * >(argp1);
29955 if (obj1) {
29956 ecode2 = SWIG_AsVal_int(obj1, &val2);
29957 if (!SWIG_IsOK(ecode2)) {
29958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EventBlocker" "', expected argument " "2"" of type '" "wxEventType""'");
29959 }
29960 arg2 = static_cast< wxEventType >(val2);
29961 }
29962 {
29963 PyThreadState* __tstate = wxPyBeginAllowThreads();
29964 result = (wxEventBlocker *)new wxEventBlocker(arg1,arg2);
29965 wxPyEndAllowThreads(__tstate);
29966 if (PyErr_Occurred()) SWIG_fail;
29967 }
29968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_NEW | 0 );
29969 return resultobj;
29970 fail:
29971 return NULL;
29972 }
29973
29974
29975 SWIGINTERN PyObject *_wrap_delete_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29976 PyObject *resultobj = 0;
29977 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
29978 void *argp1 = 0 ;
29979 int res1 = 0 ;
29980 PyObject *swig_obj[1] ;
29981
29982 if (!args) SWIG_fail;
29983 swig_obj[0] = args;
29984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_DISOWN | 0 );
29985 if (!SWIG_IsOK(res1)) {
29986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventBlocker" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
29987 }
29988 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
29989 {
29990 PyThreadState* __tstate = wxPyBeginAllowThreads();
29991 delete arg1;
29992
29993 wxPyEndAllowThreads(__tstate);
29994 if (PyErr_Occurred()) SWIG_fail;
29995 }
29996 resultobj = SWIG_Py_Void();
29997 return resultobj;
29998 fail:
29999 return NULL;
30000 }
30001
30002
30003 SWIGINTERN PyObject *_wrap_EventBlocker_Block(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30004 PyObject *resultobj = 0;
30005 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30006 wxEventType arg2 ;
30007 void *argp1 = 0 ;
30008 int res1 = 0 ;
30009 int val2 ;
30010 int ecode2 = 0 ;
30011 PyObject * obj0 = 0 ;
30012 PyObject * obj1 = 0 ;
30013 char * kwnames[] = {
30014 (char *) "self",(char *) "type", NULL
30015 };
30016
30017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EventBlocker_Block",kwnames,&obj0,&obj1)) SWIG_fail;
30018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventBlocker, 0 | 0 );
30019 if (!SWIG_IsOK(res1)) {
30020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventBlocker_Block" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30021 }
30022 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30023 ecode2 = SWIG_AsVal_int(obj1, &val2);
30024 if (!SWIG_IsOK(ecode2)) {
30025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventBlocker_Block" "', expected argument " "2"" of type '" "wxEventType""'");
30026 }
30027 arg2 = static_cast< wxEventType >(val2);
30028 {
30029 PyThreadState* __tstate = wxPyBeginAllowThreads();
30030 (arg1)->Block(arg2);
30031 wxPyEndAllowThreads(__tstate);
30032 if (PyErr_Occurred()) SWIG_fail;
30033 }
30034 resultobj = SWIG_Py_Void();
30035 return resultobj;
30036 fail:
30037 return NULL;
30038 }
30039
30040
30041 SWIGINTERN PyObject *EventBlocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30042 PyObject *obj;
30043 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30044 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventBlocker, SWIG_NewClientData(obj));
30045 return SWIG_Py_Void();
30046 }
30047
30048 SWIGINTERN PyObject *EventBlocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30049 return SWIG_Python_InitShadowInstance(args);
30050 }
30051
30052 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30053 PyObject *resultobj = 0;
30054 wxPyApp *result = 0 ;
30055
30056 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
30057 {
30058 PyThreadState* __tstate = wxPyBeginAllowThreads();
30059 result = (wxPyApp *)new_wxPyApp();
30060 wxPyEndAllowThreads(__tstate);
30061 if (PyErr_Occurred()) SWIG_fail;
30062 }
30063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
30064 return resultobj;
30065 fail:
30066 return NULL;
30067 }
30068
30069
30070 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30071 PyObject *resultobj = 0;
30072 wxPyApp *arg1 = (wxPyApp *) 0 ;
30073 void *argp1 = 0 ;
30074 int res1 = 0 ;
30075 PyObject *swig_obj[1] ;
30076
30077 if (!args) SWIG_fail;
30078 swig_obj[0] = args;
30079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
30080 if (!SWIG_IsOK(res1)) {
30081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
30082 }
30083 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30084 {
30085 PyThreadState* __tstate = wxPyBeginAllowThreads();
30086 delete arg1;
30087
30088 wxPyEndAllowThreads(__tstate);
30089 if (PyErr_Occurred()) SWIG_fail;
30090 }
30091 resultobj = SWIG_Py_Void();
30092 return resultobj;
30093 fail:
30094 return NULL;
30095 }
30096
30097
30098 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30099 PyObject *resultobj = 0;
30100 wxPyApp *arg1 = (wxPyApp *) 0 ;
30101 PyObject *arg2 = (PyObject *) 0 ;
30102 PyObject *arg3 = (PyObject *) 0 ;
30103 bool arg4 = (bool) false ;
30104 void *argp1 = 0 ;
30105 int res1 = 0 ;
30106 bool val4 ;
30107 int ecode4 = 0 ;
30108 PyObject * obj0 = 0 ;
30109 PyObject * obj1 = 0 ;
30110 PyObject * obj2 = 0 ;
30111 PyObject * obj3 = 0 ;
30112 char * kwnames[] = {
30113 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
30114 };
30115
30116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30118 if (!SWIG_IsOK(res1)) {
30119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
30120 }
30121 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30122 arg2 = obj1;
30123 arg3 = obj2;
30124 if (obj3) {
30125 ecode4 = SWIG_AsVal_bool(obj3, &val4);
30126 if (!SWIG_IsOK(ecode4)) {
30127 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
30128 }
30129 arg4 = static_cast< bool >(val4);
30130 }
30131 {
30132 PyThreadState* __tstate = wxPyBeginAllowThreads();
30133 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
30134 wxPyEndAllowThreads(__tstate);
30135 if (PyErr_Occurred()) SWIG_fail;
30136 }
30137 resultobj = SWIG_Py_Void();
30138 return resultobj;
30139 fail:
30140 return NULL;
30141 }
30142
30143
30144 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30145 PyObject *resultobj = 0;
30146 wxPyApp *arg1 = (wxPyApp *) 0 ;
30147 wxString result;
30148 void *argp1 = 0 ;
30149 int res1 = 0 ;
30150 PyObject *swig_obj[1] ;
30151
30152 if (!args) SWIG_fail;
30153 swig_obj[0] = args;
30154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30155 if (!SWIG_IsOK(res1)) {
30156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30157 }
30158 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30159 {
30160 PyThreadState* __tstate = wxPyBeginAllowThreads();
30161 result = ((wxPyApp const *)arg1)->GetAppName();
30162 wxPyEndAllowThreads(__tstate);
30163 if (PyErr_Occurred()) SWIG_fail;
30164 }
30165 {
30166 #if wxUSE_UNICODE
30167 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30168 #else
30169 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30170 #endif
30171 }
30172 return resultobj;
30173 fail:
30174 return NULL;
30175 }
30176
30177
30178 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30179 PyObject *resultobj = 0;
30180 wxPyApp *arg1 = (wxPyApp *) 0 ;
30181 wxString *arg2 = 0 ;
30182 void *argp1 = 0 ;
30183 int res1 = 0 ;
30184 bool temp2 = false ;
30185 PyObject * obj0 = 0 ;
30186 PyObject * obj1 = 0 ;
30187 char * kwnames[] = {
30188 (char *) "self",(char *) "name", NULL
30189 };
30190
30191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30193 if (!SWIG_IsOK(res1)) {
30194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30195 }
30196 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30197 {
30198 arg2 = wxString_in_helper(obj1);
30199 if (arg2 == NULL) SWIG_fail;
30200 temp2 = true;
30201 }
30202 {
30203 PyThreadState* __tstate = wxPyBeginAllowThreads();
30204 (arg1)->SetAppName((wxString const &)*arg2);
30205 wxPyEndAllowThreads(__tstate);
30206 if (PyErr_Occurred()) SWIG_fail;
30207 }
30208 resultobj = SWIG_Py_Void();
30209 {
30210 if (temp2)
30211 delete arg2;
30212 }
30213 return resultobj;
30214 fail:
30215 {
30216 if (temp2)
30217 delete arg2;
30218 }
30219 return NULL;
30220 }
30221
30222
30223 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30224 PyObject *resultobj = 0;
30225 wxPyApp *arg1 = (wxPyApp *) 0 ;
30226 wxString result;
30227 void *argp1 = 0 ;
30228 int res1 = 0 ;
30229 PyObject *swig_obj[1] ;
30230
30231 if (!args) SWIG_fail;
30232 swig_obj[0] = args;
30233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30234 if (!SWIG_IsOK(res1)) {
30235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30236 }
30237 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30238 {
30239 PyThreadState* __tstate = wxPyBeginAllowThreads();
30240 result = ((wxPyApp const *)arg1)->GetClassName();
30241 wxPyEndAllowThreads(__tstate);
30242 if (PyErr_Occurred()) SWIG_fail;
30243 }
30244 {
30245 #if wxUSE_UNICODE
30246 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30247 #else
30248 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30249 #endif
30250 }
30251 return resultobj;
30252 fail:
30253 return NULL;
30254 }
30255
30256
30257 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30258 PyObject *resultobj = 0;
30259 wxPyApp *arg1 = (wxPyApp *) 0 ;
30260 wxString *arg2 = 0 ;
30261 void *argp1 = 0 ;
30262 int res1 = 0 ;
30263 bool temp2 = false ;
30264 PyObject * obj0 = 0 ;
30265 PyObject * obj1 = 0 ;
30266 char * kwnames[] = {
30267 (char *) "self",(char *) "name", NULL
30268 };
30269
30270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30272 if (!SWIG_IsOK(res1)) {
30273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30274 }
30275 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30276 {
30277 arg2 = wxString_in_helper(obj1);
30278 if (arg2 == NULL) SWIG_fail;
30279 temp2 = true;
30280 }
30281 {
30282 PyThreadState* __tstate = wxPyBeginAllowThreads();
30283 (arg1)->SetClassName((wxString const &)*arg2);
30284 wxPyEndAllowThreads(__tstate);
30285 if (PyErr_Occurred()) SWIG_fail;
30286 }
30287 resultobj = SWIG_Py_Void();
30288 {
30289 if (temp2)
30290 delete arg2;
30291 }
30292 return resultobj;
30293 fail:
30294 {
30295 if (temp2)
30296 delete arg2;
30297 }
30298 return NULL;
30299 }
30300
30301
30302 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30303 PyObject *resultobj = 0;
30304 wxPyApp *arg1 = (wxPyApp *) 0 ;
30305 wxString *result = 0 ;
30306 void *argp1 = 0 ;
30307 int res1 = 0 ;
30308 PyObject *swig_obj[1] ;
30309
30310 if (!args) SWIG_fail;
30311 swig_obj[0] = args;
30312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30313 if (!SWIG_IsOK(res1)) {
30314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30315 }
30316 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30317 {
30318 PyThreadState* __tstate = wxPyBeginAllowThreads();
30319 {
30320 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30321 result = (wxString *) &_result_ref;
30322 }
30323 wxPyEndAllowThreads(__tstate);
30324 if (PyErr_Occurred()) SWIG_fail;
30325 }
30326 {
30327 #if wxUSE_UNICODE
30328 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30329 #else
30330 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30331 #endif
30332 }
30333 return resultobj;
30334 fail:
30335 return NULL;
30336 }
30337
30338
30339 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30340 PyObject *resultobj = 0;
30341 wxPyApp *arg1 = (wxPyApp *) 0 ;
30342 wxString *arg2 = 0 ;
30343 void *argp1 = 0 ;
30344 int res1 = 0 ;
30345 bool temp2 = false ;
30346 PyObject * obj0 = 0 ;
30347 PyObject * obj1 = 0 ;
30348 char * kwnames[] = {
30349 (char *) "self",(char *) "name", NULL
30350 };
30351
30352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30354 if (!SWIG_IsOK(res1)) {
30355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30356 }
30357 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30358 {
30359 arg2 = wxString_in_helper(obj1);
30360 if (arg2 == NULL) SWIG_fail;
30361 temp2 = true;
30362 }
30363 {
30364 PyThreadState* __tstate = wxPyBeginAllowThreads();
30365 (arg1)->SetVendorName((wxString const &)*arg2);
30366 wxPyEndAllowThreads(__tstate);
30367 if (PyErr_Occurred()) SWIG_fail;
30368 }
30369 resultobj = SWIG_Py_Void();
30370 {
30371 if (temp2)
30372 delete arg2;
30373 }
30374 return resultobj;
30375 fail:
30376 {
30377 if (temp2)
30378 delete arg2;
30379 }
30380 return NULL;
30381 }
30382
30383
30384 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30385 PyObject *resultobj = 0;
30386 wxPyApp *arg1 = (wxPyApp *) 0 ;
30387 wxAppTraits *result = 0 ;
30388 void *argp1 = 0 ;
30389 int res1 = 0 ;
30390 PyObject *swig_obj[1] ;
30391
30392 if (!args) SWIG_fail;
30393 swig_obj[0] = args;
30394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30395 if (!SWIG_IsOK(res1)) {
30396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30397 }
30398 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30399 {
30400 PyThreadState* __tstate = wxPyBeginAllowThreads();
30401 result = (wxAppTraits *)(arg1)->GetTraits();
30402 wxPyEndAllowThreads(__tstate);
30403 if (PyErr_Occurred()) SWIG_fail;
30404 }
30405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30406 return resultobj;
30407 fail:
30408 return NULL;
30409 }
30410
30411
30412 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30413 PyObject *resultobj = 0;
30414 wxPyApp *arg1 = (wxPyApp *) 0 ;
30415 void *argp1 = 0 ;
30416 int res1 = 0 ;
30417 PyObject *swig_obj[1] ;
30418
30419 if (!args) SWIG_fail;
30420 swig_obj[0] = args;
30421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30422 if (!SWIG_IsOK(res1)) {
30423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30424 }
30425 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30426 {
30427 PyThreadState* __tstate = wxPyBeginAllowThreads();
30428 (arg1)->ProcessPendingEvents();
30429 wxPyEndAllowThreads(__tstate);
30430 if (PyErr_Occurred()) SWIG_fail;
30431 }
30432 resultobj = SWIG_Py_Void();
30433 return resultobj;
30434 fail:
30435 return NULL;
30436 }
30437
30438
30439 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30440 PyObject *resultobj = 0;
30441 wxPyApp *arg1 = (wxPyApp *) 0 ;
30442 bool arg2 = (bool) false ;
30443 bool result;
30444 void *argp1 = 0 ;
30445 int res1 = 0 ;
30446 bool val2 ;
30447 int ecode2 = 0 ;
30448 PyObject * obj0 = 0 ;
30449 PyObject * obj1 = 0 ;
30450 char * kwnames[] = {
30451 (char *) "self",(char *) "onlyIfNeeded", NULL
30452 };
30453
30454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30456 if (!SWIG_IsOK(res1)) {
30457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30458 }
30459 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30460 if (obj1) {
30461 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30462 if (!SWIG_IsOK(ecode2)) {
30463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30464 }
30465 arg2 = static_cast< bool >(val2);
30466 }
30467 {
30468 PyThreadState* __tstate = wxPyBeginAllowThreads();
30469 result = (bool)(arg1)->Yield(arg2);
30470 wxPyEndAllowThreads(__tstate);
30471 if (PyErr_Occurred()) SWIG_fail;
30472 }
30473 {
30474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30475 }
30476 return resultobj;
30477 fail:
30478 return NULL;
30479 }
30480
30481
30482 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30483 PyObject *resultobj = 0;
30484 wxPyApp *arg1 = (wxPyApp *) 0 ;
30485 void *argp1 = 0 ;
30486 int res1 = 0 ;
30487 PyObject *swig_obj[1] ;
30488
30489 if (!args) SWIG_fail;
30490 swig_obj[0] = args;
30491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30492 if (!SWIG_IsOK(res1)) {
30493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30494 }
30495 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30496 {
30497 PyThreadState* __tstate = wxPyBeginAllowThreads();
30498 (arg1)->WakeUpIdle();
30499 wxPyEndAllowThreads(__tstate);
30500 if (PyErr_Occurred()) SWIG_fail;
30501 }
30502 resultobj = SWIG_Py_Void();
30503 return resultobj;
30504 fail:
30505 return NULL;
30506 }
30507
30508
30509 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30510 PyObject *resultobj = 0;
30511 bool result;
30512
30513 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30514 {
30515 PyThreadState* __tstate = wxPyBeginAllowThreads();
30516 result = (bool)wxPyApp::IsMainLoopRunning();
30517 wxPyEndAllowThreads(__tstate);
30518 if (PyErr_Occurred()) SWIG_fail;
30519 }
30520 {
30521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30522 }
30523 return resultobj;
30524 fail:
30525 return NULL;
30526 }
30527
30528
30529 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30530 PyObject *resultobj = 0;
30531 wxPyApp *arg1 = (wxPyApp *) 0 ;
30532 int result;
30533 void *argp1 = 0 ;
30534 int res1 = 0 ;
30535 PyObject *swig_obj[1] ;
30536
30537 if (!args) SWIG_fail;
30538 swig_obj[0] = args;
30539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30540 if (!SWIG_IsOK(res1)) {
30541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30542 }
30543 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30544 {
30545 PyThreadState* __tstate = wxPyBeginAllowThreads();
30546 result = (int)(arg1)->MainLoop();
30547 wxPyEndAllowThreads(__tstate);
30548 if (PyErr_Occurred()) SWIG_fail;
30549 }
30550 resultobj = SWIG_From_int(static_cast< int >(result));
30551 return resultobj;
30552 fail:
30553 return NULL;
30554 }
30555
30556
30557 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30558 PyObject *resultobj = 0;
30559 wxPyApp *arg1 = (wxPyApp *) 0 ;
30560 void *argp1 = 0 ;
30561 int res1 = 0 ;
30562 PyObject *swig_obj[1] ;
30563
30564 if (!args) SWIG_fail;
30565 swig_obj[0] = args;
30566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30567 if (!SWIG_IsOK(res1)) {
30568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30569 }
30570 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30571 {
30572 PyThreadState* __tstate = wxPyBeginAllowThreads();
30573 (arg1)->Exit();
30574 wxPyEndAllowThreads(__tstate);
30575 if (PyErr_Occurred()) SWIG_fail;
30576 }
30577 resultobj = SWIG_Py_Void();
30578 return resultobj;
30579 fail:
30580 return NULL;
30581 }
30582
30583
30584 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30585 PyObject *resultobj = 0;
30586 wxPyApp *arg1 = (wxPyApp *) 0 ;
30587 wxLayoutDirection result;
30588 void *argp1 = 0 ;
30589 int res1 = 0 ;
30590 PyObject *swig_obj[1] ;
30591
30592 if (!args) SWIG_fail;
30593 swig_obj[0] = args;
30594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30595 if (!SWIG_IsOK(res1)) {
30596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30597 }
30598 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30599 {
30600 PyThreadState* __tstate = wxPyBeginAllowThreads();
30601 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30602 wxPyEndAllowThreads(__tstate);
30603 if (PyErr_Occurred()) SWIG_fail;
30604 }
30605 resultobj = SWIG_From_int(static_cast< int >(result));
30606 return resultobj;
30607 fail:
30608 return NULL;
30609 }
30610
30611
30612 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30613 PyObject *resultobj = 0;
30614 wxPyApp *arg1 = (wxPyApp *) 0 ;
30615 void *argp1 = 0 ;
30616 int res1 = 0 ;
30617 PyObject *swig_obj[1] ;
30618
30619 if (!args) SWIG_fail;
30620 swig_obj[0] = args;
30621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30622 if (!SWIG_IsOK(res1)) {
30623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30624 }
30625 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30626 {
30627 PyThreadState* __tstate = wxPyBeginAllowThreads();
30628 (arg1)->ExitMainLoop();
30629 wxPyEndAllowThreads(__tstate);
30630 if (PyErr_Occurred()) SWIG_fail;
30631 }
30632 resultobj = SWIG_Py_Void();
30633 return resultobj;
30634 fail:
30635 return NULL;
30636 }
30637
30638
30639 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30640 PyObject *resultobj = 0;
30641 wxPyApp *arg1 = (wxPyApp *) 0 ;
30642 bool result;
30643 void *argp1 = 0 ;
30644 int res1 = 0 ;
30645 PyObject *swig_obj[1] ;
30646
30647 if (!args) SWIG_fail;
30648 swig_obj[0] = args;
30649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30650 if (!SWIG_IsOK(res1)) {
30651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30652 }
30653 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30654 {
30655 PyThreadState* __tstate = wxPyBeginAllowThreads();
30656 result = (bool)(arg1)->Pending();
30657 wxPyEndAllowThreads(__tstate);
30658 if (PyErr_Occurred()) SWIG_fail;
30659 }
30660 {
30661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30662 }
30663 return resultobj;
30664 fail:
30665 return NULL;
30666 }
30667
30668
30669 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30670 PyObject *resultobj = 0;
30671 wxPyApp *arg1 = (wxPyApp *) 0 ;
30672 bool result;
30673 void *argp1 = 0 ;
30674 int res1 = 0 ;
30675 PyObject *swig_obj[1] ;
30676
30677 if (!args) SWIG_fail;
30678 swig_obj[0] = args;
30679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30680 if (!SWIG_IsOK(res1)) {
30681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30682 }
30683 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30684 {
30685 PyThreadState* __tstate = wxPyBeginAllowThreads();
30686 result = (bool)(arg1)->Dispatch();
30687 wxPyEndAllowThreads(__tstate);
30688 if (PyErr_Occurred()) SWIG_fail;
30689 }
30690 {
30691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30692 }
30693 return resultobj;
30694 fail:
30695 return NULL;
30696 }
30697
30698
30699 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30700 PyObject *resultobj = 0;
30701 wxPyApp *arg1 = (wxPyApp *) 0 ;
30702 bool result;
30703 void *argp1 = 0 ;
30704 int res1 = 0 ;
30705 PyObject *swig_obj[1] ;
30706
30707 if (!args) SWIG_fail;
30708 swig_obj[0] = args;
30709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30710 if (!SWIG_IsOK(res1)) {
30711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30712 }
30713 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30714 {
30715 PyThreadState* __tstate = wxPyBeginAllowThreads();
30716 result = (bool)(arg1)->ProcessIdle();
30717 wxPyEndAllowThreads(__tstate);
30718 if (PyErr_Occurred()) SWIG_fail;
30719 }
30720 {
30721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30722 }
30723 return resultobj;
30724 fail:
30725 return NULL;
30726 }
30727
30728
30729 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30730 PyObject *resultobj = 0;
30731 wxPyApp *arg1 = (wxPyApp *) 0 ;
30732 wxWindow *arg2 = (wxWindow *) 0 ;
30733 wxIdleEvent *arg3 = 0 ;
30734 bool result;
30735 void *argp1 = 0 ;
30736 int res1 = 0 ;
30737 void *argp2 = 0 ;
30738 int res2 = 0 ;
30739 void *argp3 = 0 ;
30740 int res3 = 0 ;
30741 PyObject * obj0 = 0 ;
30742 PyObject * obj1 = 0 ;
30743 PyObject * obj2 = 0 ;
30744 char * kwnames[] = {
30745 (char *) "self",(char *) "win",(char *) "event", NULL
30746 };
30747
30748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30750 if (!SWIG_IsOK(res1)) {
30751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30752 }
30753 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30754 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30755 if (!SWIG_IsOK(res2)) {
30756 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30757 }
30758 arg2 = reinterpret_cast< wxWindow * >(argp2);
30759 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30760 if (!SWIG_IsOK(res3)) {
30761 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30762 }
30763 if (!argp3) {
30764 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30765 }
30766 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30767 {
30768 PyThreadState* __tstate = wxPyBeginAllowThreads();
30769 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30770 wxPyEndAllowThreads(__tstate);
30771 if (PyErr_Occurred()) SWIG_fail;
30772 }
30773 {
30774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30775 }
30776 return resultobj;
30777 fail:
30778 return NULL;
30779 }
30780
30781
30782 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30783 PyObject *resultobj = 0;
30784 wxPyApp *arg1 = (wxPyApp *) 0 ;
30785 bool result;
30786 void *argp1 = 0 ;
30787 int res1 = 0 ;
30788 PyObject *swig_obj[1] ;
30789
30790 if (!args) SWIG_fail;
30791 swig_obj[0] = args;
30792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30793 if (!SWIG_IsOK(res1)) {
30794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30795 }
30796 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30797 {
30798 PyThreadState* __tstate = wxPyBeginAllowThreads();
30799 result = (bool)((wxPyApp const *)arg1)->IsActive();
30800 wxPyEndAllowThreads(__tstate);
30801 if (PyErr_Occurred()) SWIG_fail;
30802 }
30803 {
30804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30805 }
30806 return resultobj;
30807 fail:
30808 return NULL;
30809 }
30810
30811
30812 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30813 PyObject *resultobj = 0;
30814 wxPyApp *arg1 = (wxPyApp *) 0 ;
30815 wxWindow *arg2 = (wxWindow *) 0 ;
30816 void *argp1 = 0 ;
30817 int res1 = 0 ;
30818 void *argp2 = 0 ;
30819 int res2 = 0 ;
30820 PyObject * obj0 = 0 ;
30821 PyObject * obj1 = 0 ;
30822 char * kwnames[] = {
30823 (char *) "self",(char *) "win", NULL
30824 };
30825
30826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30828 if (!SWIG_IsOK(res1)) {
30829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30830 }
30831 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30832 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30833 if (!SWIG_IsOK(res2)) {
30834 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30835 }
30836 arg2 = reinterpret_cast< wxWindow * >(argp2);
30837 {
30838 PyThreadState* __tstate = wxPyBeginAllowThreads();
30839 (arg1)->SetTopWindow(arg2);
30840 wxPyEndAllowThreads(__tstate);
30841 if (PyErr_Occurred()) SWIG_fail;
30842 }
30843 resultobj = SWIG_Py_Void();
30844 return resultobj;
30845 fail:
30846 return NULL;
30847 }
30848
30849
30850 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30851 PyObject *resultobj = 0;
30852 wxPyApp *arg1 = (wxPyApp *) 0 ;
30853 wxWindow *result = 0 ;
30854 void *argp1 = 0 ;
30855 int res1 = 0 ;
30856 PyObject *swig_obj[1] ;
30857
30858 if (!args) SWIG_fail;
30859 swig_obj[0] = args;
30860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30861 if (!SWIG_IsOK(res1)) {
30862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30863 }
30864 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30865 {
30866 PyThreadState* __tstate = wxPyBeginAllowThreads();
30867 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30868 wxPyEndAllowThreads(__tstate);
30869 if (PyErr_Occurred()) SWIG_fail;
30870 }
30871 {
30872 resultobj = wxPyMake_wxObject(result, (bool)0);
30873 }
30874 return resultobj;
30875 fail:
30876 return NULL;
30877 }
30878
30879
30880 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30881 PyObject *resultobj = 0;
30882 wxPyApp *arg1 = (wxPyApp *) 0 ;
30883 bool arg2 ;
30884 void *argp1 = 0 ;
30885 int res1 = 0 ;
30886 bool val2 ;
30887 int ecode2 = 0 ;
30888 PyObject * obj0 = 0 ;
30889 PyObject * obj1 = 0 ;
30890 char * kwnames[] = {
30891 (char *) "self",(char *) "flag", NULL
30892 };
30893
30894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30896 if (!SWIG_IsOK(res1)) {
30897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30898 }
30899 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30900 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30901 if (!SWIG_IsOK(ecode2)) {
30902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30903 }
30904 arg2 = static_cast< bool >(val2);
30905 {
30906 PyThreadState* __tstate = wxPyBeginAllowThreads();
30907 (arg1)->SetExitOnFrameDelete(arg2);
30908 wxPyEndAllowThreads(__tstate);
30909 if (PyErr_Occurred()) SWIG_fail;
30910 }
30911 resultobj = SWIG_Py_Void();
30912 return resultobj;
30913 fail:
30914 return NULL;
30915 }
30916
30917
30918 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30919 PyObject *resultobj = 0;
30920 wxPyApp *arg1 = (wxPyApp *) 0 ;
30921 bool result;
30922 void *argp1 = 0 ;
30923 int res1 = 0 ;
30924 PyObject *swig_obj[1] ;
30925
30926 if (!args) SWIG_fail;
30927 swig_obj[0] = args;
30928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30929 if (!SWIG_IsOK(res1)) {
30930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30931 }
30932 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30933 {
30934 PyThreadState* __tstate = wxPyBeginAllowThreads();
30935 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30936 wxPyEndAllowThreads(__tstate);
30937 if (PyErr_Occurred()) SWIG_fail;
30938 }
30939 {
30940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30941 }
30942 return resultobj;
30943 fail:
30944 return NULL;
30945 }
30946
30947
30948 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30949 PyObject *resultobj = 0;
30950 wxPyApp *arg1 = (wxPyApp *) 0 ;
30951 bool arg2 ;
30952 bool arg3 = (bool) false ;
30953 void *argp1 = 0 ;
30954 int res1 = 0 ;
30955 bool val2 ;
30956 int ecode2 = 0 ;
30957 bool val3 ;
30958 int ecode3 = 0 ;
30959 PyObject * obj0 = 0 ;
30960 PyObject * obj1 = 0 ;
30961 PyObject * obj2 = 0 ;
30962 char * kwnames[] = {
30963 (char *) "self",(char *) "flag",(char *) "forceTrueColour", NULL
30964 };
30965
30966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30968 if (!SWIG_IsOK(res1)) {
30969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
30970 }
30971 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30972 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30973 if (!SWIG_IsOK(ecode2)) {
30974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
30975 }
30976 arg2 = static_cast< bool >(val2);
30977 if (obj2) {
30978 ecode3 = SWIG_AsVal_bool(obj2, &val3);
30979 if (!SWIG_IsOK(ecode3)) {
30980 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "3"" of type '" "bool""'");
30981 }
30982 arg3 = static_cast< bool >(val3);
30983 }
30984 {
30985 PyThreadState* __tstate = wxPyBeginAllowThreads();
30986 (arg1)->SetUseBestVisual(arg2,arg3);
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_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30998 PyObject *resultobj = 0;
30999 wxPyApp *arg1 = (wxPyApp *) 0 ;
31000 bool 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_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31010 }
31011 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31012 {
31013 PyThreadState* __tstate = wxPyBeginAllowThreads();
31014 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
31015 wxPyEndAllowThreads(__tstate);
31016 if (PyErr_Occurred()) SWIG_fail;
31017 }
31018 {
31019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31020 }
31021 return resultobj;
31022 fail:
31023 return NULL;
31024 }
31025
31026
31027 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31028 PyObject *resultobj = 0;
31029 wxPyApp *arg1 = (wxPyApp *) 0 ;
31030 int arg2 ;
31031 void *argp1 = 0 ;
31032 int res1 = 0 ;
31033 int val2 ;
31034 int ecode2 = 0 ;
31035 PyObject * obj0 = 0 ;
31036 PyObject * obj1 = 0 ;
31037 char * kwnames[] = {
31038 (char *) "self",(char *) "mode", NULL
31039 };
31040
31041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
31042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31043 if (!SWIG_IsOK(res1)) {
31044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31045 }
31046 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31047 ecode2 = SWIG_AsVal_int(obj1, &val2);
31048 if (!SWIG_IsOK(ecode2)) {
31049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
31050 }
31051 arg2 = static_cast< int >(val2);
31052 {
31053 PyThreadState* __tstate = wxPyBeginAllowThreads();
31054 (arg1)->SetPrintMode(arg2);
31055 wxPyEndAllowThreads(__tstate);
31056 if (PyErr_Occurred()) SWIG_fail;
31057 }
31058 resultobj = SWIG_Py_Void();
31059 return resultobj;
31060 fail:
31061 return NULL;
31062 }
31063
31064
31065 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31066 PyObject *resultobj = 0;
31067 wxPyApp *arg1 = (wxPyApp *) 0 ;
31068 int result;
31069 void *argp1 = 0 ;
31070 int res1 = 0 ;
31071 PyObject *swig_obj[1] ;
31072
31073 if (!args) SWIG_fail;
31074 swig_obj[0] = args;
31075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31076 if (!SWIG_IsOK(res1)) {
31077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31078 }
31079 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31080 {
31081 PyThreadState* __tstate = wxPyBeginAllowThreads();
31082 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
31083 wxPyEndAllowThreads(__tstate);
31084 if (PyErr_Occurred()) SWIG_fail;
31085 }
31086 resultobj = SWIG_From_int(static_cast< int >(result));
31087 return resultobj;
31088 fail:
31089 return NULL;
31090 }
31091
31092
31093 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31094 PyObject *resultobj = 0;
31095 wxPyApp *arg1 = (wxPyApp *) 0 ;
31096 int arg2 ;
31097 void *argp1 = 0 ;
31098 int res1 = 0 ;
31099 int val2 ;
31100 int ecode2 = 0 ;
31101 PyObject * obj0 = 0 ;
31102 PyObject * obj1 = 0 ;
31103 char * kwnames[] = {
31104 (char *) "self",(char *) "mode", NULL
31105 };
31106
31107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
31108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31109 if (!SWIG_IsOK(res1)) {
31110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31111 }
31112 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31113 ecode2 = SWIG_AsVal_int(obj1, &val2);
31114 if (!SWIG_IsOK(ecode2)) {
31115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
31116 }
31117 arg2 = static_cast< int >(val2);
31118 {
31119 PyThreadState* __tstate = wxPyBeginAllowThreads();
31120 (arg1)->SetAssertMode(arg2);
31121 wxPyEndAllowThreads(__tstate);
31122 if (PyErr_Occurred()) SWIG_fail;
31123 }
31124 resultobj = SWIG_Py_Void();
31125 return resultobj;
31126 fail:
31127 return NULL;
31128 }
31129
31130
31131 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31132 PyObject *resultobj = 0;
31133 wxPyApp *arg1 = (wxPyApp *) 0 ;
31134 int result;
31135 void *argp1 = 0 ;
31136 int res1 = 0 ;
31137 PyObject *swig_obj[1] ;
31138
31139 if (!args) SWIG_fail;
31140 swig_obj[0] = args;
31141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31142 if (!SWIG_IsOK(res1)) {
31143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31144 }
31145 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31146 {
31147 PyThreadState* __tstate = wxPyBeginAllowThreads();
31148 result = (int)(arg1)->GetAssertMode();
31149 wxPyEndAllowThreads(__tstate);
31150 if (PyErr_Occurred()) SWIG_fail;
31151 }
31152 resultobj = SWIG_From_int(static_cast< int >(result));
31153 return resultobj;
31154 fail:
31155 return NULL;
31156 }
31157
31158
31159 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31160 PyObject *resultobj = 0;
31161 bool result;
31162
31163 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31164 {
31165 PyThreadState* __tstate = wxPyBeginAllowThreads();
31166 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31167 wxPyEndAllowThreads(__tstate);
31168 if (PyErr_Occurred()) SWIG_fail;
31169 }
31170 {
31171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31172 }
31173 return resultobj;
31174 fail:
31175 return NULL;
31176 }
31177
31178
31179 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31180 PyObject *resultobj = 0;
31181 long result;
31182
31183 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31184 {
31185 PyThreadState* __tstate = wxPyBeginAllowThreads();
31186 result = (long)wxPyApp::GetMacAboutMenuItemId();
31187 wxPyEndAllowThreads(__tstate);
31188 if (PyErr_Occurred()) SWIG_fail;
31189 }
31190 resultobj = SWIG_From_long(static_cast< long >(result));
31191 return resultobj;
31192 fail:
31193 return NULL;
31194 }
31195
31196
31197 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31198 PyObject *resultobj = 0;
31199 long result;
31200
31201 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31202 {
31203 PyThreadState* __tstate = wxPyBeginAllowThreads();
31204 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31205 wxPyEndAllowThreads(__tstate);
31206 if (PyErr_Occurred()) SWIG_fail;
31207 }
31208 resultobj = SWIG_From_long(static_cast< long >(result));
31209 return resultobj;
31210 fail:
31211 return NULL;
31212 }
31213
31214
31215 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31216 PyObject *resultobj = 0;
31217 long result;
31218
31219 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31220 {
31221 PyThreadState* __tstate = wxPyBeginAllowThreads();
31222 result = (long)wxPyApp::GetMacExitMenuItemId();
31223 wxPyEndAllowThreads(__tstate);
31224 if (PyErr_Occurred()) SWIG_fail;
31225 }
31226 resultobj = SWIG_From_long(static_cast< long >(result));
31227 return resultobj;
31228 fail:
31229 return NULL;
31230 }
31231
31232
31233 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31234 PyObject *resultobj = 0;
31235 wxString result;
31236
31237 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31238 {
31239 PyThreadState* __tstate = wxPyBeginAllowThreads();
31240 result = wxPyApp::GetMacHelpMenuTitleName();
31241 wxPyEndAllowThreads(__tstate);
31242 if (PyErr_Occurred()) SWIG_fail;
31243 }
31244 {
31245 #if wxUSE_UNICODE
31246 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31247 #else
31248 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31249 #endif
31250 }
31251 return resultobj;
31252 fail:
31253 return NULL;
31254 }
31255
31256
31257 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31258 PyObject *resultobj = 0;
31259 bool arg1 ;
31260 bool val1 ;
31261 int ecode1 = 0 ;
31262 PyObject * obj0 = 0 ;
31263 char * kwnames[] = {
31264 (char *) "val", NULL
31265 };
31266
31267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31268 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31269 if (!SWIG_IsOK(ecode1)) {
31270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31271 }
31272 arg1 = static_cast< bool >(val1);
31273 {
31274 PyThreadState* __tstate = wxPyBeginAllowThreads();
31275 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31276 wxPyEndAllowThreads(__tstate);
31277 if (PyErr_Occurred()) SWIG_fail;
31278 }
31279 resultobj = SWIG_Py_Void();
31280 return resultobj;
31281 fail:
31282 return NULL;
31283 }
31284
31285
31286 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31287 PyObject *resultobj = 0;
31288 long arg1 ;
31289 long val1 ;
31290 int ecode1 = 0 ;
31291 PyObject * obj0 = 0 ;
31292 char * kwnames[] = {
31293 (char *) "val", NULL
31294 };
31295
31296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31297 ecode1 = SWIG_AsVal_long(obj0, &val1);
31298 if (!SWIG_IsOK(ecode1)) {
31299 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31300 }
31301 arg1 = static_cast< long >(val1);
31302 {
31303 PyThreadState* __tstate = wxPyBeginAllowThreads();
31304 wxPyApp::SetMacAboutMenuItemId(arg1);
31305 wxPyEndAllowThreads(__tstate);
31306 if (PyErr_Occurred()) SWIG_fail;
31307 }
31308 resultobj = SWIG_Py_Void();
31309 return resultobj;
31310 fail:
31311 return NULL;
31312 }
31313
31314
31315 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31316 PyObject *resultobj = 0;
31317 long arg1 ;
31318 long val1 ;
31319 int ecode1 = 0 ;
31320 PyObject * obj0 = 0 ;
31321 char * kwnames[] = {
31322 (char *) "val", NULL
31323 };
31324
31325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31326 ecode1 = SWIG_AsVal_long(obj0, &val1);
31327 if (!SWIG_IsOK(ecode1)) {
31328 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31329 }
31330 arg1 = static_cast< long >(val1);
31331 {
31332 PyThreadState* __tstate = wxPyBeginAllowThreads();
31333 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31334 wxPyEndAllowThreads(__tstate);
31335 if (PyErr_Occurred()) SWIG_fail;
31336 }
31337 resultobj = SWIG_Py_Void();
31338 return resultobj;
31339 fail:
31340 return NULL;
31341 }
31342
31343
31344 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31345 PyObject *resultobj = 0;
31346 long arg1 ;
31347 long val1 ;
31348 int ecode1 = 0 ;
31349 PyObject * obj0 = 0 ;
31350 char * kwnames[] = {
31351 (char *) "val", NULL
31352 };
31353
31354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31355 ecode1 = SWIG_AsVal_long(obj0, &val1);
31356 if (!SWIG_IsOK(ecode1)) {
31357 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31358 }
31359 arg1 = static_cast< long >(val1);
31360 {
31361 PyThreadState* __tstate = wxPyBeginAllowThreads();
31362 wxPyApp::SetMacExitMenuItemId(arg1);
31363 wxPyEndAllowThreads(__tstate);
31364 if (PyErr_Occurred()) SWIG_fail;
31365 }
31366 resultobj = SWIG_Py_Void();
31367 return resultobj;
31368 fail:
31369 return NULL;
31370 }
31371
31372
31373 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31374 PyObject *resultobj = 0;
31375 wxString *arg1 = 0 ;
31376 bool temp1 = false ;
31377 PyObject * obj0 = 0 ;
31378 char * kwnames[] = {
31379 (char *) "val", NULL
31380 };
31381
31382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31383 {
31384 arg1 = wxString_in_helper(obj0);
31385 if (arg1 == NULL) SWIG_fail;
31386 temp1 = true;
31387 }
31388 {
31389 PyThreadState* __tstate = wxPyBeginAllowThreads();
31390 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31391 wxPyEndAllowThreads(__tstate);
31392 if (PyErr_Occurred()) SWIG_fail;
31393 }
31394 resultobj = SWIG_Py_Void();
31395 {
31396 if (temp1)
31397 delete arg1;
31398 }
31399 return resultobj;
31400 fail:
31401 {
31402 if (temp1)
31403 delete arg1;
31404 }
31405 return NULL;
31406 }
31407
31408
31409 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31410 PyObject *resultobj = 0;
31411 wxPyApp *arg1 = (wxPyApp *) 0 ;
31412 void *argp1 = 0 ;
31413 int res1 = 0 ;
31414 PyObject *swig_obj[1] ;
31415
31416 if (!args) SWIG_fail;
31417 swig_obj[0] = args;
31418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31419 if (!SWIG_IsOK(res1)) {
31420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31421 }
31422 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31423 {
31424 PyThreadState* __tstate = wxPyBeginAllowThreads();
31425 (arg1)->_BootstrapApp();
31426 wxPyEndAllowThreads(__tstate);
31427 if (PyErr_Occurred()) SWIG_fail;
31428 }
31429 resultobj = SWIG_Py_Void();
31430 return resultobj;
31431 fail:
31432 return NULL;
31433 }
31434
31435
31436 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31437 PyObject *resultobj = 0;
31438 int result;
31439
31440 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31441 {
31442 PyThreadState* __tstate = wxPyBeginAllowThreads();
31443 result = (int)wxPyApp_GetComCtl32Version();
31444 wxPyEndAllowThreads(__tstate);
31445 if (PyErr_Occurred()) SWIG_fail;
31446 }
31447 resultobj = SWIG_From_int(static_cast< int >(result));
31448 return resultobj;
31449 fail:
31450 return NULL;
31451 }
31452
31453
31454 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31455 PyObject *resultobj = 0;
31456 bool result;
31457
31458 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31459 {
31460 PyThreadState* __tstate = wxPyBeginAllowThreads();
31461 result = (bool)wxPyApp_IsDisplayAvailable();
31462 wxPyEndAllowThreads(__tstate);
31463 if (PyErr_Occurred()) SWIG_fail;
31464 }
31465 {
31466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31467 }
31468 return resultobj;
31469 fail:
31470 return NULL;
31471 }
31472
31473
31474 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31475 PyObject *obj;
31476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31477 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31478 return SWIG_Py_Void();
31479 }
31480
31481 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31482 return SWIG_Python_InitShadowInstance(args);
31483 }
31484
31485 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31486 PyObject *resultobj = 0;
31487
31488 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31489 {
31490 PyThreadState* __tstate = wxPyBeginAllowThreads();
31491 wxExit();
31492 wxPyEndAllowThreads(__tstate);
31493 if (PyErr_Occurred()) SWIG_fail;
31494 }
31495 resultobj = SWIG_Py_Void();
31496 return resultobj;
31497 fail:
31498 return NULL;
31499 }
31500
31501
31502 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31503 PyObject *resultobj = 0;
31504 bool result;
31505
31506 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31507 {
31508 PyThreadState* __tstate = wxPyBeginAllowThreads();
31509 result = (bool)wxYield();
31510 wxPyEndAllowThreads(__tstate);
31511 if (PyErr_Occurred()) SWIG_fail;
31512 }
31513 {
31514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31515 }
31516 return resultobj;
31517 fail:
31518 return NULL;
31519 }
31520
31521
31522 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31523 PyObject *resultobj = 0;
31524 bool result;
31525
31526 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31527 {
31528 PyThreadState* __tstate = wxPyBeginAllowThreads();
31529 result = (bool)wxYieldIfNeeded();
31530 wxPyEndAllowThreads(__tstate);
31531 if (PyErr_Occurred()) SWIG_fail;
31532 }
31533 {
31534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31535 }
31536 return resultobj;
31537 fail:
31538 return NULL;
31539 }
31540
31541
31542 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31543 PyObject *resultobj = 0;
31544 wxWindow *arg1 = (wxWindow *) NULL ;
31545 bool arg2 = (bool) false ;
31546 bool result;
31547 void *argp1 = 0 ;
31548 int res1 = 0 ;
31549 bool val2 ;
31550 int ecode2 = 0 ;
31551 PyObject * obj0 = 0 ;
31552 PyObject * obj1 = 0 ;
31553 char * kwnames[] = {
31554 (char *) "win",(char *) "onlyIfNeeded", NULL
31555 };
31556
31557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31558 if (obj0) {
31559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31560 if (!SWIG_IsOK(res1)) {
31561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31562 }
31563 arg1 = reinterpret_cast< wxWindow * >(argp1);
31564 }
31565 if (obj1) {
31566 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31567 if (!SWIG_IsOK(ecode2)) {
31568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31569 }
31570 arg2 = static_cast< bool >(val2);
31571 }
31572 {
31573 PyThreadState* __tstate = wxPyBeginAllowThreads();
31574 result = (bool)wxSafeYield(arg1,arg2);
31575 wxPyEndAllowThreads(__tstate);
31576 if (PyErr_Occurred()) SWIG_fail;
31577 }
31578 {
31579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31580 }
31581 return resultobj;
31582 fail:
31583 return NULL;
31584 }
31585
31586
31587 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31588 PyObject *resultobj = 0;
31589
31590 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31591 {
31592 PyThreadState* __tstate = wxPyBeginAllowThreads();
31593 wxWakeUpIdle();
31594 wxPyEndAllowThreads(__tstate);
31595 if (PyErr_Occurred()) SWIG_fail;
31596 }
31597 resultobj = SWIG_Py_Void();
31598 return resultobj;
31599 fail:
31600 return NULL;
31601 }
31602
31603
31604 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31605 PyObject *resultobj = 0;
31606 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31607 wxEvent *arg2 = 0 ;
31608 void *argp1 = 0 ;
31609 int res1 = 0 ;
31610 void *argp2 = 0 ;
31611 int res2 = 0 ;
31612 PyObject * obj0 = 0 ;
31613 PyObject * obj1 = 0 ;
31614 char * kwnames[] = {
31615 (char *) "dest",(char *) "event", NULL
31616 };
31617
31618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31620 if (!SWIG_IsOK(res1)) {
31621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31622 }
31623 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31624 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31625 if (!SWIG_IsOK(res2)) {
31626 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31627 }
31628 if (!argp2) {
31629 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31630 }
31631 arg2 = reinterpret_cast< wxEvent * >(argp2);
31632 {
31633 PyThreadState* __tstate = wxPyBeginAllowThreads();
31634 wxPostEvent(arg1,*arg2);
31635 wxPyEndAllowThreads(__tstate);
31636 if (PyErr_Occurred()) SWIG_fail;
31637 }
31638 resultobj = SWIG_Py_Void();
31639 return resultobj;
31640 fail:
31641 return NULL;
31642 }
31643
31644
31645 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31646 PyObject *resultobj = 0;
31647
31648 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31649 {
31650 PyThreadState* __tstate = wxPyBeginAllowThreads();
31651 wxApp_CleanUp();
31652 wxPyEndAllowThreads(__tstate);
31653 if (PyErr_Occurred()) SWIG_fail;
31654 }
31655 resultobj = SWIG_Py_Void();
31656 return resultobj;
31657 fail:
31658 return NULL;
31659 }
31660
31661
31662 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31663 PyObject *resultobj = 0;
31664 wxPyApp *result = 0 ;
31665
31666 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31667 {
31668 PyThreadState* __tstate = wxPyBeginAllowThreads();
31669 result = (wxPyApp *)wxPyGetApp();
31670 wxPyEndAllowThreads(__tstate);
31671 if (PyErr_Occurred()) SWIG_fail;
31672 }
31673 {
31674 resultobj = wxPyMake_wxObject(result, 0);
31675 }
31676 return resultobj;
31677 fail:
31678 return NULL;
31679 }
31680
31681
31682 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31683 PyObject *resultobj = 0;
31684 char *arg1 = (char *) 0 ;
31685 int res1 ;
31686 char *buf1 = 0 ;
31687 int alloc1 = 0 ;
31688 PyObject * obj0 = 0 ;
31689 char * kwnames[] = {
31690 (char *) "encoding", NULL
31691 };
31692
31693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31694 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31695 if (!SWIG_IsOK(res1)) {
31696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31697 }
31698 arg1 = buf1;
31699 {
31700 PyThreadState* __tstate = wxPyBeginAllowThreads();
31701 wxSetDefaultPyEncoding((char const *)arg1);
31702 wxPyEndAllowThreads(__tstate);
31703 if (PyErr_Occurred()) SWIG_fail;
31704 }
31705 resultobj = SWIG_Py_Void();
31706 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31707 return resultobj;
31708 fail:
31709 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31710 return NULL;
31711 }
31712
31713
31714 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31715 PyObject *resultobj = 0;
31716 char *result = 0 ;
31717
31718 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31719 {
31720 PyThreadState* __tstate = wxPyBeginAllowThreads();
31721 result = (char *)wxGetDefaultPyEncoding();
31722 wxPyEndAllowThreads(__tstate);
31723 if (PyErr_Occurred()) SWIG_fail;
31724 }
31725 resultobj = SWIG_FromCharPtr(result);
31726 return resultobj;
31727 fail:
31728 return NULL;
31729 }
31730
31731
31732 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31733 PyObject *resultobj = 0;
31734 wxEventLoop *result = 0 ;
31735
31736 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31737 {
31738 PyThreadState* __tstate = wxPyBeginAllowThreads();
31739 result = (wxEventLoop *)new wxEventLoop();
31740 wxPyEndAllowThreads(__tstate);
31741 if (PyErr_Occurred()) SWIG_fail;
31742 }
31743 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31744 return resultobj;
31745 fail:
31746 return NULL;
31747 }
31748
31749
31750 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31751 PyObject *resultobj = 0;
31752 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31753 void *argp1 = 0 ;
31754 int res1 = 0 ;
31755 PyObject *swig_obj[1] ;
31756
31757 if (!args) SWIG_fail;
31758 swig_obj[0] = args;
31759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31760 if (!SWIG_IsOK(res1)) {
31761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31762 }
31763 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31764 {
31765 PyThreadState* __tstate = wxPyBeginAllowThreads();
31766 delete arg1;
31767
31768 wxPyEndAllowThreads(__tstate);
31769 if (PyErr_Occurred()) SWIG_fail;
31770 }
31771 resultobj = SWIG_Py_Void();
31772 return resultobj;
31773 fail:
31774 return NULL;
31775 }
31776
31777
31778 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31779 PyObject *resultobj = 0;
31780 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31781 int result;
31782 void *argp1 = 0 ;
31783 int res1 = 0 ;
31784 PyObject *swig_obj[1] ;
31785
31786 if (!args) SWIG_fail;
31787 swig_obj[0] = args;
31788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31789 if (!SWIG_IsOK(res1)) {
31790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31791 }
31792 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31793 {
31794 PyThreadState* __tstate = wxPyBeginAllowThreads();
31795 result = (int)(arg1)->Run();
31796 wxPyEndAllowThreads(__tstate);
31797 if (PyErr_Occurred()) SWIG_fail;
31798 }
31799 resultobj = SWIG_From_int(static_cast< int >(result));
31800 return resultobj;
31801 fail:
31802 return NULL;
31803 }
31804
31805
31806 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31807 PyObject *resultobj = 0;
31808 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31809 int arg2 = (int) 0 ;
31810 void *argp1 = 0 ;
31811 int res1 = 0 ;
31812 int val2 ;
31813 int ecode2 = 0 ;
31814 PyObject * obj0 = 0 ;
31815 PyObject * obj1 = 0 ;
31816 char * kwnames[] = {
31817 (char *) "self",(char *) "rc", NULL
31818 };
31819
31820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31822 if (!SWIG_IsOK(res1)) {
31823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31824 }
31825 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31826 if (obj1) {
31827 ecode2 = SWIG_AsVal_int(obj1, &val2);
31828 if (!SWIG_IsOK(ecode2)) {
31829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31830 }
31831 arg2 = static_cast< int >(val2);
31832 }
31833 {
31834 PyThreadState* __tstate = wxPyBeginAllowThreads();
31835 (arg1)->Exit(arg2);
31836 wxPyEndAllowThreads(__tstate);
31837 if (PyErr_Occurred()) SWIG_fail;
31838 }
31839 resultobj = SWIG_Py_Void();
31840 return resultobj;
31841 fail:
31842 return NULL;
31843 }
31844
31845
31846 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31847 PyObject *resultobj = 0;
31848 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31849 bool result;
31850 void *argp1 = 0 ;
31851 int res1 = 0 ;
31852 PyObject *swig_obj[1] ;
31853
31854 if (!args) SWIG_fail;
31855 swig_obj[0] = args;
31856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31857 if (!SWIG_IsOK(res1)) {
31858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31859 }
31860 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31861 {
31862 PyThreadState* __tstate = wxPyBeginAllowThreads();
31863 result = (bool)((wxEventLoop const *)arg1)->Pending();
31864 wxPyEndAllowThreads(__tstate);
31865 if (PyErr_Occurred()) SWIG_fail;
31866 }
31867 {
31868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31869 }
31870 return resultobj;
31871 fail:
31872 return NULL;
31873 }
31874
31875
31876 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31877 PyObject *resultobj = 0;
31878 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31879 bool result;
31880 void *argp1 = 0 ;
31881 int res1 = 0 ;
31882 PyObject *swig_obj[1] ;
31883
31884 if (!args) SWIG_fail;
31885 swig_obj[0] = args;
31886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31887 if (!SWIG_IsOK(res1)) {
31888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31889 }
31890 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31891 {
31892 PyThreadState* __tstate = wxPyBeginAllowThreads();
31893 result = (bool)(arg1)->Dispatch();
31894 wxPyEndAllowThreads(__tstate);
31895 if (PyErr_Occurred()) SWIG_fail;
31896 }
31897 {
31898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31899 }
31900 return resultobj;
31901 fail:
31902 return NULL;
31903 }
31904
31905
31906 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31907 PyObject *resultobj = 0;
31908 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31909 bool result;
31910 void *argp1 = 0 ;
31911 int res1 = 0 ;
31912 PyObject *swig_obj[1] ;
31913
31914 if (!args) SWIG_fail;
31915 swig_obj[0] = args;
31916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31917 if (!SWIG_IsOK(res1)) {
31918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31919 }
31920 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31921 {
31922 PyThreadState* __tstate = wxPyBeginAllowThreads();
31923 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31924 wxPyEndAllowThreads(__tstate);
31925 if (PyErr_Occurred()) SWIG_fail;
31926 }
31927 {
31928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31929 }
31930 return resultobj;
31931 fail:
31932 return NULL;
31933 }
31934
31935
31936 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31937 PyObject *resultobj = 0;
31938 wxEventLoop *result = 0 ;
31939
31940 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31941 {
31942 PyThreadState* __tstate = wxPyBeginAllowThreads();
31943 result = (wxEventLoop *)wxEventLoop::GetActive();
31944 wxPyEndAllowThreads(__tstate);
31945 if (PyErr_Occurred()) SWIG_fail;
31946 }
31947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
31948 return resultobj;
31949 fail:
31950 return NULL;
31951 }
31952
31953
31954 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31955 PyObject *resultobj = 0;
31956 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31957 void *argp1 = 0 ;
31958 int res1 = 0 ;
31959 PyObject * obj0 = 0 ;
31960 char * kwnames[] = {
31961 (char *) "loop", NULL
31962 };
31963
31964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
31965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31966 if (!SWIG_IsOK(res1)) {
31967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31968 }
31969 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31970 {
31971 PyThreadState* __tstate = wxPyBeginAllowThreads();
31972 wxEventLoop::SetActive(arg1);
31973 wxPyEndAllowThreads(__tstate);
31974 if (PyErr_Occurred()) SWIG_fail;
31975 }
31976 resultobj = SWIG_Py_Void();
31977 return resultobj;
31978 fail:
31979 return NULL;
31980 }
31981
31982
31983 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31984 PyObject *obj;
31985 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31986 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
31987 return SWIG_Py_Void();
31988 }
31989
31990 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31991 return SWIG_Python_InitShadowInstance(args);
31992 }
31993
31994 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31995 PyObject *resultobj = 0;
31996 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31997 wxEventLoopActivator *result = 0 ;
31998 void *argp1 = 0 ;
31999 int res1 = 0 ;
32000 PyObject * obj0 = 0 ;
32001 char * kwnames[] = {
32002 (char *) "evtLoop", NULL
32003 };
32004
32005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
32006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32007 if (!SWIG_IsOK(res1)) {
32008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32009 }
32010 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32011 {
32012 PyThreadState* __tstate = wxPyBeginAllowThreads();
32013 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
32014 wxPyEndAllowThreads(__tstate);
32015 if (PyErr_Occurred()) SWIG_fail;
32016 }
32017 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
32018 return resultobj;
32019 fail:
32020 return NULL;
32021 }
32022
32023
32024 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32025 PyObject *resultobj = 0;
32026 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
32027 void *argp1 = 0 ;
32028 int res1 = 0 ;
32029 PyObject *swig_obj[1] ;
32030
32031 if (!args) SWIG_fail;
32032 swig_obj[0] = args;
32033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
32034 if (!SWIG_IsOK(res1)) {
32035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
32036 }
32037 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
32038 {
32039 PyThreadState* __tstate = wxPyBeginAllowThreads();
32040 delete arg1;
32041
32042 wxPyEndAllowThreads(__tstate);
32043 if (PyErr_Occurred()) SWIG_fail;
32044 }
32045 resultobj = SWIG_Py_Void();
32046 return resultobj;
32047 fail:
32048 return NULL;
32049 }
32050
32051
32052 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32053 PyObject *obj;
32054 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32055 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
32056 return SWIG_Py_Void();
32057 }
32058
32059 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32060 return SWIG_Python_InitShadowInstance(args);
32061 }
32062
32063 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32064 PyObject *resultobj = 0;
32065 int arg1 = (int) 0 ;
32066 int arg2 = (int) 0 ;
32067 int arg3 = (int) 0 ;
32068 wxAcceleratorEntry *result = 0 ;
32069 int val1 ;
32070 int ecode1 = 0 ;
32071 int val2 ;
32072 int ecode2 = 0 ;
32073 int val3 ;
32074 int ecode3 = 0 ;
32075 PyObject * obj0 = 0 ;
32076 PyObject * obj1 = 0 ;
32077 PyObject * obj2 = 0 ;
32078 char * kwnames[] = {
32079 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
32080 };
32081
32082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32083 if (obj0) {
32084 ecode1 = SWIG_AsVal_int(obj0, &val1);
32085 if (!SWIG_IsOK(ecode1)) {
32086 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
32087 }
32088 arg1 = static_cast< int >(val1);
32089 }
32090 if (obj1) {
32091 ecode2 = SWIG_AsVal_int(obj1, &val2);
32092 if (!SWIG_IsOK(ecode2)) {
32093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
32094 }
32095 arg2 = static_cast< int >(val2);
32096 }
32097 if (obj2) {
32098 ecode3 = SWIG_AsVal_int(obj2, &val3);
32099 if (!SWIG_IsOK(ecode3)) {
32100 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
32101 }
32102 arg3 = static_cast< int >(val3);
32103 }
32104 {
32105 PyThreadState* __tstate = wxPyBeginAllowThreads();
32106 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
32107 wxPyEndAllowThreads(__tstate);
32108 if (PyErr_Occurred()) SWIG_fail;
32109 }
32110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
32111 return resultobj;
32112 fail:
32113 return NULL;
32114 }
32115
32116
32117 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32118 PyObject *resultobj = 0;
32119 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32120 void *argp1 = 0 ;
32121 int res1 = 0 ;
32122 PyObject *swig_obj[1] ;
32123
32124 if (!args) SWIG_fail;
32125 swig_obj[0] = args;
32126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
32127 if (!SWIG_IsOK(res1)) {
32128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32129 }
32130 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32131 {
32132 PyThreadState* __tstate = wxPyBeginAllowThreads();
32133 delete arg1;
32134
32135 wxPyEndAllowThreads(__tstate);
32136 if (PyErr_Occurred()) SWIG_fail;
32137 }
32138 resultobj = SWIG_Py_Void();
32139 return resultobj;
32140 fail:
32141 return NULL;
32142 }
32143
32144
32145 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32146 PyObject *resultobj = 0;
32147 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32148 int arg2 ;
32149 int arg3 ;
32150 int arg4 ;
32151 void *argp1 = 0 ;
32152 int res1 = 0 ;
32153 int val2 ;
32154 int ecode2 = 0 ;
32155 int val3 ;
32156 int ecode3 = 0 ;
32157 int val4 ;
32158 int ecode4 = 0 ;
32159 PyObject * obj0 = 0 ;
32160 PyObject * obj1 = 0 ;
32161 PyObject * obj2 = 0 ;
32162 PyObject * obj3 = 0 ;
32163 char * kwnames[] = {
32164 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32165 };
32166
32167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32169 if (!SWIG_IsOK(res1)) {
32170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32171 }
32172 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32173 ecode2 = SWIG_AsVal_int(obj1, &val2);
32174 if (!SWIG_IsOK(ecode2)) {
32175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32176 }
32177 arg2 = static_cast< int >(val2);
32178 ecode3 = SWIG_AsVal_int(obj2, &val3);
32179 if (!SWIG_IsOK(ecode3)) {
32180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32181 }
32182 arg3 = static_cast< int >(val3);
32183 ecode4 = SWIG_AsVal_int(obj3, &val4);
32184 if (!SWIG_IsOK(ecode4)) {
32185 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32186 }
32187 arg4 = static_cast< int >(val4);
32188 {
32189 PyThreadState* __tstate = wxPyBeginAllowThreads();
32190 (arg1)->Set(arg2,arg3,arg4);
32191 wxPyEndAllowThreads(__tstate);
32192 if (PyErr_Occurred()) SWIG_fail;
32193 }
32194 resultobj = SWIG_Py_Void();
32195 return resultobj;
32196 fail:
32197 return NULL;
32198 }
32199
32200
32201 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32202 PyObject *resultobj = 0;
32203 wxString *arg1 = 0 ;
32204 wxAcceleratorEntry *result = 0 ;
32205 bool temp1 = false ;
32206 PyObject * obj0 = 0 ;
32207 char * kwnames[] = {
32208 (char *) "str", NULL
32209 };
32210
32211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32212 {
32213 arg1 = wxString_in_helper(obj0);
32214 if (arg1 == NULL) SWIG_fail;
32215 temp1 = true;
32216 }
32217 {
32218 PyThreadState* __tstate = wxPyBeginAllowThreads();
32219 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32220 wxPyEndAllowThreads(__tstate);
32221 if (PyErr_Occurred()) SWIG_fail;
32222 }
32223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32224 {
32225 if (temp1)
32226 delete arg1;
32227 }
32228 return resultobj;
32229 fail:
32230 {
32231 if (temp1)
32232 delete arg1;
32233 }
32234 return NULL;
32235 }
32236
32237
32238 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32239 PyObject *resultobj = 0;
32240 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32241 int result;
32242 void *argp1 = 0 ;
32243 int res1 = 0 ;
32244 PyObject *swig_obj[1] ;
32245
32246 if (!args) SWIG_fail;
32247 swig_obj[0] = args;
32248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32249 if (!SWIG_IsOK(res1)) {
32250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32251 }
32252 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32253 {
32254 PyThreadState* __tstate = wxPyBeginAllowThreads();
32255 result = (int)(arg1)->GetFlags();
32256 wxPyEndAllowThreads(__tstate);
32257 if (PyErr_Occurred()) SWIG_fail;
32258 }
32259 resultobj = SWIG_From_int(static_cast< int >(result));
32260 return resultobj;
32261 fail:
32262 return NULL;
32263 }
32264
32265
32266 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32267 PyObject *resultobj = 0;
32268 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32269 int result;
32270 void *argp1 = 0 ;
32271 int res1 = 0 ;
32272 PyObject *swig_obj[1] ;
32273
32274 if (!args) SWIG_fail;
32275 swig_obj[0] = args;
32276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32277 if (!SWIG_IsOK(res1)) {
32278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32279 }
32280 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32281 {
32282 PyThreadState* __tstate = wxPyBeginAllowThreads();
32283 result = (int)(arg1)->GetKeyCode();
32284 wxPyEndAllowThreads(__tstate);
32285 if (PyErr_Occurred()) SWIG_fail;
32286 }
32287 resultobj = SWIG_From_int(static_cast< int >(result));
32288 return resultobj;
32289 fail:
32290 return NULL;
32291 }
32292
32293
32294 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32295 PyObject *resultobj = 0;
32296 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32297 int result;
32298 void *argp1 = 0 ;
32299 int res1 = 0 ;
32300 PyObject *swig_obj[1] ;
32301
32302 if (!args) SWIG_fail;
32303 swig_obj[0] = args;
32304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32305 if (!SWIG_IsOK(res1)) {
32306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32307 }
32308 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32309 {
32310 PyThreadState* __tstate = wxPyBeginAllowThreads();
32311 result = (int)(arg1)->GetCommand();
32312 wxPyEndAllowThreads(__tstate);
32313 if (PyErr_Occurred()) SWIG_fail;
32314 }
32315 resultobj = SWIG_From_int(static_cast< int >(result));
32316 return resultobj;
32317 fail:
32318 return NULL;
32319 }
32320
32321
32322 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32323 PyObject *resultobj = 0;
32324 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32325 bool result;
32326 void *argp1 = 0 ;
32327 int res1 = 0 ;
32328 PyObject *swig_obj[1] ;
32329
32330 if (!args) SWIG_fail;
32331 swig_obj[0] = args;
32332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32333 if (!SWIG_IsOK(res1)) {
32334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32335 }
32336 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32337 {
32338 PyThreadState* __tstate = wxPyBeginAllowThreads();
32339 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32340 wxPyEndAllowThreads(__tstate);
32341 if (PyErr_Occurred()) SWIG_fail;
32342 }
32343 {
32344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32345 }
32346 return resultobj;
32347 fail:
32348 return NULL;
32349 }
32350
32351
32352 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32353 PyObject *resultobj = 0;
32354 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32355 wxString result;
32356 void *argp1 = 0 ;
32357 int res1 = 0 ;
32358 PyObject *swig_obj[1] ;
32359
32360 if (!args) SWIG_fail;
32361 swig_obj[0] = args;
32362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32363 if (!SWIG_IsOK(res1)) {
32364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32365 }
32366 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32367 {
32368 PyThreadState* __tstate = wxPyBeginAllowThreads();
32369 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32370 wxPyEndAllowThreads(__tstate);
32371 if (PyErr_Occurred()) SWIG_fail;
32372 }
32373 {
32374 #if wxUSE_UNICODE
32375 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32376 #else
32377 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32378 #endif
32379 }
32380 return resultobj;
32381 fail:
32382 return NULL;
32383 }
32384
32385
32386 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32387 PyObject *resultobj = 0;
32388 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32389 wxString *arg2 = 0 ;
32390 bool result;
32391 void *argp1 = 0 ;
32392 int res1 = 0 ;
32393 bool temp2 = false ;
32394 PyObject * obj0 = 0 ;
32395 PyObject * obj1 = 0 ;
32396 char * kwnames[] = {
32397 (char *) "self",(char *) "str", NULL
32398 };
32399
32400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32402 if (!SWIG_IsOK(res1)) {
32403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32404 }
32405 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32406 {
32407 arg2 = wxString_in_helper(obj1);
32408 if (arg2 == NULL) SWIG_fail;
32409 temp2 = true;
32410 }
32411 {
32412 PyThreadState* __tstate = wxPyBeginAllowThreads();
32413 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32414 wxPyEndAllowThreads(__tstate);
32415 if (PyErr_Occurred()) SWIG_fail;
32416 }
32417 {
32418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32419 }
32420 {
32421 if (temp2)
32422 delete arg2;
32423 }
32424 return resultobj;
32425 fail:
32426 {
32427 if (temp2)
32428 delete arg2;
32429 }
32430 return NULL;
32431 }
32432
32433
32434 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32435 PyObject *obj;
32436 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32437 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32438 return SWIG_Py_Void();
32439 }
32440
32441 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32442 return SWIG_Python_InitShadowInstance(args);
32443 }
32444
32445 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32446 PyObject *resultobj = 0;
32447 int arg1 ;
32448 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32449 wxAcceleratorTable *result = 0 ;
32450 PyObject * obj0 = 0 ;
32451 char * kwnames[] = {
32452 (char *) "n", NULL
32453 };
32454
32455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32456 {
32457 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32458 if (arg2) arg1 = PyList_Size(obj0);
32459 else arg1 = 0;
32460 }
32461 {
32462 PyThreadState* __tstate = wxPyBeginAllowThreads();
32463 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32464 wxPyEndAllowThreads(__tstate);
32465 if (PyErr_Occurred()) SWIG_fail;
32466 }
32467 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32468 return resultobj;
32469 fail:
32470 return NULL;
32471 }
32472
32473
32474 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32475 PyObject *resultobj = 0;
32476 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32477 void *argp1 = 0 ;
32478 int res1 = 0 ;
32479 PyObject *swig_obj[1] ;
32480
32481 if (!args) SWIG_fail;
32482 swig_obj[0] = args;
32483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32484 if (!SWIG_IsOK(res1)) {
32485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32486 }
32487 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32488 {
32489 PyThreadState* __tstate = wxPyBeginAllowThreads();
32490 delete arg1;
32491
32492 wxPyEndAllowThreads(__tstate);
32493 if (PyErr_Occurred()) SWIG_fail;
32494 }
32495 resultobj = SWIG_Py_Void();
32496 return resultobj;
32497 fail:
32498 return NULL;
32499 }
32500
32501
32502 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32503 PyObject *resultobj = 0;
32504 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32505 bool result;
32506 void *argp1 = 0 ;
32507 int res1 = 0 ;
32508 PyObject *swig_obj[1] ;
32509
32510 if (!args) SWIG_fail;
32511 swig_obj[0] = args;
32512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32513 if (!SWIG_IsOK(res1)) {
32514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32515 }
32516 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32517 {
32518 PyThreadState* __tstate = wxPyBeginAllowThreads();
32519 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32520 wxPyEndAllowThreads(__tstate);
32521 if (PyErr_Occurred()) SWIG_fail;
32522 }
32523 {
32524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32525 }
32526 return resultobj;
32527 fail:
32528 return NULL;
32529 }
32530
32531
32532 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32533 PyObject *obj;
32534 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32535 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32536 return SWIG_Py_Void();
32537 }
32538
32539 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32540 return SWIG_Python_InitShadowInstance(args);
32541 }
32542
32543 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32544 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32545 return 1;
32546 }
32547
32548
32549 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32550 PyObject *pyobj = 0;
32551
32552 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32553 return pyobj;
32554 }
32555
32556
32557 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32558 PyObject *resultobj = 0;
32559 wxString *arg1 = 0 ;
32560 wxAcceleratorEntry *result = 0 ;
32561 bool temp1 = false ;
32562 PyObject * obj0 = 0 ;
32563 char * kwnames[] = {
32564 (char *) "label", NULL
32565 };
32566
32567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
32568 {
32569 arg1 = wxString_in_helper(obj0);
32570 if (arg1 == NULL) SWIG_fail;
32571 temp1 = true;
32572 }
32573 {
32574 PyThreadState* __tstate = wxPyBeginAllowThreads();
32575 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
32576 wxPyEndAllowThreads(__tstate);
32577 if (PyErr_Occurred()) SWIG_fail;
32578 }
32579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32580 {
32581 if (temp1)
32582 delete arg1;
32583 }
32584 return resultobj;
32585 fail:
32586 {
32587 if (temp1)
32588 delete arg1;
32589 }
32590 return NULL;
32591 }
32592
32593
32594 SWIGINTERN int PanelNameStr_set(PyObject *) {
32595 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32596 return 1;
32597 }
32598
32599
32600 SWIGINTERN PyObject *PanelNameStr_get(void) {
32601 PyObject *pyobj = 0;
32602
32603 {
32604 #if wxUSE_UNICODE
32605 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32606 #else
32607 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32608 #endif
32609 }
32610 return pyobj;
32611 }
32612
32613
32614 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32615 PyObject *resultobj = 0;
32616 wxVisualAttributes *result = 0 ;
32617
32618 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32619 {
32620 PyThreadState* __tstate = wxPyBeginAllowThreads();
32621 result = (wxVisualAttributes *)new_wxVisualAttributes();
32622 wxPyEndAllowThreads(__tstate);
32623 if (PyErr_Occurred()) SWIG_fail;
32624 }
32625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32626 return resultobj;
32627 fail:
32628 return NULL;
32629 }
32630
32631
32632 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32633 PyObject *resultobj = 0;
32634 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32635 void *argp1 = 0 ;
32636 int res1 = 0 ;
32637 PyObject *swig_obj[1] ;
32638
32639 if (!args) SWIG_fail;
32640 swig_obj[0] = args;
32641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32642 if (!SWIG_IsOK(res1)) {
32643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32644 }
32645 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32646 {
32647 PyThreadState* __tstate = wxPyBeginAllowThreads();
32648 delete_wxVisualAttributes(arg1);
32649
32650 wxPyEndAllowThreads(__tstate);
32651 if (PyErr_Occurred()) SWIG_fail;
32652 }
32653 resultobj = SWIG_Py_Void();
32654 return resultobj;
32655 fail:
32656 return NULL;
32657 }
32658
32659
32660 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32661 PyObject *resultobj = 0;
32662 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32663 wxFont *arg2 = (wxFont *) 0 ;
32664 void *argp1 = 0 ;
32665 int res1 = 0 ;
32666 void *argp2 = 0 ;
32667 int res2 = 0 ;
32668 PyObject *swig_obj[2] ;
32669
32670 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32672 if (!SWIG_IsOK(res1)) {
32673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32674 }
32675 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32676 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32677 if (!SWIG_IsOK(res2)) {
32678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32679 }
32680 arg2 = reinterpret_cast< wxFont * >(argp2);
32681 if (arg1) (arg1)->font = *arg2;
32682
32683 resultobj = SWIG_Py_Void();
32684 return resultobj;
32685 fail:
32686 return NULL;
32687 }
32688
32689
32690 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32691 PyObject *resultobj = 0;
32692 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32693 wxFont *result = 0 ;
32694 void *argp1 = 0 ;
32695 int res1 = 0 ;
32696 PyObject *swig_obj[1] ;
32697
32698 if (!args) SWIG_fail;
32699 swig_obj[0] = args;
32700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32701 if (!SWIG_IsOK(res1)) {
32702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32703 }
32704 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32705 result = (wxFont *)& ((arg1)->font);
32706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32707 return resultobj;
32708 fail:
32709 return NULL;
32710 }
32711
32712
32713 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32714 PyObject *resultobj = 0;
32715 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32716 wxColour *arg2 = (wxColour *) 0 ;
32717 void *argp1 = 0 ;
32718 int res1 = 0 ;
32719 void *argp2 = 0 ;
32720 int res2 = 0 ;
32721 PyObject *swig_obj[2] ;
32722
32723 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32725 if (!SWIG_IsOK(res1)) {
32726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32727 }
32728 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32729 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32730 if (!SWIG_IsOK(res2)) {
32731 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32732 }
32733 arg2 = reinterpret_cast< wxColour * >(argp2);
32734 if (arg1) (arg1)->colFg = *arg2;
32735
32736 resultobj = SWIG_Py_Void();
32737 return resultobj;
32738 fail:
32739 return NULL;
32740 }
32741
32742
32743 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32744 PyObject *resultobj = 0;
32745 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32746 wxColour *result = 0 ;
32747 void *argp1 = 0 ;
32748 int res1 = 0 ;
32749 PyObject *swig_obj[1] ;
32750
32751 if (!args) SWIG_fail;
32752 swig_obj[0] = args;
32753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32754 if (!SWIG_IsOK(res1)) {
32755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32756 }
32757 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32758 result = (wxColour *)& ((arg1)->colFg);
32759 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32760 return resultobj;
32761 fail:
32762 return NULL;
32763 }
32764
32765
32766 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32767 PyObject *resultobj = 0;
32768 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32769 wxColour *arg2 = (wxColour *) 0 ;
32770 void *argp1 = 0 ;
32771 int res1 = 0 ;
32772 void *argp2 = 0 ;
32773 int res2 = 0 ;
32774 PyObject *swig_obj[2] ;
32775
32776 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32778 if (!SWIG_IsOK(res1)) {
32779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32780 }
32781 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32782 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32783 if (!SWIG_IsOK(res2)) {
32784 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32785 }
32786 arg2 = reinterpret_cast< wxColour * >(argp2);
32787 if (arg1) (arg1)->colBg = *arg2;
32788
32789 resultobj = SWIG_Py_Void();
32790 return resultobj;
32791 fail:
32792 return NULL;
32793 }
32794
32795
32796 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32797 PyObject *resultobj = 0;
32798 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32799 wxColour *result = 0 ;
32800 void *argp1 = 0 ;
32801 int res1 = 0 ;
32802 PyObject *swig_obj[1] ;
32803
32804 if (!args) SWIG_fail;
32805 swig_obj[0] = args;
32806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32807 if (!SWIG_IsOK(res1)) {
32808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32809 }
32810 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32811 result = (wxColour *)& ((arg1)->colBg);
32812 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32813 return resultobj;
32814 fail:
32815 return NULL;
32816 }
32817
32818
32819 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32820 PyObject *obj;
32821 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32822 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32823 return SWIG_Py_Void();
32824 }
32825
32826 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32827 return SWIG_Python_InitShadowInstance(args);
32828 }
32829
32830 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32831 PyObject *resultobj = 0;
32832 wxWindow *arg1 = (wxWindow *) 0 ;
32833 int arg2 = (int) (int)-1 ;
32834 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32835 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32836 wxSize const &arg4_defvalue = wxDefaultSize ;
32837 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32838 long arg5 = (long) 0 ;
32839 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32840 wxString *arg6 = (wxString *) &arg6_defvalue ;
32841 wxWindow *result = 0 ;
32842 void *argp1 = 0 ;
32843 int res1 = 0 ;
32844 int val2 ;
32845 int ecode2 = 0 ;
32846 wxPoint temp3 ;
32847 wxSize temp4 ;
32848 long val5 ;
32849 int ecode5 = 0 ;
32850 bool temp6 = false ;
32851 PyObject * obj0 = 0 ;
32852 PyObject * obj1 = 0 ;
32853 PyObject * obj2 = 0 ;
32854 PyObject * obj3 = 0 ;
32855 PyObject * obj4 = 0 ;
32856 PyObject * obj5 = 0 ;
32857 char * kwnames[] = {
32858 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32859 };
32860
32861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32863 if (!SWIG_IsOK(res1)) {
32864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32865 }
32866 arg1 = reinterpret_cast< wxWindow * >(argp1);
32867 if (obj1) {
32868 ecode2 = SWIG_AsVal_int(obj1, &val2);
32869 if (!SWIG_IsOK(ecode2)) {
32870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32871 }
32872 arg2 = static_cast< int >(val2);
32873 }
32874 if (obj2) {
32875 {
32876 arg3 = &temp3;
32877 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32878 }
32879 }
32880 if (obj3) {
32881 {
32882 arg4 = &temp4;
32883 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32884 }
32885 }
32886 if (obj4) {
32887 ecode5 = SWIG_AsVal_long(obj4, &val5);
32888 if (!SWIG_IsOK(ecode5)) {
32889 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32890 }
32891 arg5 = static_cast< long >(val5);
32892 }
32893 if (obj5) {
32894 {
32895 arg6 = wxString_in_helper(obj5);
32896 if (arg6 == NULL) SWIG_fail;
32897 temp6 = true;
32898 }
32899 }
32900 {
32901 if (!wxPyCheckForApp()) SWIG_fail;
32902 PyThreadState* __tstate = wxPyBeginAllowThreads();
32903 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32904 wxPyEndAllowThreads(__tstate);
32905 if (PyErr_Occurred()) SWIG_fail;
32906 }
32907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32908 {
32909 if (temp6)
32910 delete arg6;
32911 }
32912 return resultobj;
32913 fail:
32914 {
32915 if (temp6)
32916 delete arg6;
32917 }
32918 return NULL;
32919 }
32920
32921
32922 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32923 PyObject *resultobj = 0;
32924 wxWindow *result = 0 ;
32925
32926 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32927 {
32928 if (!wxPyCheckForApp()) SWIG_fail;
32929 PyThreadState* __tstate = wxPyBeginAllowThreads();
32930 result = (wxWindow *)new wxWindow();
32931 wxPyEndAllowThreads(__tstate);
32932 if (PyErr_Occurred()) SWIG_fail;
32933 }
32934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32935 return resultobj;
32936 fail:
32937 return NULL;
32938 }
32939
32940
32941 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32942 PyObject *resultobj = 0;
32943 wxWindow *arg1 = (wxWindow *) 0 ;
32944 wxWindow *arg2 = (wxWindow *) 0 ;
32945 int arg3 = (int) (int)-1 ;
32946 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32947 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32948 wxSize const &arg5_defvalue = wxDefaultSize ;
32949 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32950 long arg6 = (long) 0 ;
32951 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32952 wxString *arg7 = (wxString *) &arg7_defvalue ;
32953 bool result;
32954 void *argp1 = 0 ;
32955 int res1 = 0 ;
32956 void *argp2 = 0 ;
32957 int res2 = 0 ;
32958 int val3 ;
32959 int ecode3 = 0 ;
32960 wxPoint temp4 ;
32961 wxSize temp5 ;
32962 long val6 ;
32963 int ecode6 = 0 ;
32964 bool temp7 = false ;
32965 PyObject * obj0 = 0 ;
32966 PyObject * obj1 = 0 ;
32967 PyObject * obj2 = 0 ;
32968 PyObject * obj3 = 0 ;
32969 PyObject * obj4 = 0 ;
32970 PyObject * obj5 = 0 ;
32971 PyObject * obj6 = 0 ;
32972 char * kwnames[] = {
32973 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32974 };
32975
32976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32978 if (!SWIG_IsOK(res1)) {
32979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
32980 }
32981 arg1 = reinterpret_cast< wxWindow * >(argp1);
32982 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32983 if (!SWIG_IsOK(res2)) {
32984 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
32985 }
32986 arg2 = reinterpret_cast< wxWindow * >(argp2);
32987 if (obj2) {
32988 ecode3 = SWIG_AsVal_int(obj2, &val3);
32989 if (!SWIG_IsOK(ecode3)) {
32990 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
32991 }
32992 arg3 = static_cast< int >(val3);
32993 }
32994 if (obj3) {
32995 {
32996 arg4 = &temp4;
32997 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32998 }
32999 }
33000 if (obj4) {
33001 {
33002 arg5 = &temp5;
33003 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
33004 }
33005 }
33006 if (obj5) {
33007 ecode6 = SWIG_AsVal_long(obj5, &val6);
33008 if (!SWIG_IsOK(ecode6)) {
33009 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
33010 }
33011 arg6 = static_cast< long >(val6);
33012 }
33013 if (obj6) {
33014 {
33015 arg7 = wxString_in_helper(obj6);
33016 if (arg7 == NULL) SWIG_fail;
33017 temp7 = true;
33018 }
33019 }
33020 {
33021 PyThreadState* __tstate = wxPyBeginAllowThreads();
33022 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
33023 wxPyEndAllowThreads(__tstate);
33024 if (PyErr_Occurred()) SWIG_fail;
33025 }
33026 {
33027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33028 }
33029 {
33030 if (temp7)
33031 delete arg7;
33032 }
33033 return resultobj;
33034 fail:
33035 {
33036 if (temp7)
33037 delete arg7;
33038 }
33039 return NULL;
33040 }
33041
33042
33043 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33044 PyObject *resultobj = 0;
33045 wxWindow *arg1 = (wxWindow *) 0 ;
33046 bool arg2 = (bool) false ;
33047 bool result;
33048 void *argp1 = 0 ;
33049 int res1 = 0 ;
33050 bool val2 ;
33051 int ecode2 = 0 ;
33052 PyObject * obj0 = 0 ;
33053 PyObject * obj1 = 0 ;
33054 char * kwnames[] = {
33055 (char *) "self",(char *) "force", NULL
33056 };
33057
33058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
33059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33060 if (!SWIG_IsOK(res1)) {
33061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
33062 }
33063 arg1 = reinterpret_cast< wxWindow * >(argp1);
33064 if (obj1) {
33065 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33066 if (!SWIG_IsOK(ecode2)) {
33067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
33068 }
33069 arg2 = static_cast< bool >(val2);
33070 }
33071 {
33072 PyThreadState* __tstate = wxPyBeginAllowThreads();
33073 result = (bool)(arg1)->Close(arg2);
33074 wxPyEndAllowThreads(__tstate);
33075 if (PyErr_Occurred()) SWIG_fail;
33076 }
33077 {
33078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33079 }
33080 return resultobj;
33081 fail:
33082 return NULL;
33083 }
33084
33085
33086 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33087 PyObject *resultobj = 0;
33088 wxWindow *arg1 = (wxWindow *) 0 ;
33089 bool result;
33090 void *argp1 = 0 ;
33091 int res1 = 0 ;
33092 PyObject *swig_obj[1] ;
33093
33094 if (!args) SWIG_fail;
33095 swig_obj[0] = args;
33096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33097 if (!SWIG_IsOK(res1)) {
33098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
33099 }
33100 arg1 = reinterpret_cast< wxWindow * >(argp1);
33101 {
33102 PyThreadState* __tstate = wxPyBeginAllowThreads();
33103 result = (bool)(arg1)->Destroy();
33104 wxPyEndAllowThreads(__tstate);
33105 if (PyErr_Occurred()) SWIG_fail;
33106 }
33107 {
33108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33109 }
33110 return resultobj;
33111 fail:
33112 return NULL;
33113 }
33114
33115
33116 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33117 PyObject *resultobj = 0;
33118 wxWindow *arg1 = (wxWindow *) 0 ;
33119 bool result;
33120 void *argp1 = 0 ;
33121 int res1 = 0 ;
33122 PyObject *swig_obj[1] ;
33123
33124 if (!args) SWIG_fail;
33125 swig_obj[0] = args;
33126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33127 if (!SWIG_IsOK(res1)) {
33128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33129 }
33130 arg1 = reinterpret_cast< wxWindow * >(argp1);
33131 {
33132 PyThreadState* __tstate = wxPyBeginAllowThreads();
33133 result = (bool)(arg1)->DestroyChildren();
33134 wxPyEndAllowThreads(__tstate);
33135 if (PyErr_Occurred()) SWIG_fail;
33136 }
33137 {
33138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33139 }
33140 return resultobj;
33141 fail:
33142 return NULL;
33143 }
33144
33145
33146 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33147 PyObject *resultobj = 0;
33148 wxWindow *arg1 = (wxWindow *) 0 ;
33149 bool result;
33150 void *argp1 = 0 ;
33151 int res1 = 0 ;
33152 PyObject *swig_obj[1] ;
33153
33154 if (!args) SWIG_fail;
33155 swig_obj[0] = args;
33156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33157 if (!SWIG_IsOK(res1)) {
33158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33159 }
33160 arg1 = reinterpret_cast< wxWindow * >(argp1);
33161 {
33162 PyThreadState* __tstate = wxPyBeginAllowThreads();
33163 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33164 wxPyEndAllowThreads(__tstate);
33165 if (PyErr_Occurred()) SWIG_fail;
33166 }
33167 {
33168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33169 }
33170 return resultobj;
33171 fail:
33172 return NULL;
33173 }
33174
33175
33176 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33177 PyObject *resultobj = 0;
33178 wxWindow *arg1 = (wxWindow *) 0 ;
33179 wxString *arg2 = 0 ;
33180 void *argp1 = 0 ;
33181 int res1 = 0 ;
33182 bool temp2 = false ;
33183 PyObject * obj0 = 0 ;
33184 PyObject * obj1 = 0 ;
33185 char * kwnames[] = {
33186 (char *) "self",(char *) "label", NULL
33187 };
33188
33189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33191 if (!SWIG_IsOK(res1)) {
33192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33193 }
33194 arg1 = reinterpret_cast< wxWindow * >(argp1);
33195 {
33196 arg2 = wxString_in_helper(obj1);
33197 if (arg2 == NULL) SWIG_fail;
33198 temp2 = true;
33199 }
33200 {
33201 PyThreadState* __tstate = wxPyBeginAllowThreads();
33202 (arg1)->SetLabel((wxString const &)*arg2);
33203 wxPyEndAllowThreads(__tstate);
33204 if (PyErr_Occurred()) SWIG_fail;
33205 }
33206 resultobj = SWIG_Py_Void();
33207 {
33208 if (temp2)
33209 delete arg2;
33210 }
33211 return resultobj;
33212 fail:
33213 {
33214 if (temp2)
33215 delete arg2;
33216 }
33217 return NULL;
33218 }
33219
33220
33221 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33222 PyObject *resultobj = 0;
33223 wxWindow *arg1 = (wxWindow *) 0 ;
33224 wxString result;
33225 void *argp1 = 0 ;
33226 int res1 = 0 ;
33227 PyObject *swig_obj[1] ;
33228
33229 if (!args) SWIG_fail;
33230 swig_obj[0] = args;
33231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33232 if (!SWIG_IsOK(res1)) {
33233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33234 }
33235 arg1 = reinterpret_cast< wxWindow * >(argp1);
33236 {
33237 PyThreadState* __tstate = wxPyBeginAllowThreads();
33238 result = ((wxWindow const *)arg1)->GetLabel();
33239 wxPyEndAllowThreads(__tstate);
33240 if (PyErr_Occurred()) SWIG_fail;
33241 }
33242 {
33243 #if wxUSE_UNICODE
33244 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33245 #else
33246 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33247 #endif
33248 }
33249 return resultobj;
33250 fail:
33251 return NULL;
33252 }
33253
33254
33255 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33256 PyObject *resultobj = 0;
33257 wxWindow *arg1 = (wxWindow *) 0 ;
33258 wxString *arg2 = 0 ;
33259 void *argp1 = 0 ;
33260 int res1 = 0 ;
33261 bool temp2 = false ;
33262 PyObject * obj0 = 0 ;
33263 PyObject * obj1 = 0 ;
33264 char * kwnames[] = {
33265 (char *) "self",(char *) "name", NULL
33266 };
33267
33268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33270 if (!SWIG_IsOK(res1)) {
33271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33272 }
33273 arg1 = reinterpret_cast< wxWindow * >(argp1);
33274 {
33275 arg2 = wxString_in_helper(obj1);
33276 if (arg2 == NULL) SWIG_fail;
33277 temp2 = true;
33278 }
33279 {
33280 PyThreadState* __tstate = wxPyBeginAllowThreads();
33281 (arg1)->SetName((wxString const &)*arg2);
33282 wxPyEndAllowThreads(__tstate);
33283 if (PyErr_Occurred()) SWIG_fail;
33284 }
33285 resultobj = SWIG_Py_Void();
33286 {
33287 if (temp2)
33288 delete arg2;
33289 }
33290 return resultobj;
33291 fail:
33292 {
33293 if (temp2)
33294 delete arg2;
33295 }
33296 return NULL;
33297 }
33298
33299
33300 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33301 PyObject *resultobj = 0;
33302 wxWindow *arg1 = (wxWindow *) 0 ;
33303 wxString result;
33304 void *argp1 = 0 ;
33305 int res1 = 0 ;
33306 PyObject *swig_obj[1] ;
33307
33308 if (!args) SWIG_fail;
33309 swig_obj[0] = args;
33310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33311 if (!SWIG_IsOK(res1)) {
33312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33313 }
33314 arg1 = reinterpret_cast< wxWindow * >(argp1);
33315 {
33316 PyThreadState* __tstate = wxPyBeginAllowThreads();
33317 result = ((wxWindow const *)arg1)->GetName();
33318 wxPyEndAllowThreads(__tstate);
33319 if (PyErr_Occurred()) SWIG_fail;
33320 }
33321 {
33322 #if wxUSE_UNICODE
33323 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33324 #else
33325 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33326 #endif
33327 }
33328 return resultobj;
33329 fail:
33330 return NULL;
33331 }
33332
33333
33334 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33335 PyObject *resultobj = 0;
33336 wxWindow *arg1 = (wxWindow *) 0 ;
33337 wxWindowVariant arg2 ;
33338 void *argp1 = 0 ;
33339 int res1 = 0 ;
33340 int val2 ;
33341 int ecode2 = 0 ;
33342 PyObject * obj0 = 0 ;
33343 PyObject * obj1 = 0 ;
33344 char * kwnames[] = {
33345 (char *) "self",(char *) "variant", NULL
33346 };
33347
33348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33350 if (!SWIG_IsOK(res1)) {
33351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33352 }
33353 arg1 = reinterpret_cast< wxWindow * >(argp1);
33354 ecode2 = SWIG_AsVal_int(obj1, &val2);
33355 if (!SWIG_IsOK(ecode2)) {
33356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33357 }
33358 arg2 = static_cast< wxWindowVariant >(val2);
33359 {
33360 PyThreadState* __tstate = wxPyBeginAllowThreads();
33361 (arg1)->SetWindowVariant(arg2);
33362 wxPyEndAllowThreads(__tstate);
33363 if (PyErr_Occurred()) SWIG_fail;
33364 }
33365 resultobj = SWIG_Py_Void();
33366 return resultobj;
33367 fail:
33368 return NULL;
33369 }
33370
33371
33372 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33373 PyObject *resultobj = 0;
33374 wxWindow *arg1 = (wxWindow *) 0 ;
33375 wxWindowVariant result;
33376 void *argp1 = 0 ;
33377 int res1 = 0 ;
33378 PyObject *swig_obj[1] ;
33379
33380 if (!args) SWIG_fail;
33381 swig_obj[0] = args;
33382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33383 if (!SWIG_IsOK(res1)) {
33384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33385 }
33386 arg1 = reinterpret_cast< wxWindow * >(argp1);
33387 {
33388 PyThreadState* __tstate = wxPyBeginAllowThreads();
33389 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33390 wxPyEndAllowThreads(__tstate);
33391 if (PyErr_Occurred()) SWIG_fail;
33392 }
33393 resultobj = SWIG_From_int(static_cast< int >(result));
33394 return resultobj;
33395 fail:
33396 return NULL;
33397 }
33398
33399
33400 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33401 PyObject *resultobj = 0;
33402 wxWindow *arg1 = (wxWindow *) 0 ;
33403 int arg2 ;
33404 void *argp1 = 0 ;
33405 int res1 = 0 ;
33406 int val2 ;
33407 int ecode2 = 0 ;
33408 PyObject * obj0 = 0 ;
33409 PyObject * obj1 = 0 ;
33410 char * kwnames[] = {
33411 (char *) "self",(char *) "winid", NULL
33412 };
33413
33414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33416 if (!SWIG_IsOK(res1)) {
33417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33418 }
33419 arg1 = reinterpret_cast< wxWindow * >(argp1);
33420 ecode2 = SWIG_AsVal_int(obj1, &val2);
33421 if (!SWIG_IsOK(ecode2)) {
33422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33423 }
33424 arg2 = static_cast< int >(val2);
33425 {
33426 PyThreadState* __tstate = wxPyBeginAllowThreads();
33427 (arg1)->SetId(arg2);
33428 wxPyEndAllowThreads(__tstate);
33429 if (PyErr_Occurred()) SWIG_fail;
33430 }
33431 resultobj = SWIG_Py_Void();
33432 return resultobj;
33433 fail:
33434 return NULL;
33435 }
33436
33437
33438 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33439 PyObject *resultobj = 0;
33440 wxWindow *arg1 = (wxWindow *) 0 ;
33441 int result;
33442 void *argp1 = 0 ;
33443 int res1 = 0 ;
33444 PyObject *swig_obj[1] ;
33445
33446 if (!args) SWIG_fail;
33447 swig_obj[0] = args;
33448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33449 if (!SWIG_IsOK(res1)) {
33450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33451 }
33452 arg1 = reinterpret_cast< wxWindow * >(argp1);
33453 {
33454 PyThreadState* __tstate = wxPyBeginAllowThreads();
33455 result = (int)((wxWindow const *)arg1)->GetId();
33456 wxPyEndAllowThreads(__tstate);
33457 if (PyErr_Occurred()) SWIG_fail;
33458 }
33459 resultobj = SWIG_From_int(static_cast< int >(result));
33460 return resultobj;
33461 fail:
33462 return NULL;
33463 }
33464
33465
33466 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33467 PyObject *resultobj = 0;
33468 int result;
33469
33470 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33471 {
33472 PyThreadState* __tstate = wxPyBeginAllowThreads();
33473 result = (int)wxWindow::NewControlId();
33474 wxPyEndAllowThreads(__tstate);
33475 if (PyErr_Occurred()) SWIG_fail;
33476 }
33477 resultobj = SWIG_From_int(static_cast< int >(result));
33478 return resultobj;
33479 fail:
33480 return NULL;
33481 }
33482
33483
33484 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33485 PyObject *resultobj = 0;
33486 int arg1 ;
33487 int result;
33488 int val1 ;
33489 int ecode1 = 0 ;
33490 PyObject * obj0 = 0 ;
33491 char * kwnames[] = {
33492 (char *) "winid", NULL
33493 };
33494
33495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33496 ecode1 = SWIG_AsVal_int(obj0, &val1);
33497 if (!SWIG_IsOK(ecode1)) {
33498 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33499 }
33500 arg1 = static_cast< int >(val1);
33501 {
33502 PyThreadState* __tstate = wxPyBeginAllowThreads();
33503 result = (int)wxWindow::NextControlId(arg1);
33504 wxPyEndAllowThreads(__tstate);
33505 if (PyErr_Occurred()) SWIG_fail;
33506 }
33507 resultobj = SWIG_From_int(static_cast< int >(result));
33508 return resultobj;
33509 fail:
33510 return NULL;
33511 }
33512
33513
33514 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33515 PyObject *resultobj = 0;
33516 int arg1 ;
33517 int result;
33518 int val1 ;
33519 int ecode1 = 0 ;
33520 PyObject * obj0 = 0 ;
33521 char * kwnames[] = {
33522 (char *) "winid", NULL
33523 };
33524
33525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33526 ecode1 = SWIG_AsVal_int(obj0, &val1);
33527 if (!SWIG_IsOK(ecode1)) {
33528 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33529 }
33530 arg1 = static_cast< int >(val1);
33531 {
33532 PyThreadState* __tstate = wxPyBeginAllowThreads();
33533 result = (int)wxWindow::PrevControlId(arg1);
33534 wxPyEndAllowThreads(__tstate);
33535 if (PyErr_Occurred()) SWIG_fail;
33536 }
33537 resultobj = SWIG_From_int(static_cast< int >(result));
33538 return resultobj;
33539 fail:
33540 return NULL;
33541 }
33542
33543
33544 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33545 PyObject *resultobj = 0;
33546 wxWindow *arg1 = (wxWindow *) 0 ;
33547 wxLayoutDirection result;
33548 void *argp1 = 0 ;
33549 int res1 = 0 ;
33550 PyObject *swig_obj[1] ;
33551
33552 if (!args) SWIG_fail;
33553 swig_obj[0] = args;
33554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33555 if (!SWIG_IsOK(res1)) {
33556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33557 }
33558 arg1 = reinterpret_cast< wxWindow * >(argp1);
33559 {
33560 PyThreadState* __tstate = wxPyBeginAllowThreads();
33561 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33562 wxPyEndAllowThreads(__tstate);
33563 if (PyErr_Occurred()) SWIG_fail;
33564 }
33565 resultobj = SWIG_From_int(static_cast< int >(result));
33566 return resultobj;
33567 fail:
33568 return NULL;
33569 }
33570
33571
33572 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33573 PyObject *resultobj = 0;
33574 wxWindow *arg1 = (wxWindow *) 0 ;
33575 wxLayoutDirection arg2 ;
33576 void *argp1 = 0 ;
33577 int res1 = 0 ;
33578 int val2 ;
33579 int ecode2 = 0 ;
33580 PyObject * obj0 = 0 ;
33581 PyObject * obj1 = 0 ;
33582 char * kwnames[] = {
33583 (char *) "self",(char *) "dir", NULL
33584 };
33585
33586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33588 if (!SWIG_IsOK(res1)) {
33589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33590 }
33591 arg1 = reinterpret_cast< wxWindow * >(argp1);
33592 ecode2 = SWIG_AsVal_int(obj1, &val2);
33593 if (!SWIG_IsOK(ecode2)) {
33594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33595 }
33596 arg2 = static_cast< wxLayoutDirection >(val2);
33597 {
33598 PyThreadState* __tstate = wxPyBeginAllowThreads();
33599 (arg1)->SetLayoutDirection(arg2);
33600 wxPyEndAllowThreads(__tstate);
33601 if (PyErr_Occurred()) SWIG_fail;
33602 }
33603 resultobj = SWIG_Py_Void();
33604 return resultobj;
33605 fail:
33606 return NULL;
33607 }
33608
33609
33610 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33611 PyObject *resultobj = 0;
33612 wxWindow *arg1 = (wxWindow *) 0 ;
33613 int arg2 ;
33614 int arg3 ;
33615 int arg4 ;
33616 int result;
33617 void *argp1 = 0 ;
33618 int res1 = 0 ;
33619 int val2 ;
33620 int ecode2 = 0 ;
33621 int val3 ;
33622 int ecode3 = 0 ;
33623 int val4 ;
33624 int ecode4 = 0 ;
33625 PyObject * obj0 = 0 ;
33626 PyObject * obj1 = 0 ;
33627 PyObject * obj2 = 0 ;
33628 PyObject * obj3 = 0 ;
33629 char * kwnames[] = {
33630 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33631 };
33632
33633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33635 if (!SWIG_IsOK(res1)) {
33636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33637 }
33638 arg1 = reinterpret_cast< wxWindow * >(argp1);
33639 ecode2 = SWIG_AsVal_int(obj1, &val2);
33640 if (!SWIG_IsOK(ecode2)) {
33641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33642 }
33643 arg2 = static_cast< int >(val2);
33644 ecode3 = SWIG_AsVal_int(obj2, &val3);
33645 if (!SWIG_IsOK(ecode3)) {
33646 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33647 }
33648 arg3 = static_cast< int >(val3);
33649 ecode4 = SWIG_AsVal_int(obj3, &val4);
33650 if (!SWIG_IsOK(ecode4)) {
33651 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33652 }
33653 arg4 = static_cast< int >(val4);
33654 {
33655 PyThreadState* __tstate = wxPyBeginAllowThreads();
33656 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33657 wxPyEndAllowThreads(__tstate);
33658 if (PyErr_Occurred()) SWIG_fail;
33659 }
33660 resultobj = SWIG_From_int(static_cast< int >(result));
33661 return resultobj;
33662 fail:
33663 return NULL;
33664 }
33665
33666
33667 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33668 PyObject *resultobj = 0;
33669 wxWindow *arg1 = (wxWindow *) 0 ;
33670 wxSize *arg2 = 0 ;
33671 void *argp1 = 0 ;
33672 int res1 = 0 ;
33673 wxSize temp2 ;
33674 PyObject * obj0 = 0 ;
33675 PyObject * obj1 = 0 ;
33676 char * kwnames[] = {
33677 (char *) "self",(char *) "size", NULL
33678 };
33679
33680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33682 if (!SWIG_IsOK(res1)) {
33683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33684 }
33685 arg1 = reinterpret_cast< wxWindow * >(argp1);
33686 {
33687 arg2 = &temp2;
33688 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33689 }
33690 {
33691 PyThreadState* __tstate = wxPyBeginAllowThreads();
33692 (arg1)->SetSize((wxSize const &)*arg2);
33693 wxPyEndAllowThreads(__tstate);
33694 if (PyErr_Occurred()) SWIG_fail;
33695 }
33696 resultobj = SWIG_Py_Void();
33697 return resultobj;
33698 fail:
33699 return NULL;
33700 }
33701
33702
33703 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33704 PyObject *resultobj = 0;
33705 wxWindow *arg1 = (wxWindow *) 0 ;
33706 int arg2 ;
33707 int arg3 ;
33708 int arg4 ;
33709 int arg5 ;
33710 int arg6 = (int) wxSIZE_AUTO ;
33711 void *argp1 = 0 ;
33712 int res1 = 0 ;
33713 int val2 ;
33714 int ecode2 = 0 ;
33715 int val3 ;
33716 int ecode3 = 0 ;
33717 int val4 ;
33718 int ecode4 = 0 ;
33719 int val5 ;
33720 int ecode5 = 0 ;
33721 int val6 ;
33722 int ecode6 = 0 ;
33723 PyObject * obj0 = 0 ;
33724 PyObject * obj1 = 0 ;
33725 PyObject * obj2 = 0 ;
33726 PyObject * obj3 = 0 ;
33727 PyObject * obj4 = 0 ;
33728 PyObject * obj5 = 0 ;
33729 char * kwnames[] = {
33730 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33731 };
33732
33733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33735 if (!SWIG_IsOK(res1)) {
33736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33737 }
33738 arg1 = reinterpret_cast< wxWindow * >(argp1);
33739 ecode2 = SWIG_AsVal_int(obj1, &val2);
33740 if (!SWIG_IsOK(ecode2)) {
33741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33742 }
33743 arg2 = static_cast< int >(val2);
33744 ecode3 = SWIG_AsVal_int(obj2, &val3);
33745 if (!SWIG_IsOK(ecode3)) {
33746 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33747 }
33748 arg3 = static_cast< int >(val3);
33749 ecode4 = SWIG_AsVal_int(obj3, &val4);
33750 if (!SWIG_IsOK(ecode4)) {
33751 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33752 }
33753 arg4 = static_cast< int >(val4);
33754 ecode5 = SWIG_AsVal_int(obj4, &val5);
33755 if (!SWIG_IsOK(ecode5)) {
33756 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33757 }
33758 arg5 = static_cast< int >(val5);
33759 if (obj5) {
33760 ecode6 = SWIG_AsVal_int(obj5, &val6);
33761 if (!SWIG_IsOK(ecode6)) {
33762 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33763 }
33764 arg6 = static_cast< int >(val6);
33765 }
33766 {
33767 PyThreadState* __tstate = wxPyBeginAllowThreads();
33768 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33769 wxPyEndAllowThreads(__tstate);
33770 if (PyErr_Occurred()) SWIG_fail;
33771 }
33772 resultobj = SWIG_Py_Void();
33773 return resultobj;
33774 fail:
33775 return NULL;
33776 }
33777
33778
33779 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33780 PyObject *resultobj = 0;
33781 wxWindow *arg1 = (wxWindow *) 0 ;
33782 wxRect *arg2 = 0 ;
33783 int arg3 = (int) wxSIZE_AUTO ;
33784 void *argp1 = 0 ;
33785 int res1 = 0 ;
33786 wxRect temp2 ;
33787 int val3 ;
33788 int ecode3 = 0 ;
33789 PyObject * obj0 = 0 ;
33790 PyObject * obj1 = 0 ;
33791 PyObject * obj2 = 0 ;
33792 char * kwnames[] = {
33793 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33794 };
33795
33796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33798 if (!SWIG_IsOK(res1)) {
33799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33800 }
33801 arg1 = reinterpret_cast< wxWindow * >(argp1);
33802 {
33803 arg2 = &temp2;
33804 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33805 }
33806 if (obj2) {
33807 ecode3 = SWIG_AsVal_int(obj2, &val3);
33808 if (!SWIG_IsOK(ecode3)) {
33809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33810 }
33811 arg3 = static_cast< int >(val3);
33812 }
33813 {
33814 PyThreadState* __tstate = wxPyBeginAllowThreads();
33815 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33816 wxPyEndAllowThreads(__tstate);
33817 if (PyErr_Occurred()) SWIG_fail;
33818 }
33819 resultobj = SWIG_Py_Void();
33820 return resultobj;
33821 fail:
33822 return NULL;
33823 }
33824
33825
33826 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33827 PyObject *resultobj = 0;
33828 wxWindow *arg1 = (wxWindow *) 0 ;
33829 int arg2 ;
33830 int arg3 ;
33831 void *argp1 = 0 ;
33832 int res1 = 0 ;
33833 int val2 ;
33834 int ecode2 = 0 ;
33835 int val3 ;
33836 int ecode3 = 0 ;
33837 PyObject * obj0 = 0 ;
33838 PyObject * obj1 = 0 ;
33839 PyObject * obj2 = 0 ;
33840 char * kwnames[] = {
33841 (char *) "self",(char *) "width",(char *) "height", NULL
33842 };
33843
33844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33846 if (!SWIG_IsOK(res1)) {
33847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33848 }
33849 arg1 = reinterpret_cast< wxWindow * >(argp1);
33850 ecode2 = SWIG_AsVal_int(obj1, &val2);
33851 if (!SWIG_IsOK(ecode2)) {
33852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33853 }
33854 arg2 = static_cast< int >(val2);
33855 ecode3 = SWIG_AsVal_int(obj2, &val3);
33856 if (!SWIG_IsOK(ecode3)) {
33857 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33858 }
33859 arg3 = static_cast< int >(val3);
33860 {
33861 PyThreadState* __tstate = wxPyBeginAllowThreads();
33862 (arg1)->SetSize(arg2,arg3);
33863 wxPyEndAllowThreads(__tstate);
33864 if (PyErr_Occurred()) SWIG_fail;
33865 }
33866 resultobj = SWIG_Py_Void();
33867 return resultobj;
33868 fail:
33869 return NULL;
33870 }
33871
33872
33873 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33874 PyObject *resultobj = 0;
33875 wxWindow *arg1 = (wxWindow *) 0 ;
33876 wxPoint *arg2 = 0 ;
33877 int arg3 = (int) wxSIZE_USE_EXISTING ;
33878 void *argp1 = 0 ;
33879 int res1 = 0 ;
33880 wxPoint temp2 ;
33881 int val3 ;
33882 int ecode3 = 0 ;
33883 PyObject * obj0 = 0 ;
33884 PyObject * obj1 = 0 ;
33885 PyObject * obj2 = 0 ;
33886 char * kwnames[] = {
33887 (char *) "self",(char *) "pt",(char *) "flags", NULL
33888 };
33889
33890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33892 if (!SWIG_IsOK(res1)) {
33893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33894 }
33895 arg1 = reinterpret_cast< wxWindow * >(argp1);
33896 {
33897 arg2 = &temp2;
33898 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33899 }
33900 if (obj2) {
33901 ecode3 = SWIG_AsVal_int(obj2, &val3);
33902 if (!SWIG_IsOK(ecode3)) {
33903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33904 }
33905 arg3 = static_cast< int >(val3);
33906 }
33907 {
33908 PyThreadState* __tstate = wxPyBeginAllowThreads();
33909 (arg1)->Move((wxPoint const &)*arg2,arg3);
33910 wxPyEndAllowThreads(__tstate);
33911 if (PyErr_Occurred()) SWIG_fail;
33912 }
33913 resultobj = SWIG_Py_Void();
33914 return resultobj;
33915 fail:
33916 return NULL;
33917 }
33918
33919
33920 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33921 PyObject *resultobj = 0;
33922 wxWindow *arg1 = (wxWindow *) 0 ;
33923 int arg2 ;
33924 int arg3 ;
33925 int arg4 = (int) wxSIZE_USE_EXISTING ;
33926 void *argp1 = 0 ;
33927 int res1 = 0 ;
33928 int val2 ;
33929 int ecode2 = 0 ;
33930 int val3 ;
33931 int ecode3 = 0 ;
33932 int val4 ;
33933 int ecode4 = 0 ;
33934 PyObject * obj0 = 0 ;
33935 PyObject * obj1 = 0 ;
33936 PyObject * obj2 = 0 ;
33937 PyObject * obj3 = 0 ;
33938 char * kwnames[] = {
33939 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33940 };
33941
33942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33944 if (!SWIG_IsOK(res1)) {
33945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33946 }
33947 arg1 = reinterpret_cast< wxWindow * >(argp1);
33948 ecode2 = SWIG_AsVal_int(obj1, &val2);
33949 if (!SWIG_IsOK(ecode2)) {
33950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33951 }
33952 arg2 = static_cast< int >(val2);
33953 ecode3 = SWIG_AsVal_int(obj2, &val3);
33954 if (!SWIG_IsOK(ecode3)) {
33955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33956 }
33957 arg3 = static_cast< int >(val3);
33958 if (obj3) {
33959 ecode4 = SWIG_AsVal_int(obj3, &val4);
33960 if (!SWIG_IsOK(ecode4)) {
33961 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33962 }
33963 arg4 = static_cast< int >(val4);
33964 }
33965 {
33966 PyThreadState* __tstate = wxPyBeginAllowThreads();
33967 (arg1)->Move(arg2,arg3,arg4);
33968 wxPyEndAllowThreads(__tstate);
33969 if (PyErr_Occurred()) SWIG_fail;
33970 }
33971 resultobj = SWIG_Py_Void();
33972 return resultobj;
33973 fail:
33974 return NULL;
33975 }
33976
33977
33978 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33979 PyObject *resultobj = 0;
33980 wxWindow *arg1 = (wxWindow *) 0 ;
33981 wxSize const &arg2_defvalue = wxDefaultSize ;
33982 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
33983 void *argp1 = 0 ;
33984 int res1 = 0 ;
33985 wxSize temp2 ;
33986 PyObject * obj0 = 0 ;
33987 PyObject * obj1 = 0 ;
33988 char * kwnames[] = {
33989 (char *) "self",(char *) "size", NULL
33990 };
33991
33992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
33993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33994 if (!SWIG_IsOK(res1)) {
33995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33996 }
33997 arg1 = reinterpret_cast< wxWindow * >(argp1);
33998 if (obj1) {
33999 {
34000 arg2 = &temp2;
34001 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34002 }
34003 }
34004 {
34005 PyThreadState* __tstate = wxPyBeginAllowThreads();
34006 (arg1)->SetInitialSize((wxSize const &)*arg2);
34007 wxPyEndAllowThreads(__tstate);
34008 if (PyErr_Occurred()) SWIG_fail;
34009 }
34010 resultobj = SWIG_Py_Void();
34011 return resultobj;
34012 fail:
34013 return NULL;
34014 }
34015
34016
34017 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34018 PyObject *resultobj = 0;
34019 wxWindow *arg1 = (wxWindow *) 0 ;
34020 void *argp1 = 0 ;
34021 int res1 = 0 ;
34022 PyObject *swig_obj[1] ;
34023
34024 if (!args) SWIG_fail;
34025 swig_obj[0] = args;
34026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34027 if (!SWIG_IsOK(res1)) {
34028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
34029 }
34030 arg1 = reinterpret_cast< wxWindow * >(argp1);
34031 {
34032 PyThreadState* __tstate = wxPyBeginAllowThreads();
34033 (arg1)->Raise();
34034 wxPyEndAllowThreads(__tstate);
34035 if (PyErr_Occurred()) SWIG_fail;
34036 }
34037 resultobj = SWIG_Py_Void();
34038 return resultobj;
34039 fail:
34040 return NULL;
34041 }
34042
34043
34044 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34045 PyObject *resultobj = 0;
34046 wxWindow *arg1 = (wxWindow *) 0 ;
34047 void *argp1 = 0 ;
34048 int res1 = 0 ;
34049 PyObject *swig_obj[1] ;
34050
34051 if (!args) SWIG_fail;
34052 swig_obj[0] = args;
34053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34054 if (!SWIG_IsOK(res1)) {
34055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
34056 }
34057 arg1 = reinterpret_cast< wxWindow * >(argp1);
34058 {
34059 PyThreadState* __tstate = wxPyBeginAllowThreads();
34060 (arg1)->Lower();
34061 wxPyEndAllowThreads(__tstate);
34062 if (PyErr_Occurred()) SWIG_fail;
34063 }
34064 resultobj = SWIG_Py_Void();
34065 return resultobj;
34066 fail:
34067 return NULL;
34068 }
34069
34070
34071 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34072 PyObject *resultobj = 0;
34073 wxWindow *arg1 = (wxWindow *) 0 ;
34074 wxSize *arg2 = 0 ;
34075 void *argp1 = 0 ;
34076 int res1 = 0 ;
34077 wxSize temp2 ;
34078 PyObject * obj0 = 0 ;
34079 PyObject * obj1 = 0 ;
34080 char * kwnames[] = {
34081 (char *) "self",(char *) "size", NULL
34082 };
34083
34084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
34085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34086 if (!SWIG_IsOK(res1)) {
34087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34088 }
34089 arg1 = reinterpret_cast< wxWindow * >(argp1);
34090 {
34091 arg2 = &temp2;
34092 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34093 }
34094 {
34095 PyThreadState* __tstate = wxPyBeginAllowThreads();
34096 (arg1)->SetClientSize((wxSize const &)*arg2);
34097 wxPyEndAllowThreads(__tstate);
34098 if (PyErr_Occurred()) SWIG_fail;
34099 }
34100 resultobj = SWIG_Py_Void();
34101 return resultobj;
34102 fail:
34103 return NULL;
34104 }
34105
34106
34107 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34108 PyObject *resultobj = 0;
34109 wxWindow *arg1 = (wxWindow *) 0 ;
34110 int arg2 ;
34111 int arg3 ;
34112 void *argp1 = 0 ;
34113 int res1 = 0 ;
34114 int val2 ;
34115 int ecode2 = 0 ;
34116 int val3 ;
34117 int ecode3 = 0 ;
34118 PyObject * obj0 = 0 ;
34119 PyObject * obj1 = 0 ;
34120 PyObject * obj2 = 0 ;
34121 char * kwnames[] = {
34122 (char *) "self",(char *) "width",(char *) "height", NULL
34123 };
34124
34125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34127 if (!SWIG_IsOK(res1)) {
34128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34129 }
34130 arg1 = reinterpret_cast< wxWindow * >(argp1);
34131 ecode2 = SWIG_AsVal_int(obj1, &val2);
34132 if (!SWIG_IsOK(ecode2)) {
34133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
34134 }
34135 arg2 = static_cast< int >(val2);
34136 ecode3 = SWIG_AsVal_int(obj2, &val3);
34137 if (!SWIG_IsOK(ecode3)) {
34138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
34139 }
34140 arg3 = static_cast< int >(val3);
34141 {
34142 PyThreadState* __tstate = wxPyBeginAllowThreads();
34143 (arg1)->SetClientSize(arg2,arg3);
34144 wxPyEndAllowThreads(__tstate);
34145 if (PyErr_Occurred()) SWIG_fail;
34146 }
34147 resultobj = SWIG_Py_Void();
34148 return resultobj;
34149 fail:
34150 return NULL;
34151 }
34152
34153
34154 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34155 PyObject *resultobj = 0;
34156 wxWindow *arg1 = (wxWindow *) 0 ;
34157 wxRect *arg2 = 0 ;
34158 void *argp1 = 0 ;
34159 int res1 = 0 ;
34160 wxRect temp2 ;
34161 PyObject * obj0 = 0 ;
34162 PyObject * obj1 = 0 ;
34163 char * kwnames[] = {
34164 (char *) "self",(char *) "rect", NULL
34165 };
34166
34167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34169 if (!SWIG_IsOK(res1)) {
34170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34171 }
34172 arg1 = reinterpret_cast< wxWindow * >(argp1);
34173 {
34174 arg2 = &temp2;
34175 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34176 }
34177 {
34178 PyThreadState* __tstate = wxPyBeginAllowThreads();
34179 (arg1)->SetClientSize((wxRect const &)*arg2);
34180 wxPyEndAllowThreads(__tstate);
34181 if (PyErr_Occurred()) SWIG_fail;
34182 }
34183 resultobj = SWIG_Py_Void();
34184 return resultobj;
34185 fail:
34186 return NULL;
34187 }
34188
34189
34190 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34191 PyObject *resultobj = 0;
34192 wxWindow *arg1 = (wxWindow *) 0 ;
34193 wxPoint result;
34194 void *argp1 = 0 ;
34195 int res1 = 0 ;
34196 PyObject *swig_obj[1] ;
34197
34198 if (!args) SWIG_fail;
34199 swig_obj[0] = args;
34200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34201 if (!SWIG_IsOK(res1)) {
34202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34203 }
34204 arg1 = reinterpret_cast< wxWindow * >(argp1);
34205 {
34206 PyThreadState* __tstate = wxPyBeginAllowThreads();
34207 result = ((wxWindow const *)arg1)->GetPosition();
34208 wxPyEndAllowThreads(__tstate);
34209 if (PyErr_Occurred()) SWIG_fail;
34210 }
34211 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34212 return resultobj;
34213 fail:
34214 return NULL;
34215 }
34216
34217
34218 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34219 PyObject *resultobj = 0;
34220 wxWindow *arg1 = (wxWindow *) 0 ;
34221 int *arg2 = (int *) 0 ;
34222 int *arg3 = (int *) 0 ;
34223 void *argp1 = 0 ;
34224 int res1 = 0 ;
34225 int temp2 ;
34226 int res2 = SWIG_TMPOBJ ;
34227 int temp3 ;
34228 int res3 = SWIG_TMPOBJ ;
34229 PyObject *swig_obj[1] ;
34230
34231 arg2 = &temp2;
34232 arg3 = &temp3;
34233 if (!args) SWIG_fail;
34234 swig_obj[0] = args;
34235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34236 if (!SWIG_IsOK(res1)) {
34237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34238 }
34239 arg1 = reinterpret_cast< wxWindow * >(argp1);
34240 {
34241 PyThreadState* __tstate = wxPyBeginAllowThreads();
34242 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34243 wxPyEndAllowThreads(__tstate);
34244 if (PyErr_Occurred()) SWIG_fail;
34245 }
34246 resultobj = SWIG_Py_Void();
34247 if (SWIG_IsTmpObj(res2)) {
34248 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34249 } else {
34250 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34251 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34252 }
34253 if (SWIG_IsTmpObj(res3)) {
34254 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34255 } else {
34256 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34257 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34258 }
34259 return resultobj;
34260 fail:
34261 return NULL;
34262 }
34263
34264
34265 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34266 PyObject *resultobj = 0;
34267 wxWindow *arg1 = (wxWindow *) 0 ;
34268 wxPoint result;
34269 void *argp1 = 0 ;
34270 int res1 = 0 ;
34271 PyObject *swig_obj[1] ;
34272
34273 if (!args) SWIG_fail;
34274 swig_obj[0] = args;
34275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34276 if (!SWIG_IsOK(res1)) {
34277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34278 }
34279 arg1 = reinterpret_cast< wxWindow * >(argp1);
34280 {
34281 PyThreadState* __tstate = wxPyBeginAllowThreads();
34282 result = ((wxWindow const *)arg1)->GetScreenPosition();
34283 wxPyEndAllowThreads(__tstate);
34284 if (PyErr_Occurred()) SWIG_fail;
34285 }
34286 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34287 return resultobj;
34288 fail:
34289 return NULL;
34290 }
34291
34292
34293 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34294 PyObject *resultobj = 0;
34295 wxWindow *arg1 = (wxWindow *) 0 ;
34296 int *arg2 = (int *) 0 ;
34297 int *arg3 = (int *) 0 ;
34298 void *argp1 = 0 ;
34299 int res1 = 0 ;
34300 int temp2 ;
34301 int res2 = SWIG_TMPOBJ ;
34302 int temp3 ;
34303 int res3 = SWIG_TMPOBJ ;
34304 PyObject *swig_obj[1] ;
34305
34306 arg2 = &temp2;
34307 arg3 = &temp3;
34308 if (!args) SWIG_fail;
34309 swig_obj[0] = args;
34310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34311 if (!SWIG_IsOK(res1)) {
34312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34313 }
34314 arg1 = reinterpret_cast< wxWindow * >(argp1);
34315 {
34316 PyThreadState* __tstate = wxPyBeginAllowThreads();
34317 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34318 wxPyEndAllowThreads(__tstate);
34319 if (PyErr_Occurred()) SWIG_fail;
34320 }
34321 resultobj = SWIG_Py_Void();
34322 if (SWIG_IsTmpObj(res2)) {
34323 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34324 } else {
34325 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34326 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34327 }
34328 if (SWIG_IsTmpObj(res3)) {
34329 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34330 } else {
34331 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34332 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34333 }
34334 return resultobj;
34335 fail:
34336 return NULL;
34337 }
34338
34339
34340 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34341 PyObject *resultobj = 0;
34342 wxWindow *arg1 = (wxWindow *) 0 ;
34343 wxRect result;
34344 void *argp1 = 0 ;
34345 int res1 = 0 ;
34346 PyObject *swig_obj[1] ;
34347
34348 if (!args) SWIG_fail;
34349 swig_obj[0] = args;
34350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34351 if (!SWIG_IsOK(res1)) {
34352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34353 }
34354 arg1 = reinterpret_cast< wxWindow * >(argp1);
34355 {
34356 PyThreadState* __tstate = wxPyBeginAllowThreads();
34357 result = ((wxWindow const *)arg1)->GetScreenRect();
34358 wxPyEndAllowThreads(__tstate);
34359 if (PyErr_Occurred()) SWIG_fail;
34360 }
34361 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34362 return resultobj;
34363 fail:
34364 return NULL;
34365 }
34366
34367
34368 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34369 PyObject *resultobj = 0;
34370 wxWindow *arg1 = (wxWindow *) 0 ;
34371 wxSize result;
34372 void *argp1 = 0 ;
34373 int res1 = 0 ;
34374 PyObject *swig_obj[1] ;
34375
34376 if (!args) SWIG_fail;
34377 swig_obj[0] = args;
34378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34379 if (!SWIG_IsOK(res1)) {
34380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34381 }
34382 arg1 = reinterpret_cast< wxWindow * >(argp1);
34383 {
34384 PyThreadState* __tstate = wxPyBeginAllowThreads();
34385 result = ((wxWindow const *)arg1)->GetSize();
34386 wxPyEndAllowThreads(__tstate);
34387 if (PyErr_Occurred()) SWIG_fail;
34388 }
34389 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34390 return resultobj;
34391 fail:
34392 return NULL;
34393 }
34394
34395
34396 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34397 PyObject *resultobj = 0;
34398 wxWindow *arg1 = (wxWindow *) 0 ;
34399 int *arg2 = (int *) 0 ;
34400 int *arg3 = (int *) 0 ;
34401 void *argp1 = 0 ;
34402 int res1 = 0 ;
34403 int temp2 ;
34404 int res2 = SWIG_TMPOBJ ;
34405 int temp3 ;
34406 int res3 = SWIG_TMPOBJ ;
34407 PyObject *swig_obj[1] ;
34408
34409 arg2 = &temp2;
34410 arg3 = &temp3;
34411 if (!args) SWIG_fail;
34412 swig_obj[0] = args;
34413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34414 if (!SWIG_IsOK(res1)) {
34415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34416 }
34417 arg1 = reinterpret_cast< wxWindow * >(argp1);
34418 {
34419 PyThreadState* __tstate = wxPyBeginAllowThreads();
34420 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34421 wxPyEndAllowThreads(__tstate);
34422 if (PyErr_Occurred()) SWIG_fail;
34423 }
34424 resultobj = SWIG_Py_Void();
34425 if (SWIG_IsTmpObj(res2)) {
34426 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34427 } else {
34428 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34429 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34430 }
34431 if (SWIG_IsTmpObj(res3)) {
34432 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34433 } else {
34434 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34435 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34436 }
34437 return resultobj;
34438 fail:
34439 return NULL;
34440 }
34441
34442
34443 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34444 PyObject *resultobj = 0;
34445 wxWindow *arg1 = (wxWindow *) 0 ;
34446 wxRect result;
34447 void *argp1 = 0 ;
34448 int res1 = 0 ;
34449 PyObject *swig_obj[1] ;
34450
34451 if (!args) SWIG_fail;
34452 swig_obj[0] = args;
34453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34454 if (!SWIG_IsOK(res1)) {
34455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34456 }
34457 arg1 = reinterpret_cast< wxWindow * >(argp1);
34458 {
34459 PyThreadState* __tstate = wxPyBeginAllowThreads();
34460 result = ((wxWindow const *)arg1)->GetRect();
34461 wxPyEndAllowThreads(__tstate);
34462 if (PyErr_Occurred()) SWIG_fail;
34463 }
34464 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34465 return resultobj;
34466 fail:
34467 return NULL;
34468 }
34469
34470
34471 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34472 PyObject *resultobj = 0;
34473 wxWindow *arg1 = (wxWindow *) 0 ;
34474 wxSize result;
34475 void *argp1 = 0 ;
34476 int res1 = 0 ;
34477 PyObject *swig_obj[1] ;
34478
34479 if (!args) SWIG_fail;
34480 swig_obj[0] = args;
34481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34482 if (!SWIG_IsOK(res1)) {
34483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34484 }
34485 arg1 = reinterpret_cast< wxWindow * >(argp1);
34486 {
34487 PyThreadState* __tstate = wxPyBeginAllowThreads();
34488 result = ((wxWindow const *)arg1)->GetClientSize();
34489 wxPyEndAllowThreads(__tstate);
34490 if (PyErr_Occurred()) SWIG_fail;
34491 }
34492 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34493 return resultobj;
34494 fail:
34495 return NULL;
34496 }
34497
34498
34499 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34500 PyObject *resultobj = 0;
34501 wxWindow *arg1 = (wxWindow *) 0 ;
34502 int *arg2 = (int *) 0 ;
34503 int *arg3 = (int *) 0 ;
34504 void *argp1 = 0 ;
34505 int res1 = 0 ;
34506 int temp2 ;
34507 int res2 = SWIG_TMPOBJ ;
34508 int temp3 ;
34509 int res3 = SWIG_TMPOBJ ;
34510 PyObject *swig_obj[1] ;
34511
34512 arg2 = &temp2;
34513 arg3 = &temp3;
34514 if (!args) SWIG_fail;
34515 swig_obj[0] = args;
34516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34517 if (!SWIG_IsOK(res1)) {
34518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34519 }
34520 arg1 = reinterpret_cast< wxWindow * >(argp1);
34521 {
34522 PyThreadState* __tstate = wxPyBeginAllowThreads();
34523 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34524 wxPyEndAllowThreads(__tstate);
34525 if (PyErr_Occurred()) SWIG_fail;
34526 }
34527 resultobj = SWIG_Py_Void();
34528 if (SWIG_IsTmpObj(res2)) {
34529 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34530 } else {
34531 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34532 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34533 }
34534 if (SWIG_IsTmpObj(res3)) {
34535 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34536 } else {
34537 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34538 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34539 }
34540 return resultobj;
34541 fail:
34542 return NULL;
34543 }
34544
34545
34546 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34547 PyObject *resultobj = 0;
34548 wxWindow *arg1 = (wxWindow *) 0 ;
34549 wxPoint result;
34550 void *argp1 = 0 ;
34551 int res1 = 0 ;
34552 PyObject *swig_obj[1] ;
34553
34554 if (!args) SWIG_fail;
34555 swig_obj[0] = args;
34556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34557 if (!SWIG_IsOK(res1)) {
34558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34559 }
34560 arg1 = reinterpret_cast< wxWindow * >(argp1);
34561 {
34562 PyThreadState* __tstate = wxPyBeginAllowThreads();
34563 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34564 wxPyEndAllowThreads(__tstate);
34565 if (PyErr_Occurred()) SWIG_fail;
34566 }
34567 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34568 return resultobj;
34569 fail:
34570 return NULL;
34571 }
34572
34573
34574 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34575 PyObject *resultobj = 0;
34576 wxWindow *arg1 = (wxWindow *) 0 ;
34577 wxRect result;
34578 void *argp1 = 0 ;
34579 int res1 = 0 ;
34580 PyObject *swig_obj[1] ;
34581
34582 if (!args) SWIG_fail;
34583 swig_obj[0] = args;
34584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34585 if (!SWIG_IsOK(res1)) {
34586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34587 }
34588 arg1 = reinterpret_cast< wxWindow * >(argp1);
34589 {
34590 PyThreadState* __tstate = wxPyBeginAllowThreads();
34591 result = ((wxWindow const *)arg1)->GetClientRect();
34592 wxPyEndAllowThreads(__tstate);
34593 if (PyErr_Occurred()) SWIG_fail;
34594 }
34595 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34596 return resultobj;
34597 fail:
34598 return NULL;
34599 }
34600
34601
34602 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34603 PyObject *resultobj = 0;
34604 wxWindow *arg1 = (wxWindow *) 0 ;
34605 wxSize result;
34606 void *argp1 = 0 ;
34607 int res1 = 0 ;
34608 PyObject *swig_obj[1] ;
34609
34610 if (!args) SWIG_fail;
34611 swig_obj[0] = args;
34612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34613 if (!SWIG_IsOK(res1)) {
34614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34615 }
34616 arg1 = reinterpret_cast< wxWindow * >(argp1);
34617 {
34618 PyThreadState* __tstate = wxPyBeginAllowThreads();
34619 result = ((wxWindow const *)arg1)->GetBestSize();
34620 wxPyEndAllowThreads(__tstate);
34621 if (PyErr_Occurred()) SWIG_fail;
34622 }
34623 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34624 return resultobj;
34625 fail:
34626 return NULL;
34627 }
34628
34629
34630 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34631 PyObject *resultobj = 0;
34632 wxWindow *arg1 = (wxWindow *) 0 ;
34633 int *arg2 = (int *) 0 ;
34634 int *arg3 = (int *) 0 ;
34635 void *argp1 = 0 ;
34636 int res1 = 0 ;
34637 int temp2 ;
34638 int res2 = SWIG_TMPOBJ ;
34639 int temp3 ;
34640 int res3 = SWIG_TMPOBJ ;
34641 PyObject *swig_obj[1] ;
34642
34643 arg2 = &temp2;
34644 arg3 = &temp3;
34645 if (!args) SWIG_fail;
34646 swig_obj[0] = args;
34647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34648 if (!SWIG_IsOK(res1)) {
34649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34650 }
34651 arg1 = reinterpret_cast< wxWindow * >(argp1);
34652 {
34653 PyThreadState* __tstate = wxPyBeginAllowThreads();
34654 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34655 wxPyEndAllowThreads(__tstate);
34656 if (PyErr_Occurred()) SWIG_fail;
34657 }
34658 resultobj = SWIG_Py_Void();
34659 if (SWIG_IsTmpObj(res2)) {
34660 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34661 } else {
34662 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34663 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34664 }
34665 if (SWIG_IsTmpObj(res3)) {
34666 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34667 } else {
34668 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34669 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34670 }
34671 return resultobj;
34672 fail:
34673 return NULL;
34674 }
34675
34676
34677 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34678 PyObject *resultobj = 0;
34679 wxWindow *arg1 = (wxWindow *) 0 ;
34680 void *argp1 = 0 ;
34681 int res1 = 0 ;
34682 PyObject *swig_obj[1] ;
34683
34684 if (!args) SWIG_fail;
34685 swig_obj[0] = args;
34686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34687 if (!SWIG_IsOK(res1)) {
34688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34689 }
34690 arg1 = reinterpret_cast< wxWindow * >(argp1);
34691 {
34692 PyThreadState* __tstate = wxPyBeginAllowThreads();
34693 (arg1)->InvalidateBestSize();
34694 wxPyEndAllowThreads(__tstate);
34695 if (PyErr_Occurred()) SWIG_fail;
34696 }
34697 resultobj = SWIG_Py_Void();
34698 return resultobj;
34699 fail:
34700 return NULL;
34701 }
34702
34703
34704 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34705 PyObject *resultobj = 0;
34706 wxWindow *arg1 = (wxWindow *) 0 ;
34707 wxSize *arg2 = 0 ;
34708 void *argp1 = 0 ;
34709 int res1 = 0 ;
34710 wxSize temp2 ;
34711 PyObject * obj0 = 0 ;
34712 PyObject * obj1 = 0 ;
34713 char * kwnames[] = {
34714 (char *) "self",(char *) "size", NULL
34715 };
34716
34717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34719 if (!SWIG_IsOK(res1)) {
34720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34721 }
34722 arg1 = reinterpret_cast< wxWindow * >(argp1);
34723 {
34724 arg2 = &temp2;
34725 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34726 }
34727 {
34728 PyThreadState* __tstate = wxPyBeginAllowThreads();
34729 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34730 wxPyEndAllowThreads(__tstate);
34731 if (PyErr_Occurred()) SWIG_fail;
34732 }
34733 resultobj = SWIG_Py_Void();
34734 return resultobj;
34735 fail:
34736 return NULL;
34737 }
34738
34739
34740 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34741 PyObject *resultobj = 0;
34742 wxWindow *arg1 = (wxWindow *) 0 ;
34743 wxSize result;
34744 void *argp1 = 0 ;
34745 int res1 = 0 ;
34746 PyObject *swig_obj[1] ;
34747
34748 if (!args) SWIG_fail;
34749 swig_obj[0] = args;
34750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34751 if (!SWIG_IsOK(res1)) {
34752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34753 }
34754 arg1 = reinterpret_cast< wxWindow * >(argp1);
34755 {
34756 PyThreadState* __tstate = wxPyBeginAllowThreads();
34757 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
34758 wxPyEndAllowThreads(__tstate);
34759 if (PyErr_Occurred()) SWIG_fail;
34760 }
34761 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34762 return resultobj;
34763 fail:
34764 return NULL;
34765 }
34766
34767
34768 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34769 PyObject *resultobj = 0;
34770 wxWindow *arg1 = (wxWindow *) 0 ;
34771 int arg2 = (int) wxBOTH ;
34772 void *argp1 = 0 ;
34773 int res1 = 0 ;
34774 int val2 ;
34775 int ecode2 = 0 ;
34776 PyObject * obj0 = 0 ;
34777 PyObject * obj1 = 0 ;
34778 char * kwnames[] = {
34779 (char *) "self",(char *) "direction", NULL
34780 };
34781
34782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34784 if (!SWIG_IsOK(res1)) {
34785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34786 }
34787 arg1 = reinterpret_cast< wxWindow * >(argp1);
34788 if (obj1) {
34789 ecode2 = SWIG_AsVal_int(obj1, &val2);
34790 if (!SWIG_IsOK(ecode2)) {
34791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34792 }
34793 arg2 = static_cast< int >(val2);
34794 }
34795 {
34796 PyThreadState* __tstate = wxPyBeginAllowThreads();
34797 (arg1)->Center(arg2);
34798 wxPyEndAllowThreads(__tstate);
34799 if (PyErr_Occurred()) SWIG_fail;
34800 }
34801 resultobj = SWIG_Py_Void();
34802 return resultobj;
34803 fail:
34804 return NULL;
34805 }
34806
34807
34808 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34809 PyObject *resultobj = 0;
34810 wxWindow *arg1 = (wxWindow *) 0 ;
34811 int arg2 = (int) wxBOTH ;
34812 void *argp1 = 0 ;
34813 int res1 = 0 ;
34814 int val2 ;
34815 int ecode2 = 0 ;
34816 PyObject * obj0 = 0 ;
34817 PyObject * obj1 = 0 ;
34818 char * kwnames[] = {
34819 (char *) "self",(char *) "dir", NULL
34820 };
34821
34822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34824 if (!SWIG_IsOK(res1)) {
34825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34826 }
34827 arg1 = reinterpret_cast< wxWindow * >(argp1);
34828 if (obj1) {
34829 ecode2 = SWIG_AsVal_int(obj1, &val2);
34830 if (!SWIG_IsOK(ecode2)) {
34831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34832 }
34833 arg2 = static_cast< int >(val2);
34834 }
34835 {
34836 PyThreadState* __tstate = wxPyBeginAllowThreads();
34837 (arg1)->CenterOnParent(arg2);
34838 wxPyEndAllowThreads(__tstate);
34839 if (PyErr_Occurred()) SWIG_fail;
34840 }
34841 resultobj = SWIG_Py_Void();
34842 return resultobj;
34843 fail:
34844 return NULL;
34845 }
34846
34847
34848 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34849 PyObject *resultobj = 0;
34850 wxWindow *arg1 = (wxWindow *) 0 ;
34851 void *argp1 = 0 ;
34852 int res1 = 0 ;
34853 PyObject *swig_obj[1] ;
34854
34855 if (!args) SWIG_fail;
34856 swig_obj[0] = args;
34857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34858 if (!SWIG_IsOK(res1)) {
34859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34860 }
34861 arg1 = reinterpret_cast< wxWindow * >(argp1);
34862 {
34863 PyThreadState* __tstate = wxPyBeginAllowThreads();
34864 (arg1)->Fit();
34865 wxPyEndAllowThreads(__tstate);
34866 if (PyErr_Occurred()) SWIG_fail;
34867 }
34868 resultobj = SWIG_Py_Void();
34869 return resultobj;
34870 fail:
34871 return NULL;
34872 }
34873
34874
34875 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34876 PyObject *resultobj = 0;
34877 wxWindow *arg1 = (wxWindow *) 0 ;
34878 void *argp1 = 0 ;
34879 int res1 = 0 ;
34880 PyObject *swig_obj[1] ;
34881
34882 if (!args) SWIG_fail;
34883 swig_obj[0] = args;
34884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34885 if (!SWIG_IsOK(res1)) {
34886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34887 }
34888 arg1 = reinterpret_cast< wxWindow * >(argp1);
34889 {
34890 PyThreadState* __tstate = wxPyBeginAllowThreads();
34891 (arg1)->FitInside();
34892 wxPyEndAllowThreads(__tstate);
34893 if (PyErr_Occurred()) SWIG_fail;
34894 }
34895 resultobj = SWIG_Py_Void();
34896 return resultobj;
34897 fail:
34898 return NULL;
34899 }
34900
34901
34902 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34903 PyObject *resultobj = 0;
34904 wxWindow *arg1 = (wxWindow *) 0 ;
34905 int arg2 ;
34906 int arg3 ;
34907 int arg4 = (int) -1 ;
34908 int arg5 = (int) -1 ;
34909 int arg6 = (int) -1 ;
34910 int arg7 = (int) -1 ;
34911 void *argp1 = 0 ;
34912 int res1 = 0 ;
34913 int val2 ;
34914 int ecode2 = 0 ;
34915 int val3 ;
34916 int ecode3 = 0 ;
34917 int val4 ;
34918 int ecode4 = 0 ;
34919 int val5 ;
34920 int ecode5 = 0 ;
34921 int val6 ;
34922 int ecode6 = 0 ;
34923 int val7 ;
34924 int ecode7 = 0 ;
34925 PyObject * obj0 = 0 ;
34926 PyObject * obj1 = 0 ;
34927 PyObject * obj2 = 0 ;
34928 PyObject * obj3 = 0 ;
34929 PyObject * obj4 = 0 ;
34930 PyObject * obj5 = 0 ;
34931 PyObject * obj6 = 0 ;
34932 char * kwnames[] = {
34933 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34934 };
34935
34936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34938 if (!SWIG_IsOK(res1)) {
34939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34940 }
34941 arg1 = reinterpret_cast< wxWindow * >(argp1);
34942 ecode2 = SWIG_AsVal_int(obj1, &val2);
34943 if (!SWIG_IsOK(ecode2)) {
34944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34945 }
34946 arg2 = static_cast< int >(val2);
34947 ecode3 = SWIG_AsVal_int(obj2, &val3);
34948 if (!SWIG_IsOK(ecode3)) {
34949 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34950 }
34951 arg3 = static_cast< int >(val3);
34952 if (obj3) {
34953 ecode4 = SWIG_AsVal_int(obj3, &val4);
34954 if (!SWIG_IsOK(ecode4)) {
34955 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34956 }
34957 arg4 = static_cast< int >(val4);
34958 }
34959 if (obj4) {
34960 ecode5 = SWIG_AsVal_int(obj4, &val5);
34961 if (!SWIG_IsOK(ecode5)) {
34962 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34963 }
34964 arg5 = static_cast< int >(val5);
34965 }
34966 if (obj5) {
34967 ecode6 = SWIG_AsVal_int(obj5, &val6);
34968 if (!SWIG_IsOK(ecode6)) {
34969 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34970 }
34971 arg6 = static_cast< int >(val6);
34972 }
34973 if (obj6) {
34974 ecode7 = SWIG_AsVal_int(obj6, &val7);
34975 if (!SWIG_IsOK(ecode7)) {
34976 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34977 }
34978 arg7 = static_cast< int >(val7);
34979 }
34980 {
34981 PyThreadState* __tstate = wxPyBeginAllowThreads();
34982 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
34983 wxPyEndAllowThreads(__tstate);
34984 if (PyErr_Occurred()) SWIG_fail;
34985 }
34986 resultobj = SWIG_Py_Void();
34987 return resultobj;
34988 fail:
34989 return NULL;
34990 }
34991
34992
34993 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34994 PyObject *resultobj = 0;
34995 wxWindow *arg1 = (wxWindow *) 0 ;
34996 wxSize *arg2 = 0 ;
34997 wxSize const &arg3_defvalue = wxDefaultSize ;
34998 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34999 wxSize const &arg4_defvalue = wxDefaultSize ;
35000 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
35001 void *argp1 = 0 ;
35002 int res1 = 0 ;
35003 wxSize temp2 ;
35004 wxSize temp3 ;
35005 wxSize temp4 ;
35006 PyObject * obj0 = 0 ;
35007 PyObject * obj1 = 0 ;
35008 PyObject * obj2 = 0 ;
35009 PyObject * obj3 = 0 ;
35010 char * kwnames[] = {
35011 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
35012 };
35013
35014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35016 if (!SWIG_IsOK(res1)) {
35017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35018 }
35019 arg1 = reinterpret_cast< wxWindow * >(argp1);
35020 {
35021 arg2 = &temp2;
35022 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35023 }
35024 if (obj2) {
35025 {
35026 arg3 = &temp3;
35027 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35028 }
35029 }
35030 if (obj3) {
35031 {
35032 arg4 = &temp4;
35033 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
35034 }
35035 }
35036 {
35037 PyThreadState* __tstate = wxPyBeginAllowThreads();
35038 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
35039 wxPyEndAllowThreads(__tstate);
35040 if (PyErr_Occurred()) SWIG_fail;
35041 }
35042 resultobj = SWIG_Py_Void();
35043 return resultobj;
35044 fail:
35045 return NULL;
35046 }
35047
35048
35049 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35050 PyObject *resultobj = 0;
35051 wxWindow *arg1 = (wxWindow *) 0 ;
35052 int arg2 ;
35053 int arg3 ;
35054 int arg4 = (int) -1 ;
35055 int arg5 = (int) -1 ;
35056 void *argp1 = 0 ;
35057 int res1 = 0 ;
35058 int val2 ;
35059 int ecode2 = 0 ;
35060 int val3 ;
35061 int ecode3 = 0 ;
35062 int val4 ;
35063 int ecode4 = 0 ;
35064 int val5 ;
35065 int ecode5 = 0 ;
35066 PyObject * obj0 = 0 ;
35067 PyObject * obj1 = 0 ;
35068 PyObject * obj2 = 0 ;
35069 PyObject * obj3 = 0 ;
35070 PyObject * obj4 = 0 ;
35071 char * kwnames[] = {
35072 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
35073 };
35074
35075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35077 if (!SWIG_IsOK(res1)) {
35078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
35079 }
35080 arg1 = reinterpret_cast< wxWindow * >(argp1);
35081 ecode2 = SWIG_AsVal_int(obj1, &val2);
35082 if (!SWIG_IsOK(ecode2)) {
35083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
35084 }
35085 arg2 = static_cast< int >(val2);
35086 ecode3 = SWIG_AsVal_int(obj2, &val3);
35087 if (!SWIG_IsOK(ecode3)) {
35088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
35089 }
35090 arg3 = static_cast< int >(val3);
35091 if (obj3) {
35092 ecode4 = SWIG_AsVal_int(obj3, &val4);
35093 if (!SWIG_IsOK(ecode4)) {
35094 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
35095 }
35096 arg4 = static_cast< int >(val4);
35097 }
35098 if (obj4) {
35099 ecode5 = SWIG_AsVal_int(obj4, &val5);
35100 if (!SWIG_IsOK(ecode5)) {
35101 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
35102 }
35103 arg5 = static_cast< int >(val5);
35104 }
35105 {
35106 PyThreadState* __tstate = wxPyBeginAllowThreads();
35107 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
35108 wxPyEndAllowThreads(__tstate);
35109 if (PyErr_Occurred()) SWIG_fail;
35110 }
35111 resultobj = SWIG_Py_Void();
35112 return resultobj;
35113 fail:
35114 return NULL;
35115 }
35116
35117
35118 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35119 PyObject *resultobj = 0;
35120 wxWindow *arg1 = (wxWindow *) 0 ;
35121 wxSize *arg2 = 0 ;
35122 wxSize const &arg3_defvalue = wxDefaultSize ;
35123 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35124 void *argp1 = 0 ;
35125 int res1 = 0 ;
35126 wxSize temp2 ;
35127 wxSize temp3 ;
35128 PyObject * obj0 = 0 ;
35129 PyObject * obj1 = 0 ;
35130 PyObject * obj2 = 0 ;
35131 char * kwnames[] = {
35132 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
35133 };
35134
35135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35137 if (!SWIG_IsOK(res1)) {
35138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35139 }
35140 arg1 = reinterpret_cast< wxWindow * >(argp1);
35141 {
35142 arg2 = &temp2;
35143 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35144 }
35145 if (obj2) {
35146 {
35147 arg3 = &temp3;
35148 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35149 }
35150 }
35151 {
35152 PyThreadState* __tstate = wxPyBeginAllowThreads();
35153 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35154 wxPyEndAllowThreads(__tstate);
35155 if (PyErr_Occurred()) SWIG_fail;
35156 }
35157 resultobj = SWIG_Py_Void();
35158 return resultobj;
35159 fail:
35160 return NULL;
35161 }
35162
35163
35164 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35165 PyObject *resultobj = 0;
35166 wxWindow *arg1 = (wxWindow *) 0 ;
35167 wxSize result;
35168 void *argp1 = 0 ;
35169 int res1 = 0 ;
35170 PyObject *swig_obj[1] ;
35171
35172 if (!args) SWIG_fail;
35173 swig_obj[0] = args;
35174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35175 if (!SWIG_IsOK(res1)) {
35176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35177 }
35178 arg1 = reinterpret_cast< wxWindow * >(argp1);
35179 {
35180 PyThreadState* __tstate = wxPyBeginAllowThreads();
35181 result = ((wxWindow const *)arg1)->GetMaxSize();
35182 wxPyEndAllowThreads(__tstate);
35183 if (PyErr_Occurred()) SWIG_fail;
35184 }
35185 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35186 return resultobj;
35187 fail:
35188 return NULL;
35189 }
35190
35191
35192 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35193 PyObject *resultobj = 0;
35194 wxWindow *arg1 = (wxWindow *) 0 ;
35195 wxSize result;
35196 void *argp1 = 0 ;
35197 int res1 = 0 ;
35198 PyObject *swig_obj[1] ;
35199
35200 if (!args) SWIG_fail;
35201 swig_obj[0] = args;
35202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35203 if (!SWIG_IsOK(res1)) {
35204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35205 }
35206 arg1 = reinterpret_cast< wxWindow * >(argp1);
35207 {
35208 PyThreadState* __tstate = wxPyBeginAllowThreads();
35209 result = ((wxWindow const *)arg1)->GetMinSize();
35210 wxPyEndAllowThreads(__tstate);
35211 if (PyErr_Occurred()) SWIG_fail;
35212 }
35213 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35214 return resultobj;
35215 fail:
35216 return NULL;
35217 }
35218
35219
35220 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35221 PyObject *resultobj = 0;
35222 wxWindow *arg1 = (wxWindow *) 0 ;
35223 wxSize *arg2 = 0 ;
35224 void *argp1 = 0 ;
35225 int res1 = 0 ;
35226 wxSize temp2 ;
35227 PyObject * obj0 = 0 ;
35228 PyObject * obj1 = 0 ;
35229 char * kwnames[] = {
35230 (char *) "self",(char *) "minSize", NULL
35231 };
35232
35233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35235 if (!SWIG_IsOK(res1)) {
35236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35237 }
35238 arg1 = reinterpret_cast< wxWindow * >(argp1);
35239 {
35240 arg2 = &temp2;
35241 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35242 }
35243 {
35244 PyThreadState* __tstate = wxPyBeginAllowThreads();
35245 (arg1)->SetMinSize((wxSize const &)*arg2);
35246 wxPyEndAllowThreads(__tstate);
35247 if (PyErr_Occurred()) SWIG_fail;
35248 }
35249 resultobj = SWIG_Py_Void();
35250 return resultobj;
35251 fail:
35252 return NULL;
35253 }
35254
35255
35256 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35257 PyObject *resultobj = 0;
35258 wxWindow *arg1 = (wxWindow *) 0 ;
35259 wxSize *arg2 = 0 ;
35260 void *argp1 = 0 ;
35261 int res1 = 0 ;
35262 wxSize temp2 ;
35263 PyObject * obj0 = 0 ;
35264 PyObject * obj1 = 0 ;
35265 char * kwnames[] = {
35266 (char *) "self",(char *) "maxSize", NULL
35267 };
35268
35269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35271 if (!SWIG_IsOK(res1)) {
35272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35273 }
35274 arg1 = reinterpret_cast< wxWindow * >(argp1);
35275 {
35276 arg2 = &temp2;
35277 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35278 }
35279 {
35280 PyThreadState* __tstate = wxPyBeginAllowThreads();
35281 (arg1)->SetMaxSize((wxSize const &)*arg2);
35282 wxPyEndAllowThreads(__tstate);
35283 if (PyErr_Occurred()) SWIG_fail;
35284 }
35285 resultobj = SWIG_Py_Void();
35286 return resultobj;
35287 fail:
35288 return NULL;
35289 }
35290
35291
35292 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35293 PyObject *resultobj = 0;
35294 wxWindow *arg1 = (wxWindow *) 0 ;
35295 int result;
35296 void *argp1 = 0 ;
35297 int res1 = 0 ;
35298 PyObject *swig_obj[1] ;
35299
35300 if (!args) SWIG_fail;
35301 swig_obj[0] = args;
35302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35303 if (!SWIG_IsOK(res1)) {
35304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35305 }
35306 arg1 = reinterpret_cast< wxWindow * >(argp1);
35307 {
35308 PyThreadState* __tstate = wxPyBeginAllowThreads();
35309 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35310 wxPyEndAllowThreads(__tstate);
35311 if (PyErr_Occurred()) SWIG_fail;
35312 }
35313 resultobj = SWIG_From_int(static_cast< int >(result));
35314 return resultobj;
35315 fail:
35316 return NULL;
35317 }
35318
35319
35320 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35321 PyObject *resultobj = 0;
35322 wxWindow *arg1 = (wxWindow *) 0 ;
35323 int result;
35324 void *argp1 = 0 ;
35325 int res1 = 0 ;
35326 PyObject *swig_obj[1] ;
35327
35328 if (!args) SWIG_fail;
35329 swig_obj[0] = args;
35330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35331 if (!SWIG_IsOK(res1)) {
35332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35333 }
35334 arg1 = reinterpret_cast< wxWindow * >(argp1);
35335 {
35336 PyThreadState* __tstate = wxPyBeginAllowThreads();
35337 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35338 wxPyEndAllowThreads(__tstate);
35339 if (PyErr_Occurred()) SWIG_fail;
35340 }
35341 resultobj = SWIG_From_int(static_cast< int >(result));
35342 return resultobj;
35343 fail:
35344 return NULL;
35345 }
35346
35347
35348 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35349 PyObject *resultobj = 0;
35350 wxWindow *arg1 = (wxWindow *) 0 ;
35351 int result;
35352 void *argp1 = 0 ;
35353 int res1 = 0 ;
35354 PyObject *swig_obj[1] ;
35355
35356 if (!args) SWIG_fail;
35357 swig_obj[0] = args;
35358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35359 if (!SWIG_IsOK(res1)) {
35360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35361 }
35362 arg1 = reinterpret_cast< wxWindow * >(argp1);
35363 {
35364 PyThreadState* __tstate = wxPyBeginAllowThreads();
35365 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35366 wxPyEndAllowThreads(__tstate);
35367 if (PyErr_Occurred()) SWIG_fail;
35368 }
35369 resultobj = SWIG_From_int(static_cast< int >(result));
35370 return resultobj;
35371 fail:
35372 return NULL;
35373 }
35374
35375
35376 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35377 PyObject *resultobj = 0;
35378 wxWindow *arg1 = (wxWindow *) 0 ;
35379 int result;
35380 void *argp1 = 0 ;
35381 int res1 = 0 ;
35382 PyObject *swig_obj[1] ;
35383
35384 if (!args) SWIG_fail;
35385 swig_obj[0] = args;
35386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35387 if (!SWIG_IsOK(res1)) {
35388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35389 }
35390 arg1 = reinterpret_cast< wxWindow * >(argp1);
35391 {
35392 PyThreadState* __tstate = wxPyBeginAllowThreads();
35393 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35394 wxPyEndAllowThreads(__tstate);
35395 if (PyErr_Occurred()) SWIG_fail;
35396 }
35397 resultobj = SWIG_From_int(static_cast< int >(result));
35398 return resultobj;
35399 fail:
35400 return NULL;
35401 }
35402
35403
35404 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35405 PyObject *resultobj = 0;
35406 wxWindow *arg1 = (wxWindow *) 0 ;
35407 wxSize *arg2 = 0 ;
35408 void *argp1 = 0 ;
35409 int res1 = 0 ;
35410 wxSize temp2 ;
35411 PyObject * obj0 = 0 ;
35412 PyObject * obj1 = 0 ;
35413 char * kwnames[] = {
35414 (char *) "self",(char *) "size", NULL
35415 };
35416
35417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35419 if (!SWIG_IsOK(res1)) {
35420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35421 }
35422 arg1 = reinterpret_cast< wxWindow * >(argp1);
35423 {
35424 arg2 = &temp2;
35425 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35426 }
35427 {
35428 PyThreadState* __tstate = wxPyBeginAllowThreads();
35429 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35430 wxPyEndAllowThreads(__tstate);
35431 if (PyErr_Occurred()) SWIG_fail;
35432 }
35433 resultobj = SWIG_Py_Void();
35434 return resultobj;
35435 fail:
35436 return NULL;
35437 }
35438
35439
35440 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35441 PyObject *resultobj = 0;
35442 wxWindow *arg1 = (wxWindow *) 0 ;
35443 int arg2 ;
35444 int arg3 ;
35445 void *argp1 = 0 ;
35446 int res1 = 0 ;
35447 int val2 ;
35448 int ecode2 = 0 ;
35449 int val3 ;
35450 int ecode3 = 0 ;
35451 PyObject * obj0 = 0 ;
35452 PyObject * obj1 = 0 ;
35453 PyObject * obj2 = 0 ;
35454 char * kwnames[] = {
35455 (char *) "self",(char *) "w",(char *) "h", NULL
35456 };
35457
35458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35460 if (!SWIG_IsOK(res1)) {
35461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35462 }
35463 arg1 = reinterpret_cast< wxWindow * >(argp1);
35464 ecode2 = SWIG_AsVal_int(obj1, &val2);
35465 if (!SWIG_IsOK(ecode2)) {
35466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35467 }
35468 arg2 = static_cast< int >(val2);
35469 ecode3 = SWIG_AsVal_int(obj2, &val3);
35470 if (!SWIG_IsOK(ecode3)) {
35471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35472 }
35473 arg3 = static_cast< int >(val3);
35474 {
35475 PyThreadState* __tstate = wxPyBeginAllowThreads();
35476 (arg1)->SetVirtualSize(arg2,arg3);
35477 wxPyEndAllowThreads(__tstate);
35478 if (PyErr_Occurred()) SWIG_fail;
35479 }
35480 resultobj = SWIG_Py_Void();
35481 return resultobj;
35482 fail:
35483 return NULL;
35484 }
35485
35486
35487 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35488 PyObject *resultobj = 0;
35489 wxWindow *arg1 = (wxWindow *) 0 ;
35490 wxSize result;
35491 void *argp1 = 0 ;
35492 int res1 = 0 ;
35493 PyObject *swig_obj[1] ;
35494
35495 if (!args) SWIG_fail;
35496 swig_obj[0] = args;
35497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35498 if (!SWIG_IsOK(res1)) {
35499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35500 }
35501 arg1 = reinterpret_cast< wxWindow * >(argp1);
35502 {
35503 PyThreadState* __tstate = wxPyBeginAllowThreads();
35504 result = ((wxWindow const *)arg1)->GetVirtualSize();
35505 wxPyEndAllowThreads(__tstate);
35506 if (PyErr_Occurred()) SWIG_fail;
35507 }
35508 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35509 return resultobj;
35510 fail:
35511 return NULL;
35512 }
35513
35514
35515 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35516 PyObject *resultobj = 0;
35517 wxWindow *arg1 = (wxWindow *) 0 ;
35518 int *arg2 = (int *) 0 ;
35519 int *arg3 = (int *) 0 ;
35520 void *argp1 = 0 ;
35521 int res1 = 0 ;
35522 int temp2 ;
35523 int res2 = SWIG_TMPOBJ ;
35524 int temp3 ;
35525 int res3 = SWIG_TMPOBJ ;
35526 PyObject *swig_obj[1] ;
35527
35528 arg2 = &temp2;
35529 arg3 = &temp3;
35530 if (!args) SWIG_fail;
35531 swig_obj[0] = args;
35532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35533 if (!SWIG_IsOK(res1)) {
35534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35535 }
35536 arg1 = reinterpret_cast< wxWindow * >(argp1);
35537 {
35538 PyThreadState* __tstate = wxPyBeginAllowThreads();
35539 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35540 wxPyEndAllowThreads(__tstate);
35541 if (PyErr_Occurred()) SWIG_fail;
35542 }
35543 resultobj = SWIG_Py_Void();
35544 if (SWIG_IsTmpObj(res2)) {
35545 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35546 } else {
35547 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35548 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35549 }
35550 if (SWIG_IsTmpObj(res3)) {
35551 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35552 } else {
35553 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35554 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35555 }
35556 return resultobj;
35557 fail:
35558 return NULL;
35559 }
35560
35561
35562 SWIGINTERN PyObject *_wrap_Window_GetWindowBorderSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35563 PyObject *resultobj = 0;
35564 wxWindow *arg1 = (wxWindow *) 0 ;
35565 wxSize result;
35566 void *argp1 = 0 ;
35567 int res1 = 0 ;
35568 PyObject *swig_obj[1] ;
35569
35570 if (!args) SWIG_fail;
35571 swig_obj[0] = args;
35572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35573 if (!SWIG_IsOK(res1)) {
35574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowBorderSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35575 }
35576 arg1 = reinterpret_cast< wxWindow * >(argp1);
35577 {
35578 PyThreadState* __tstate = wxPyBeginAllowThreads();
35579 result = ((wxWindow const *)arg1)->GetWindowBorderSize();
35580 wxPyEndAllowThreads(__tstate);
35581 if (PyErr_Occurred()) SWIG_fail;
35582 }
35583 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35584 return resultobj;
35585 fail:
35586 return NULL;
35587 }
35588
35589
35590 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35591 PyObject *resultobj = 0;
35592 wxWindow *arg1 = (wxWindow *) 0 ;
35593 wxSize result;
35594 void *argp1 = 0 ;
35595 int res1 = 0 ;
35596 PyObject *swig_obj[1] ;
35597
35598 if (!args) SWIG_fail;
35599 swig_obj[0] = args;
35600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35601 if (!SWIG_IsOK(res1)) {
35602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35603 }
35604 arg1 = reinterpret_cast< wxWindow * >(argp1);
35605 {
35606 PyThreadState* __tstate = wxPyBeginAllowThreads();
35607 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35608 wxPyEndAllowThreads(__tstate);
35609 if (PyErr_Occurred()) SWIG_fail;
35610 }
35611 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35612 return resultobj;
35613 fail:
35614 return NULL;
35615 }
35616
35617
35618 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35619 PyObject *resultobj = 0;
35620 wxWindow *arg1 = (wxWindow *) 0 ;
35621 bool arg2 = (bool) true ;
35622 bool result;
35623 void *argp1 = 0 ;
35624 int res1 = 0 ;
35625 bool val2 ;
35626 int ecode2 = 0 ;
35627 PyObject * obj0 = 0 ;
35628 PyObject * obj1 = 0 ;
35629 char * kwnames[] = {
35630 (char *) "self",(char *) "show", NULL
35631 };
35632
35633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35635 if (!SWIG_IsOK(res1)) {
35636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35637 }
35638 arg1 = reinterpret_cast< wxWindow * >(argp1);
35639 if (obj1) {
35640 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35641 if (!SWIG_IsOK(ecode2)) {
35642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35643 }
35644 arg2 = static_cast< bool >(val2);
35645 }
35646 {
35647 PyThreadState* __tstate = wxPyBeginAllowThreads();
35648 result = (bool)(arg1)->Show(arg2);
35649 wxPyEndAllowThreads(__tstate);
35650 if (PyErr_Occurred()) SWIG_fail;
35651 }
35652 {
35653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35654 }
35655 return resultobj;
35656 fail:
35657 return NULL;
35658 }
35659
35660
35661 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35662 PyObject *resultobj = 0;
35663 wxWindow *arg1 = (wxWindow *) 0 ;
35664 bool result;
35665 void *argp1 = 0 ;
35666 int res1 = 0 ;
35667 PyObject *swig_obj[1] ;
35668
35669 if (!args) SWIG_fail;
35670 swig_obj[0] = args;
35671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35672 if (!SWIG_IsOK(res1)) {
35673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35674 }
35675 arg1 = reinterpret_cast< wxWindow * >(argp1);
35676 {
35677 PyThreadState* __tstate = wxPyBeginAllowThreads();
35678 result = (bool)(arg1)->Hide();
35679 wxPyEndAllowThreads(__tstate);
35680 if (PyErr_Occurred()) SWIG_fail;
35681 }
35682 {
35683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35684 }
35685 return resultobj;
35686 fail:
35687 return NULL;
35688 }
35689
35690
35691 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35692 PyObject *resultobj = 0;
35693 wxWindow *arg1 = (wxWindow *) 0 ;
35694 bool arg2 = (bool) true ;
35695 bool result;
35696 void *argp1 = 0 ;
35697 int res1 = 0 ;
35698 bool val2 ;
35699 int ecode2 = 0 ;
35700 PyObject * obj0 = 0 ;
35701 PyObject * obj1 = 0 ;
35702 char * kwnames[] = {
35703 (char *) "self",(char *) "enable", NULL
35704 };
35705
35706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35708 if (!SWIG_IsOK(res1)) {
35709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35710 }
35711 arg1 = reinterpret_cast< wxWindow * >(argp1);
35712 if (obj1) {
35713 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35714 if (!SWIG_IsOK(ecode2)) {
35715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35716 }
35717 arg2 = static_cast< bool >(val2);
35718 }
35719 {
35720 PyThreadState* __tstate = wxPyBeginAllowThreads();
35721 result = (bool)(arg1)->Enable(arg2);
35722 wxPyEndAllowThreads(__tstate);
35723 if (PyErr_Occurred()) SWIG_fail;
35724 }
35725 {
35726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35727 }
35728 return resultobj;
35729 fail:
35730 return NULL;
35731 }
35732
35733
35734 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35735 PyObject *resultobj = 0;
35736 wxWindow *arg1 = (wxWindow *) 0 ;
35737 bool result;
35738 void *argp1 = 0 ;
35739 int res1 = 0 ;
35740 PyObject *swig_obj[1] ;
35741
35742 if (!args) SWIG_fail;
35743 swig_obj[0] = args;
35744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35745 if (!SWIG_IsOK(res1)) {
35746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35747 }
35748 arg1 = reinterpret_cast< wxWindow * >(argp1);
35749 {
35750 PyThreadState* __tstate = wxPyBeginAllowThreads();
35751 result = (bool)(arg1)->Disable();
35752 wxPyEndAllowThreads(__tstate);
35753 if (PyErr_Occurred()) SWIG_fail;
35754 }
35755 {
35756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35757 }
35758 return resultobj;
35759 fail:
35760 return NULL;
35761 }
35762
35763
35764 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35765 PyObject *resultobj = 0;
35766 wxWindow *arg1 = (wxWindow *) 0 ;
35767 bool result;
35768 void *argp1 = 0 ;
35769 int res1 = 0 ;
35770 PyObject *swig_obj[1] ;
35771
35772 if (!args) SWIG_fail;
35773 swig_obj[0] = args;
35774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35775 if (!SWIG_IsOK(res1)) {
35776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35777 }
35778 arg1 = reinterpret_cast< wxWindow * >(argp1);
35779 {
35780 PyThreadState* __tstate = wxPyBeginAllowThreads();
35781 result = (bool)((wxWindow const *)arg1)->IsShown();
35782 wxPyEndAllowThreads(__tstate);
35783 if (PyErr_Occurred()) SWIG_fail;
35784 }
35785 {
35786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35787 }
35788 return resultobj;
35789 fail:
35790 return NULL;
35791 }
35792
35793
35794 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35795 PyObject *resultobj = 0;
35796 wxWindow *arg1 = (wxWindow *) 0 ;
35797 bool result;
35798 void *argp1 = 0 ;
35799 int res1 = 0 ;
35800 PyObject *swig_obj[1] ;
35801
35802 if (!args) SWIG_fail;
35803 swig_obj[0] = args;
35804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35805 if (!SWIG_IsOK(res1)) {
35806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35807 }
35808 arg1 = reinterpret_cast< wxWindow * >(argp1);
35809 {
35810 PyThreadState* __tstate = wxPyBeginAllowThreads();
35811 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35812 wxPyEndAllowThreads(__tstate);
35813 if (PyErr_Occurred()) SWIG_fail;
35814 }
35815 {
35816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35817 }
35818 return resultobj;
35819 fail:
35820 return NULL;
35821 }
35822
35823
35824 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35825 PyObject *resultobj = 0;
35826 wxWindow *arg1 = (wxWindow *) 0 ;
35827 bool result;
35828 void *argp1 = 0 ;
35829 int res1 = 0 ;
35830 PyObject *swig_obj[1] ;
35831
35832 if (!args) SWIG_fail;
35833 swig_obj[0] = args;
35834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35835 if (!SWIG_IsOK(res1)) {
35836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35837 }
35838 arg1 = reinterpret_cast< wxWindow * >(argp1);
35839 {
35840 PyThreadState* __tstate = wxPyBeginAllowThreads();
35841 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35842 wxPyEndAllowThreads(__tstate);
35843 if (PyErr_Occurred()) SWIG_fail;
35844 }
35845 {
35846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35847 }
35848 return resultobj;
35849 fail:
35850 return NULL;
35851 }
35852
35853
35854 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35855 PyObject *resultobj = 0;
35856 wxWindow *arg1 = (wxWindow *) 0 ;
35857 long arg2 ;
35858 void *argp1 = 0 ;
35859 int res1 = 0 ;
35860 long val2 ;
35861 int ecode2 = 0 ;
35862 PyObject * obj0 = 0 ;
35863 PyObject * obj1 = 0 ;
35864 char * kwnames[] = {
35865 (char *) "self",(char *) "style", NULL
35866 };
35867
35868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35870 if (!SWIG_IsOK(res1)) {
35871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35872 }
35873 arg1 = reinterpret_cast< wxWindow * >(argp1);
35874 ecode2 = SWIG_AsVal_long(obj1, &val2);
35875 if (!SWIG_IsOK(ecode2)) {
35876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35877 }
35878 arg2 = static_cast< long >(val2);
35879 {
35880 PyThreadState* __tstate = wxPyBeginAllowThreads();
35881 (arg1)->SetWindowStyleFlag(arg2);
35882 wxPyEndAllowThreads(__tstate);
35883 if (PyErr_Occurred()) SWIG_fail;
35884 }
35885 resultobj = SWIG_Py_Void();
35886 return resultobj;
35887 fail:
35888 return NULL;
35889 }
35890
35891
35892 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35893 PyObject *resultobj = 0;
35894 wxWindow *arg1 = (wxWindow *) 0 ;
35895 long result;
35896 void *argp1 = 0 ;
35897 int res1 = 0 ;
35898 PyObject *swig_obj[1] ;
35899
35900 if (!args) SWIG_fail;
35901 swig_obj[0] = args;
35902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35903 if (!SWIG_IsOK(res1)) {
35904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35905 }
35906 arg1 = reinterpret_cast< wxWindow * >(argp1);
35907 {
35908 PyThreadState* __tstate = wxPyBeginAllowThreads();
35909 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35910 wxPyEndAllowThreads(__tstate);
35911 if (PyErr_Occurred()) SWIG_fail;
35912 }
35913 resultobj = SWIG_From_long(static_cast< long >(result));
35914 return resultobj;
35915 fail:
35916 return NULL;
35917 }
35918
35919
35920 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35921 PyObject *resultobj = 0;
35922 wxWindow *arg1 = (wxWindow *) 0 ;
35923 int arg2 ;
35924 bool result;
35925 void *argp1 = 0 ;
35926 int res1 = 0 ;
35927 int val2 ;
35928 int ecode2 = 0 ;
35929 PyObject * obj0 = 0 ;
35930 PyObject * obj1 = 0 ;
35931 char * kwnames[] = {
35932 (char *) "self",(char *) "flag", NULL
35933 };
35934
35935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35937 if (!SWIG_IsOK(res1)) {
35938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35939 }
35940 arg1 = reinterpret_cast< wxWindow * >(argp1);
35941 ecode2 = SWIG_AsVal_int(obj1, &val2);
35942 if (!SWIG_IsOK(ecode2)) {
35943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35944 }
35945 arg2 = static_cast< int >(val2);
35946 {
35947 PyThreadState* __tstate = wxPyBeginAllowThreads();
35948 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35949 wxPyEndAllowThreads(__tstate);
35950 if (PyErr_Occurred()) SWIG_fail;
35951 }
35952 {
35953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35954 }
35955 return resultobj;
35956 fail:
35957 return NULL;
35958 }
35959
35960
35961 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35962 PyObject *resultobj = 0;
35963 wxWindow *arg1 = (wxWindow *) 0 ;
35964 bool result;
35965 void *argp1 = 0 ;
35966 int res1 = 0 ;
35967 PyObject *swig_obj[1] ;
35968
35969 if (!args) SWIG_fail;
35970 swig_obj[0] = args;
35971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35972 if (!SWIG_IsOK(res1)) {
35973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
35974 }
35975 arg1 = reinterpret_cast< wxWindow * >(argp1);
35976 {
35977 PyThreadState* __tstate = wxPyBeginAllowThreads();
35978 result = (bool)((wxWindow const *)arg1)->IsRetained();
35979 wxPyEndAllowThreads(__tstate);
35980 if (PyErr_Occurred()) SWIG_fail;
35981 }
35982 {
35983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35984 }
35985 return resultobj;
35986 fail:
35987 return NULL;
35988 }
35989
35990
35991 SWIGINTERN PyObject *_wrap_Window_ToggleWindowStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35992 PyObject *resultobj = 0;
35993 wxWindow *arg1 = (wxWindow *) 0 ;
35994 int arg2 ;
35995 bool result;
35996 void *argp1 = 0 ;
35997 int res1 = 0 ;
35998 int val2 ;
35999 int ecode2 = 0 ;
36000 PyObject * obj0 = 0 ;
36001 PyObject * obj1 = 0 ;
36002 char * kwnames[] = {
36003 (char *) "self",(char *) "flag", NULL
36004 };
36005
36006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ToggleWindowStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36008 if (!SWIG_IsOK(res1)) {
36009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ToggleWindowStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36010 }
36011 arg1 = reinterpret_cast< wxWindow * >(argp1);
36012 ecode2 = SWIG_AsVal_int(obj1, &val2);
36013 if (!SWIG_IsOK(ecode2)) {
36014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ToggleWindowStyle" "', expected argument " "2"" of type '" "int""'");
36015 }
36016 arg2 = static_cast< int >(val2);
36017 {
36018 PyThreadState* __tstate = wxPyBeginAllowThreads();
36019 result = (bool)(arg1)->ToggleWindowStyle(arg2);
36020 wxPyEndAllowThreads(__tstate);
36021 if (PyErr_Occurred()) SWIG_fail;
36022 }
36023 {
36024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36025 }
36026 return resultobj;
36027 fail:
36028 return NULL;
36029 }
36030
36031
36032 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36033 PyObject *resultobj = 0;
36034 wxWindow *arg1 = (wxWindow *) 0 ;
36035 long arg2 ;
36036 void *argp1 = 0 ;
36037 int res1 = 0 ;
36038 long val2 ;
36039 int ecode2 = 0 ;
36040 PyObject * obj0 = 0 ;
36041 PyObject * obj1 = 0 ;
36042 char * kwnames[] = {
36043 (char *) "self",(char *) "exStyle", NULL
36044 };
36045
36046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36048 if (!SWIG_IsOK(res1)) {
36049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36050 }
36051 arg1 = reinterpret_cast< wxWindow * >(argp1);
36052 ecode2 = SWIG_AsVal_long(obj1, &val2);
36053 if (!SWIG_IsOK(ecode2)) {
36054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
36055 }
36056 arg2 = static_cast< long >(val2);
36057 {
36058 PyThreadState* __tstate = wxPyBeginAllowThreads();
36059 (arg1)->SetExtraStyle(arg2);
36060 wxPyEndAllowThreads(__tstate);
36061 if (PyErr_Occurred()) SWIG_fail;
36062 }
36063 resultobj = SWIG_Py_Void();
36064 return resultobj;
36065 fail:
36066 return NULL;
36067 }
36068
36069
36070 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36071 PyObject *resultobj = 0;
36072 wxWindow *arg1 = (wxWindow *) 0 ;
36073 long result;
36074 void *argp1 = 0 ;
36075 int res1 = 0 ;
36076 PyObject *swig_obj[1] ;
36077
36078 if (!args) SWIG_fail;
36079 swig_obj[0] = args;
36080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36081 if (!SWIG_IsOK(res1)) {
36082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36083 }
36084 arg1 = reinterpret_cast< wxWindow * >(argp1);
36085 {
36086 PyThreadState* __tstate = wxPyBeginAllowThreads();
36087 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
36088 wxPyEndAllowThreads(__tstate);
36089 if (PyErr_Occurred()) SWIG_fail;
36090 }
36091 resultobj = SWIG_From_long(static_cast< long >(result));
36092 return resultobj;
36093 fail:
36094 return NULL;
36095 }
36096
36097
36098 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36099 PyObject *resultobj = 0;
36100 wxWindow *arg1 = (wxWindow *) 0 ;
36101 bool arg2 = (bool) true ;
36102 void *argp1 = 0 ;
36103 int res1 = 0 ;
36104 bool val2 ;
36105 int ecode2 = 0 ;
36106 PyObject * obj0 = 0 ;
36107 PyObject * obj1 = 0 ;
36108 char * kwnames[] = {
36109 (char *) "self",(char *) "modal", NULL
36110 };
36111
36112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
36113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36114 if (!SWIG_IsOK(res1)) {
36115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
36116 }
36117 arg1 = reinterpret_cast< wxWindow * >(argp1);
36118 if (obj1) {
36119 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36120 if (!SWIG_IsOK(ecode2)) {
36121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
36122 }
36123 arg2 = static_cast< bool >(val2);
36124 }
36125 {
36126 PyThreadState* __tstate = wxPyBeginAllowThreads();
36127 (arg1)->MakeModal(arg2);
36128 wxPyEndAllowThreads(__tstate);
36129 if (PyErr_Occurred()) SWIG_fail;
36130 }
36131 resultobj = SWIG_Py_Void();
36132 return resultobj;
36133 fail:
36134 return NULL;
36135 }
36136
36137
36138 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36139 PyObject *resultobj = 0;
36140 wxWindow *arg1 = (wxWindow *) 0 ;
36141 bool arg2 ;
36142 void *argp1 = 0 ;
36143 int res1 = 0 ;
36144 bool val2 ;
36145 int ecode2 = 0 ;
36146 PyObject * obj0 = 0 ;
36147 PyObject * obj1 = 0 ;
36148 char * kwnames[] = {
36149 (char *) "self",(char *) "enableTheme", NULL
36150 };
36151
36152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
36153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36154 if (!SWIG_IsOK(res1)) {
36155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
36156 }
36157 arg1 = reinterpret_cast< wxWindow * >(argp1);
36158 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36159 if (!SWIG_IsOK(ecode2)) {
36160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36161 }
36162 arg2 = static_cast< bool >(val2);
36163 {
36164 PyThreadState* __tstate = wxPyBeginAllowThreads();
36165 (arg1)->SetThemeEnabled(arg2);
36166 wxPyEndAllowThreads(__tstate);
36167 if (PyErr_Occurred()) SWIG_fail;
36168 }
36169 resultobj = SWIG_Py_Void();
36170 return resultobj;
36171 fail:
36172 return NULL;
36173 }
36174
36175
36176 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36177 PyObject *resultobj = 0;
36178 wxWindow *arg1 = (wxWindow *) 0 ;
36179 bool result;
36180 void *argp1 = 0 ;
36181 int res1 = 0 ;
36182 PyObject *swig_obj[1] ;
36183
36184 if (!args) SWIG_fail;
36185 swig_obj[0] = args;
36186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36187 if (!SWIG_IsOK(res1)) {
36188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36189 }
36190 arg1 = reinterpret_cast< wxWindow * >(argp1);
36191 {
36192 PyThreadState* __tstate = wxPyBeginAllowThreads();
36193 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36194 wxPyEndAllowThreads(__tstate);
36195 if (PyErr_Occurred()) SWIG_fail;
36196 }
36197 {
36198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36199 }
36200 return resultobj;
36201 fail:
36202 return NULL;
36203 }
36204
36205
36206 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36207 PyObject *resultobj = 0;
36208 wxWindow *arg1 = (wxWindow *) 0 ;
36209 void *argp1 = 0 ;
36210 int res1 = 0 ;
36211 PyObject *swig_obj[1] ;
36212
36213 if (!args) SWIG_fail;
36214 swig_obj[0] = args;
36215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36216 if (!SWIG_IsOK(res1)) {
36217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36218 }
36219 arg1 = reinterpret_cast< wxWindow * >(argp1);
36220 {
36221 PyThreadState* __tstate = wxPyBeginAllowThreads();
36222 (arg1)->SetFocus();
36223 wxPyEndAllowThreads(__tstate);
36224 if (PyErr_Occurred()) SWIG_fail;
36225 }
36226 resultobj = SWIG_Py_Void();
36227 return resultobj;
36228 fail:
36229 return NULL;
36230 }
36231
36232
36233 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36234 PyObject *resultobj = 0;
36235 wxWindow *arg1 = (wxWindow *) 0 ;
36236 void *argp1 = 0 ;
36237 int res1 = 0 ;
36238 PyObject *swig_obj[1] ;
36239
36240 if (!args) SWIG_fail;
36241 swig_obj[0] = args;
36242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36243 if (!SWIG_IsOK(res1)) {
36244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36245 }
36246 arg1 = reinterpret_cast< wxWindow * >(argp1);
36247 {
36248 PyThreadState* __tstate = wxPyBeginAllowThreads();
36249 (arg1)->SetFocusFromKbd();
36250 wxPyEndAllowThreads(__tstate);
36251 if (PyErr_Occurred()) SWIG_fail;
36252 }
36253 resultobj = SWIG_Py_Void();
36254 return resultobj;
36255 fail:
36256 return NULL;
36257 }
36258
36259
36260 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36261 PyObject *resultobj = 0;
36262 wxWindow *result = 0 ;
36263
36264 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36265 {
36266 if (!wxPyCheckForApp()) SWIG_fail;
36267 PyThreadState* __tstate = wxPyBeginAllowThreads();
36268 result = (wxWindow *)wxWindow::FindFocus();
36269 wxPyEndAllowThreads(__tstate);
36270 if (PyErr_Occurred()) SWIG_fail;
36271 }
36272 {
36273 resultobj = wxPyMake_wxObject(result, 0);
36274 }
36275 return resultobj;
36276 fail:
36277 return NULL;
36278 }
36279
36280
36281 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36282 PyObject *resultobj = 0;
36283 wxWindow *arg1 = (wxWindow *) 0 ;
36284 bool result;
36285 void *argp1 = 0 ;
36286 int res1 = 0 ;
36287 PyObject *swig_obj[1] ;
36288
36289 if (!args) SWIG_fail;
36290 swig_obj[0] = args;
36291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36292 if (!SWIG_IsOK(res1)) {
36293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36294 }
36295 arg1 = reinterpret_cast< wxWindow * >(argp1);
36296 {
36297 PyThreadState* __tstate = wxPyBeginAllowThreads();
36298 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36299 wxPyEndAllowThreads(__tstate);
36300 if (PyErr_Occurred()) SWIG_fail;
36301 }
36302 {
36303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36304 }
36305 return resultobj;
36306 fail:
36307 return NULL;
36308 }
36309
36310
36311 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36312 PyObject *resultobj = 0;
36313 wxWindow *arg1 = (wxWindow *) 0 ;
36314 bool result;
36315 void *argp1 = 0 ;
36316 int res1 = 0 ;
36317 PyObject *swig_obj[1] ;
36318
36319 if (!args) SWIG_fail;
36320 swig_obj[0] = args;
36321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36322 if (!SWIG_IsOK(res1)) {
36323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36324 }
36325 arg1 = reinterpret_cast< wxWindow * >(argp1);
36326 {
36327 PyThreadState* __tstate = wxPyBeginAllowThreads();
36328 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36329 wxPyEndAllowThreads(__tstate);
36330 if (PyErr_Occurred()) SWIG_fail;
36331 }
36332 {
36333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36334 }
36335 return resultobj;
36336 fail:
36337 return NULL;
36338 }
36339
36340
36341 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36342 PyObject *resultobj = 0;
36343 wxWindow *arg1 = (wxWindow *) 0 ;
36344 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36345 bool result;
36346 void *argp1 = 0 ;
36347 int res1 = 0 ;
36348 int val2 ;
36349 int ecode2 = 0 ;
36350 PyObject * obj0 = 0 ;
36351 PyObject * obj1 = 0 ;
36352 char * kwnames[] = {
36353 (char *) "self",(char *) "flags", NULL
36354 };
36355
36356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36358 if (!SWIG_IsOK(res1)) {
36359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36360 }
36361 arg1 = reinterpret_cast< wxWindow * >(argp1);
36362 if (obj1) {
36363 ecode2 = SWIG_AsVal_int(obj1, &val2);
36364 if (!SWIG_IsOK(ecode2)) {
36365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36366 }
36367 arg2 = static_cast< int >(val2);
36368 }
36369 {
36370 PyThreadState* __tstate = wxPyBeginAllowThreads();
36371 result = (bool)(arg1)->Navigate(arg2);
36372 wxPyEndAllowThreads(__tstate);
36373 if (PyErr_Occurred()) SWIG_fail;
36374 }
36375 {
36376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36377 }
36378 return resultobj;
36379 fail:
36380 return NULL;
36381 }
36382
36383
36384 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36385 PyObject *resultobj = 0;
36386 wxWindow *arg1 = (wxWindow *) 0 ;
36387 wxWindow *arg2 = (wxWindow *) 0 ;
36388 void *argp1 = 0 ;
36389 int res1 = 0 ;
36390 void *argp2 = 0 ;
36391 int res2 = 0 ;
36392 PyObject * obj0 = 0 ;
36393 PyObject * obj1 = 0 ;
36394 char * kwnames[] = {
36395 (char *) "self",(char *) "win", NULL
36396 };
36397
36398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36400 if (!SWIG_IsOK(res1)) {
36401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36402 }
36403 arg1 = reinterpret_cast< wxWindow * >(argp1);
36404 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36405 if (!SWIG_IsOK(res2)) {
36406 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36407 }
36408 arg2 = reinterpret_cast< wxWindow * >(argp2);
36409 {
36410 PyThreadState* __tstate = wxPyBeginAllowThreads();
36411 (arg1)->MoveAfterInTabOrder(arg2);
36412 wxPyEndAllowThreads(__tstate);
36413 if (PyErr_Occurred()) SWIG_fail;
36414 }
36415 resultobj = SWIG_Py_Void();
36416 return resultobj;
36417 fail:
36418 return NULL;
36419 }
36420
36421
36422 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36423 PyObject *resultobj = 0;
36424 wxWindow *arg1 = (wxWindow *) 0 ;
36425 wxWindow *arg2 = (wxWindow *) 0 ;
36426 void *argp1 = 0 ;
36427 int res1 = 0 ;
36428 void *argp2 = 0 ;
36429 int res2 = 0 ;
36430 PyObject * obj0 = 0 ;
36431 PyObject * obj1 = 0 ;
36432 char * kwnames[] = {
36433 (char *) "self",(char *) "win", NULL
36434 };
36435
36436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36438 if (!SWIG_IsOK(res1)) {
36439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36440 }
36441 arg1 = reinterpret_cast< wxWindow * >(argp1);
36442 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36443 if (!SWIG_IsOK(res2)) {
36444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36445 }
36446 arg2 = reinterpret_cast< wxWindow * >(argp2);
36447 {
36448 PyThreadState* __tstate = wxPyBeginAllowThreads();
36449 (arg1)->MoveBeforeInTabOrder(arg2);
36450 wxPyEndAllowThreads(__tstate);
36451 if (PyErr_Occurred()) SWIG_fail;
36452 }
36453 resultobj = SWIG_Py_Void();
36454 return resultobj;
36455 fail:
36456 return NULL;
36457 }
36458
36459
36460 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36461 PyObject *resultobj = 0;
36462 wxWindow *arg1 = (wxWindow *) 0 ;
36463 PyObject *result = 0 ;
36464 void *argp1 = 0 ;
36465 int res1 = 0 ;
36466 PyObject *swig_obj[1] ;
36467
36468 if (!args) SWIG_fail;
36469 swig_obj[0] = args;
36470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36471 if (!SWIG_IsOK(res1)) {
36472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36473 }
36474 arg1 = reinterpret_cast< wxWindow * >(argp1);
36475 {
36476 PyThreadState* __tstate = wxPyBeginAllowThreads();
36477 result = (PyObject *)wxWindow_GetChildren(arg1);
36478 wxPyEndAllowThreads(__tstate);
36479 if (PyErr_Occurred()) SWIG_fail;
36480 }
36481 resultobj = result;
36482 return resultobj;
36483 fail:
36484 return NULL;
36485 }
36486
36487
36488 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36489 PyObject *resultobj = 0;
36490 wxWindow *arg1 = (wxWindow *) 0 ;
36491 wxWindow *result = 0 ;
36492 void *argp1 = 0 ;
36493 int res1 = 0 ;
36494 PyObject *swig_obj[1] ;
36495
36496 if (!args) SWIG_fail;
36497 swig_obj[0] = args;
36498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36499 if (!SWIG_IsOK(res1)) {
36500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36501 }
36502 arg1 = reinterpret_cast< wxWindow * >(argp1);
36503 {
36504 PyThreadState* __tstate = wxPyBeginAllowThreads();
36505 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36506 wxPyEndAllowThreads(__tstate);
36507 if (PyErr_Occurred()) SWIG_fail;
36508 }
36509 {
36510 resultobj = wxPyMake_wxObject(result, 0);
36511 }
36512 return resultobj;
36513 fail:
36514 return NULL;
36515 }
36516
36517
36518 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36519 PyObject *resultobj = 0;
36520 wxWindow *arg1 = (wxWindow *) 0 ;
36521 wxWindow *result = 0 ;
36522 void *argp1 = 0 ;
36523 int res1 = 0 ;
36524 PyObject *swig_obj[1] ;
36525
36526 if (!args) SWIG_fail;
36527 swig_obj[0] = args;
36528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36529 if (!SWIG_IsOK(res1)) {
36530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36531 }
36532 arg1 = reinterpret_cast< wxWindow * >(argp1);
36533 {
36534 PyThreadState* __tstate = wxPyBeginAllowThreads();
36535 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36536 wxPyEndAllowThreads(__tstate);
36537 if (PyErr_Occurred()) SWIG_fail;
36538 }
36539 {
36540 resultobj = wxPyMake_wxObject(result, 0);
36541 }
36542 return resultobj;
36543 fail:
36544 return NULL;
36545 }
36546
36547
36548 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36549 PyObject *resultobj = 0;
36550 wxWindow *arg1 = (wxWindow *) 0 ;
36551 bool result;
36552 void *argp1 = 0 ;
36553 int res1 = 0 ;
36554 PyObject *swig_obj[1] ;
36555
36556 if (!args) SWIG_fail;
36557 swig_obj[0] = args;
36558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36559 if (!SWIG_IsOK(res1)) {
36560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36561 }
36562 arg1 = reinterpret_cast< wxWindow * >(argp1);
36563 {
36564 PyThreadState* __tstate = wxPyBeginAllowThreads();
36565 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36566 wxPyEndAllowThreads(__tstate);
36567 if (PyErr_Occurred()) SWIG_fail;
36568 }
36569 {
36570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36571 }
36572 return resultobj;
36573 fail:
36574 return NULL;
36575 }
36576
36577
36578 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36579 PyObject *resultobj = 0;
36580 wxWindow *arg1 = (wxWindow *) 0 ;
36581 wxWindow *arg2 = (wxWindow *) 0 ;
36582 bool result;
36583 void *argp1 = 0 ;
36584 int res1 = 0 ;
36585 void *argp2 = 0 ;
36586 int res2 = 0 ;
36587 PyObject * obj0 = 0 ;
36588 PyObject * obj1 = 0 ;
36589 char * kwnames[] = {
36590 (char *) "self",(char *) "newParent", NULL
36591 };
36592
36593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36595 if (!SWIG_IsOK(res1)) {
36596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36597 }
36598 arg1 = reinterpret_cast< wxWindow * >(argp1);
36599 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36600 if (!SWIG_IsOK(res2)) {
36601 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36602 }
36603 arg2 = reinterpret_cast< wxWindow * >(argp2);
36604 {
36605 PyThreadState* __tstate = wxPyBeginAllowThreads();
36606 result = (bool)(arg1)->Reparent(arg2);
36607 wxPyEndAllowThreads(__tstate);
36608 if (PyErr_Occurred()) SWIG_fail;
36609 }
36610 {
36611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36612 }
36613 return resultobj;
36614 fail:
36615 return NULL;
36616 }
36617
36618
36619 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36620 PyObject *resultobj = 0;
36621 wxWindow *arg1 = (wxWindow *) 0 ;
36622 wxWindow *arg2 = (wxWindow *) 0 ;
36623 void *argp1 = 0 ;
36624 int res1 = 0 ;
36625 void *argp2 = 0 ;
36626 int res2 = 0 ;
36627 PyObject * obj0 = 0 ;
36628 PyObject * obj1 = 0 ;
36629 char * kwnames[] = {
36630 (char *) "self",(char *) "child", NULL
36631 };
36632
36633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36635 if (!SWIG_IsOK(res1)) {
36636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36637 }
36638 arg1 = reinterpret_cast< wxWindow * >(argp1);
36639 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36640 if (!SWIG_IsOK(res2)) {
36641 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36642 }
36643 arg2 = reinterpret_cast< wxWindow * >(argp2);
36644 {
36645 PyThreadState* __tstate = wxPyBeginAllowThreads();
36646 (arg1)->AddChild(arg2);
36647 wxPyEndAllowThreads(__tstate);
36648 if (PyErr_Occurred()) SWIG_fail;
36649 }
36650 resultobj = SWIG_Py_Void();
36651 return resultobj;
36652 fail:
36653 return NULL;
36654 }
36655
36656
36657 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36658 PyObject *resultobj = 0;
36659 wxWindow *arg1 = (wxWindow *) 0 ;
36660 wxWindow *arg2 = (wxWindow *) 0 ;
36661 void *argp1 = 0 ;
36662 int res1 = 0 ;
36663 void *argp2 = 0 ;
36664 int res2 = 0 ;
36665 PyObject * obj0 = 0 ;
36666 PyObject * obj1 = 0 ;
36667 char * kwnames[] = {
36668 (char *) "self",(char *) "child", NULL
36669 };
36670
36671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36673 if (!SWIG_IsOK(res1)) {
36674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36675 }
36676 arg1 = reinterpret_cast< wxWindow * >(argp1);
36677 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36678 if (!SWIG_IsOK(res2)) {
36679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36680 }
36681 arg2 = reinterpret_cast< wxWindow * >(argp2);
36682 {
36683 PyThreadState* __tstate = wxPyBeginAllowThreads();
36684 (arg1)->RemoveChild(arg2);
36685 wxPyEndAllowThreads(__tstate);
36686 if (PyErr_Occurred()) SWIG_fail;
36687 }
36688 resultobj = SWIG_Py_Void();
36689 return resultobj;
36690 fail:
36691 return NULL;
36692 }
36693
36694
36695 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36696 PyObject *resultobj = 0;
36697 wxWindow *arg1 = (wxWindow *) 0 ;
36698 bool arg2 ;
36699 void *argp1 = 0 ;
36700 int res1 = 0 ;
36701 bool val2 ;
36702 int ecode2 = 0 ;
36703 PyObject * obj0 = 0 ;
36704 PyObject * obj1 = 0 ;
36705 char * kwnames[] = {
36706 (char *) "self",(char *) "on", NULL
36707 };
36708
36709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36711 if (!SWIG_IsOK(res1)) {
36712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36713 }
36714 arg1 = reinterpret_cast< wxWindow * >(argp1);
36715 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36716 if (!SWIG_IsOK(ecode2)) {
36717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36718 }
36719 arg2 = static_cast< bool >(val2);
36720 {
36721 PyThreadState* __tstate = wxPyBeginAllowThreads();
36722 (arg1)->SetDoubleBuffered(arg2);
36723 wxPyEndAllowThreads(__tstate);
36724 if (PyErr_Occurred()) SWIG_fail;
36725 }
36726 resultobj = SWIG_Py_Void();
36727 return resultobj;
36728 fail:
36729 return NULL;
36730 }
36731
36732
36733 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36734 PyObject *resultobj = 0;
36735 wxWindow *arg1 = (wxWindow *) 0 ;
36736 long arg2 ;
36737 wxWindow *result = 0 ;
36738 void *argp1 = 0 ;
36739 int res1 = 0 ;
36740 long val2 ;
36741 int ecode2 = 0 ;
36742 PyObject * obj0 = 0 ;
36743 PyObject * obj1 = 0 ;
36744 char * kwnames[] = {
36745 (char *) "self",(char *) "winid", NULL
36746 };
36747
36748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36750 if (!SWIG_IsOK(res1)) {
36751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36752 }
36753 arg1 = reinterpret_cast< wxWindow * >(argp1);
36754 ecode2 = SWIG_AsVal_long(obj1, &val2);
36755 if (!SWIG_IsOK(ecode2)) {
36756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36757 }
36758 arg2 = static_cast< long >(val2);
36759 {
36760 PyThreadState* __tstate = wxPyBeginAllowThreads();
36761 result = (wxWindow *)(arg1)->FindWindow(arg2);
36762 wxPyEndAllowThreads(__tstate);
36763 if (PyErr_Occurred()) SWIG_fail;
36764 }
36765 {
36766 resultobj = wxPyMake_wxObject(result, 0);
36767 }
36768 return resultobj;
36769 fail:
36770 return NULL;
36771 }
36772
36773
36774 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36775 PyObject *resultobj = 0;
36776 wxWindow *arg1 = (wxWindow *) 0 ;
36777 wxString *arg2 = 0 ;
36778 wxWindow *result = 0 ;
36779 void *argp1 = 0 ;
36780 int res1 = 0 ;
36781 bool temp2 = false ;
36782 PyObject * obj0 = 0 ;
36783 PyObject * obj1 = 0 ;
36784 char * kwnames[] = {
36785 (char *) "self",(char *) "name", NULL
36786 };
36787
36788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36790 if (!SWIG_IsOK(res1)) {
36791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36792 }
36793 arg1 = reinterpret_cast< wxWindow * >(argp1);
36794 {
36795 arg2 = wxString_in_helper(obj1);
36796 if (arg2 == NULL) SWIG_fail;
36797 temp2 = true;
36798 }
36799 {
36800 PyThreadState* __tstate = wxPyBeginAllowThreads();
36801 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36802 wxPyEndAllowThreads(__tstate);
36803 if (PyErr_Occurred()) SWIG_fail;
36804 }
36805 {
36806 resultobj = wxPyMake_wxObject(result, 0);
36807 }
36808 {
36809 if (temp2)
36810 delete arg2;
36811 }
36812 return resultobj;
36813 fail:
36814 {
36815 if (temp2)
36816 delete arg2;
36817 }
36818 return NULL;
36819 }
36820
36821
36822 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36823 PyObject *resultobj = 0;
36824 wxWindow *arg1 = (wxWindow *) 0 ;
36825 wxEvtHandler *result = 0 ;
36826 void *argp1 = 0 ;
36827 int res1 = 0 ;
36828 PyObject *swig_obj[1] ;
36829
36830 if (!args) SWIG_fail;
36831 swig_obj[0] = args;
36832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36833 if (!SWIG_IsOK(res1)) {
36834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36835 }
36836 arg1 = reinterpret_cast< wxWindow * >(argp1);
36837 {
36838 PyThreadState* __tstate = wxPyBeginAllowThreads();
36839 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36840 wxPyEndAllowThreads(__tstate);
36841 if (PyErr_Occurred()) SWIG_fail;
36842 }
36843 {
36844 resultobj = wxPyMake_wxObject(result, 0);
36845 }
36846 return resultobj;
36847 fail:
36848 return NULL;
36849 }
36850
36851
36852 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36853 PyObject *resultobj = 0;
36854 wxWindow *arg1 = (wxWindow *) 0 ;
36855 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36856 void *argp1 = 0 ;
36857 int res1 = 0 ;
36858 void *argp2 = 0 ;
36859 int res2 = 0 ;
36860 PyObject * obj0 = 0 ;
36861 PyObject * obj1 = 0 ;
36862 char * kwnames[] = {
36863 (char *) "self",(char *) "handler", NULL
36864 };
36865
36866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36868 if (!SWIG_IsOK(res1)) {
36869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36870 }
36871 arg1 = reinterpret_cast< wxWindow * >(argp1);
36872 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36873 if (!SWIG_IsOK(res2)) {
36874 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36875 }
36876 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36877 {
36878 PyThreadState* __tstate = wxPyBeginAllowThreads();
36879 (arg1)->SetEventHandler(arg2);
36880 wxPyEndAllowThreads(__tstate);
36881 if (PyErr_Occurred()) SWIG_fail;
36882 }
36883 resultobj = SWIG_Py_Void();
36884 return resultobj;
36885 fail:
36886 return NULL;
36887 }
36888
36889
36890 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36891 PyObject *resultobj = 0;
36892 wxWindow *arg1 = (wxWindow *) 0 ;
36893 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36894 void *argp1 = 0 ;
36895 int res1 = 0 ;
36896 void *argp2 = 0 ;
36897 int res2 = 0 ;
36898 PyObject * obj0 = 0 ;
36899 PyObject * obj1 = 0 ;
36900 char * kwnames[] = {
36901 (char *) "self",(char *) "handler", NULL
36902 };
36903
36904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36906 if (!SWIG_IsOK(res1)) {
36907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36908 }
36909 arg1 = reinterpret_cast< wxWindow * >(argp1);
36910 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36911 if (!SWIG_IsOK(res2)) {
36912 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36913 }
36914 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36915 {
36916 PyThreadState* __tstate = wxPyBeginAllowThreads();
36917 (arg1)->PushEventHandler(arg2);
36918 wxPyEndAllowThreads(__tstate);
36919 if (PyErr_Occurred()) SWIG_fail;
36920 }
36921 resultobj = SWIG_Py_Void();
36922 return resultobj;
36923 fail:
36924 return NULL;
36925 }
36926
36927
36928 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36929 PyObject *resultobj = 0;
36930 wxWindow *arg1 = (wxWindow *) 0 ;
36931 bool arg2 = (bool) false ;
36932 wxEvtHandler *result = 0 ;
36933 void *argp1 = 0 ;
36934 int res1 = 0 ;
36935 bool val2 ;
36936 int ecode2 = 0 ;
36937 PyObject * obj0 = 0 ;
36938 PyObject * obj1 = 0 ;
36939 char * kwnames[] = {
36940 (char *) "self",(char *) "deleteHandler", NULL
36941 };
36942
36943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36945 if (!SWIG_IsOK(res1)) {
36946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36947 }
36948 arg1 = reinterpret_cast< wxWindow * >(argp1);
36949 if (obj1) {
36950 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36951 if (!SWIG_IsOK(ecode2)) {
36952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
36953 }
36954 arg2 = static_cast< bool >(val2);
36955 }
36956 {
36957 PyThreadState* __tstate = wxPyBeginAllowThreads();
36958 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
36959 wxPyEndAllowThreads(__tstate);
36960 if (PyErr_Occurred()) SWIG_fail;
36961 }
36962 {
36963 resultobj = wxPyMake_wxObject(result, 0);
36964 }
36965 return resultobj;
36966 fail:
36967 return NULL;
36968 }
36969
36970
36971 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36972 PyObject *resultobj = 0;
36973 wxWindow *arg1 = (wxWindow *) 0 ;
36974 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36975 bool result;
36976 void *argp1 = 0 ;
36977 int res1 = 0 ;
36978 void *argp2 = 0 ;
36979 int res2 = 0 ;
36980 PyObject * obj0 = 0 ;
36981 PyObject * obj1 = 0 ;
36982 char * kwnames[] = {
36983 (char *) "self",(char *) "handler", NULL
36984 };
36985
36986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36988 if (!SWIG_IsOK(res1)) {
36989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36990 }
36991 arg1 = reinterpret_cast< wxWindow * >(argp1);
36992 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36993 if (!SWIG_IsOK(res2)) {
36994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36995 }
36996 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36997 {
36998 PyThreadState* __tstate = wxPyBeginAllowThreads();
36999 result = (bool)(arg1)->RemoveEventHandler(arg2);
37000 wxPyEndAllowThreads(__tstate);
37001 if (PyErr_Occurred()) SWIG_fail;
37002 }
37003 {
37004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37005 }
37006 return resultobj;
37007 fail:
37008 return NULL;
37009 }
37010
37011
37012 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37013 PyObject *resultobj = 0;
37014 wxWindow *arg1 = (wxWindow *) 0 ;
37015 wxValidator *arg2 = 0 ;
37016 void *argp1 = 0 ;
37017 int res1 = 0 ;
37018 void *argp2 = 0 ;
37019 int res2 = 0 ;
37020 PyObject * obj0 = 0 ;
37021 PyObject * obj1 = 0 ;
37022 char * kwnames[] = {
37023 (char *) "self",(char *) "validator", NULL
37024 };
37025
37026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
37027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37028 if (!SWIG_IsOK(res1)) {
37029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37030 }
37031 arg1 = reinterpret_cast< wxWindow * >(argp1);
37032 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
37033 if (!SWIG_IsOK(res2)) {
37034 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37035 }
37036 if (!argp2) {
37037 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37038 }
37039 arg2 = reinterpret_cast< wxValidator * >(argp2);
37040 {
37041 PyThreadState* __tstate = wxPyBeginAllowThreads();
37042 (arg1)->SetValidator((wxValidator const &)*arg2);
37043 wxPyEndAllowThreads(__tstate);
37044 if (PyErr_Occurred()) SWIG_fail;
37045 }
37046 resultobj = SWIG_Py_Void();
37047 return resultobj;
37048 fail:
37049 return NULL;
37050 }
37051
37052
37053 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37054 PyObject *resultobj = 0;
37055 wxWindow *arg1 = (wxWindow *) 0 ;
37056 wxValidator *result = 0 ;
37057 void *argp1 = 0 ;
37058 int res1 = 0 ;
37059 PyObject *swig_obj[1] ;
37060
37061 if (!args) SWIG_fail;
37062 swig_obj[0] = args;
37063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37064 if (!SWIG_IsOK(res1)) {
37065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37066 }
37067 arg1 = reinterpret_cast< wxWindow * >(argp1);
37068 {
37069 PyThreadState* __tstate = wxPyBeginAllowThreads();
37070 result = (wxValidator *)(arg1)->GetValidator();
37071 wxPyEndAllowThreads(__tstate);
37072 if (PyErr_Occurred()) SWIG_fail;
37073 }
37074 {
37075 resultobj = wxPyMake_wxObject(result, (bool)0);
37076 }
37077 return resultobj;
37078 fail:
37079 return NULL;
37080 }
37081
37082
37083 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37084 PyObject *resultobj = 0;
37085 wxWindow *arg1 = (wxWindow *) 0 ;
37086 bool result;
37087 void *argp1 = 0 ;
37088 int res1 = 0 ;
37089 PyObject *swig_obj[1] ;
37090
37091 if (!args) SWIG_fail;
37092 swig_obj[0] = args;
37093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37094 if (!SWIG_IsOK(res1)) {
37095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
37096 }
37097 arg1 = reinterpret_cast< wxWindow * >(argp1);
37098 {
37099 PyThreadState* __tstate = wxPyBeginAllowThreads();
37100 result = (bool)(arg1)->Validate();
37101 wxPyEndAllowThreads(__tstate);
37102 if (PyErr_Occurred()) SWIG_fail;
37103 }
37104 {
37105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37106 }
37107 return resultobj;
37108 fail:
37109 return NULL;
37110 }
37111
37112
37113 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37114 PyObject *resultobj = 0;
37115 wxWindow *arg1 = (wxWindow *) 0 ;
37116 bool result;
37117 void *argp1 = 0 ;
37118 int res1 = 0 ;
37119 PyObject *swig_obj[1] ;
37120
37121 if (!args) SWIG_fail;
37122 swig_obj[0] = args;
37123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37124 if (!SWIG_IsOK(res1)) {
37125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37126 }
37127 arg1 = reinterpret_cast< wxWindow * >(argp1);
37128 {
37129 PyThreadState* __tstate = wxPyBeginAllowThreads();
37130 result = (bool)(arg1)->TransferDataToWindow();
37131 wxPyEndAllowThreads(__tstate);
37132 if (PyErr_Occurred()) SWIG_fail;
37133 }
37134 {
37135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37136 }
37137 return resultobj;
37138 fail:
37139 return NULL;
37140 }
37141
37142
37143 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37144 PyObject *resultobj = 0;
37145 wxWindow *arg1 = (wxWindow *) 0 ;
37146 bool result;
37147 void *argp1 = 0 ;
37148 int res1 = 0 ;
37149 PyObject *swig_obj[1] ;
37150
37151 if (!args) SWIG_fail;
37152 swig_obj[0] = args;
37153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37154 if (!SWIG_IsOK(res1)) {
37155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37156 }
37157 arg1 = reinterpret_cast< wxWindow * >(argp1);
37158 {
37159 PyThreadState* __tstate = wxPyBeginAllowThreads();
37160 result = (bool)(arg1)->TransferDataFromWindow();
37161 wxPyEndAllowThreads(__tstate);
37162 if (PyErr_Occurred()) SWIG_fail;
37163 }
37164 {
37165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37166 }
37167 return resultobj;
37168 fail:
37169 return NULL;
37170 }
37171
37172
37173 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37174 PyObject *resultobj = 0;
37175 wxWindow *arg1 = (wxWindow *) 0 ;
37176 void *argp1 = 0 ;
37177 int res1 = 0 ;
37178 PyObject *swig_obj[1] ;
37179
37180 if (!args) SWIG_fail;
37181 swig_obj[0] = args;
37182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37183 if (!SWIG_IsOK(res1)) {
37184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37185 }
37186 arg1 = reinterpret_cast< wxWindow * >(argp1);
37187 {
37188 PyThreadState* __tstate = wxPyBeginAllowThreads();
37189 (arg1)->InitDialog();
37190 wxPyEndAllowThreads(__tstate);
37191 if (PyErr_Occurred()) SWIG_fail;
37192 }
37193 resultobj = SWIG_Py_Void();
37194 return resultobj;
37195 fail:
37196 return NULL;
37197 }
37198
37199
37200 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37201 PyObject *resultobj = 0;
37202 wxWindow *arg1 = (wxWindow *) 0 ;
37203 wxAcceleratorTable *arg2 = 0 ;
37204 void *argp1 = 0 ;
37205 int res1 = 0 ;
37206 void *argp2 = 0 ;
37207 int res2 = 0 ;
37208 PyObject * obj0 = 0 ;
37209 PyObject * obj1 = 0 ;
37210 char * kwnames[] = {
37211 (char *) "self",(char *) "accel", NULL
37212 };
37213
37214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37216 if (!SWIG_IsOK(res1)) {
37217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37218 }
37219 arg1 = reinterpret_cast< wxWindow * >(argp1);
37220 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37221 if (!SWIG_IsOK(res2)) {
37222 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37223 }
37224 if (!argp2) {
37225 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37226 }
37227 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37228 {
37229 PyThreadState* __tstate = wxPyBeginAllowThreads();
37230 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37231 wxPyEndAllowThreads(__tstate);
37232 if (PyErr_Occurred()) SWIG_fail;
37233 }
37234 resultobj = SWIG_Py_Void();
37235 return resultobj;
37236 fail:
37237 return NULL;
37238 }
37239
37240
37241 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37242 PyObject *resultobj = 0;
37243 wxWindow *arg1 = (wxWindow *) 0 ;
37244 wxAcceleratorTable *result = 0 ;
37245 void *argp1 = 0 ;
37246 int res1 = 0 ;
37247 PyObject *swig_obj[1] ;
37248
37249 if (!args) SWIG_fail;
37250 swig_obj[0] = args;
37251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37252 if (!SWIG_IsOK(res1)) {
37253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37254 }
37255 arg1 = reinterpret_cast< wxWindow * >(argp1);
37256 {
37257 PyThreadState* __tstate = wxPyBeginAllowThreads();
37258 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37259 wxPyEndAllowThreads(__tstate);
37260 if (PyErr_Occurred()) SWIG_fail;
37261 }
37262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37263 return resultobj;
37264 fail:
37265 return NULL;
37266 }
37267
37268
37269 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37270 PyObject *resultobj = 0;
37271 wxWindow *arg1 = (wxWindow *) 0 ;
37272 int arg2 ;
37273 int arg3 ;
37274 int arg4 ;
37275 bool result;
37276 void *argp1 = 0 ;
37277 int res1 = 0 ;
37278 int val2 ;
37279 int ecode2 = 0 ;
37280 int val3 ;
37281 int ecode3 = 0 ;
37282 int val4 ;
37283 int ecode4 = 0 ;
37284 PyObject * obj0 = 0 ;
37285 PyObject * obj1 = 0 ;
37286 PyObject * obj2 = 0 ;
37287 PyObject * obj3 = 0 ;
37288 char * kwnames[] = {
37289 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37290 };
37291
37292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37294 if (!SWIG_IsOK(res1)) {
37295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37296 }
37297 arg1 = reinterpret_cast< wxWindow * >(argp1);
37298 ecode2 = SWIG_AsVal_int(obj1, &val2);
37299 if (!SWIG_IsOK(ecode2)) {
37300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37301 }
37302 arg2 = static_cast< int >(val2);
37303 ecode3 = SWIG_AsVal_int(obj2, &val3);
37304 if (!SWIG_IsOK(ecode3)) {
37305 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37306 }
37307 arg3 = static_cast< int >(val3);
37308 ecode4 = SWIG_AsVal_int(obj3, &val4);
37309 if (!SWIG_IsOK(ecode4)) {
37310 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37311 }
37312 arg4 = static_cast< int >(val4);
37313 {
37314 PyThreadState* __tstate = wxPyBeginAllowThreads();
37315 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37316 wxPyEndAllowThreads(__tstate);
37317 if (PyErr_Occurred()) SWIG_fail;
37318 }
37319 {
37320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37321 }
37322 return resultobj;
37323 fail:
37324 return NULL;
37325 }
37326
37327
37328 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37329 PyObject *resultobj = 0;
37330 wxWindow *arg1 = (wxWindow *) 0 ;
37331 int arg2 ;
37332 bool result;
37333 void *argp1 = 0 ;
37334 int res1 = 0 ;
37335 int val2 ;
37336 int ecode2 = 0 ;
37337 PyObject * obj0 = 0 ;
37338 PyObject * obj1 = 0 ;
37339 char * kwnames[] = {
37340 (char *) "self",(char *) "hotkeyId", NULL
37341 };
37342
37343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37345 if (!SWIG_IsOK(res1)) {
37346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37347 }
37348 arg1 = reinterpret_cast< wxWindow * >(argp1);
37349 ecode2 = SWIG_AsVal_int(obj1, &val2);
37350 if (!SWIG_IsOK(ecode2)) {
37351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37352 }
37353 arg2 = static_cast< int >(val2);
37354 {
37355 PyThreadState* __tstate = wxPyBeginAllowThreads();
37356 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37357 wxPyEndAllowThreads(__tstate);
37358 if (PyErr_Occurred()) SWIG_fail;
37359 }
37360 {
37361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37362 }
37363 return resultobj;
37364 fail:
37365 return NULL;
37366 }
37367
37368
37369 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37370 PyObject *resultobj = 0;
37371 wxWindow *arg1 = (wxWindow *) 0 ;
37372 wxPoint *arg2 = 0 ;
37373 wxPoint result;
37374 void *argp1 = 0 ;
37375 int res1 = 0 ;
37376 wxPoint temp2 ;
37377 PyObject * obj0 = 0 ;
37378 PyObject * obj1 = 0 ;
37379 char * kwnames[] = {
37380 (char *) "self",(char *) "pt", NULL
37381 };
37382
37383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37385 if (!SWIG_IsOK(res1)) {
37386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37387 }
37388 arg1 = reinterpret_cast< wxWindow * >(argp1);
37389 {
37390 arg2 = &temp2;
37391 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37392 }
37393 {
37394 PyThreadState* __tstate = wxPyBeginAllowThreads();
37395 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37396 wxPyEndAllowThreads(__tstate);
37397 if (PyErr_Occurred()) SWIG_fail;
37398 }
37399 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37400 return resultobj;
37401 fail:
37402 return NULL;
37403 }
37404
37405
37406 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37407 PyObject *resultobj = 0;
37408 wxWindow *arg1 = (wxWindow *) 0 ;
37409 wxSize *arg2 = 0 ;
37410 wxSize result;
37411 void *argp1 = 0 ;
37412 int res1 = 0 ;
37413 wxSize temp2 ;
37414 PyObject * obj0 = 0 ;
37415 PyObject * obj1 = 0 ;
37416 char * kwnames[] = {
37417 (char *) "self",(char *) "sz", NULL
37418 };
37419
37420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37422 if (!SWIG_IsOK(res1)) {
37423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37424 }
37425 arg1 = reinterpret_cast< wxWindow * >(argp1);
37426 {
37427 arg2 = &temp2;
37428 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37429 }
37430 {
37431 PyThreadState* __tstate = wxPyBeginAllowThreads();
37432 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37433 wxPyEndAllowThreads(__tstate);
37434 if (PyErr_Occurred()) SWIG_fail;
37435 }
37436 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37437 return resultobj;
37438 fail:
37439 return NULL;
37440 }
37441
37442
37443 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37444 PyObject *resultobj = 0;
37445 wxWindow *arg1 = (wxWindow *) 0 ;
37446 wxPoint *arg2 = 0 ;
37447 wxPoint result;
37448 void *argp1 = 0 ;
37449 int res1 = 0 ;
37450 wxPoint temp2 ;
37451 PyObject * obj0 = 0 ;
37452 PyObject * obj1 = 0 ;
37453 char * kwnames[] = {
37454 (char *) "self",(char *) "pt", NULL
37455 };
37456
37457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37459 if (!SWIG_IsOK(res1)) {
37460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37461 }
37462 arg1 = reinterpret_cast< wxWindow * >(argp1);
37463 {
37464 arg2 = &temp2;
37465 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37466 }
37467 {
37468 PyThreadState* __tstate = wxPyBeginAllowThreads();
37469 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37470 wxPyEndAllowThreads(__tstate);
37471 if (PyErr_Occurred()) SWIG_fail;
37472 }
37473 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37474 return resultobj;
37475 fail:
37476 return NULL;
37477 }
37478
37479
37480 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37481 PyObject *resultobj = 0;
37482 wxWindow *arg1 = (wxWindow *) 0 ;
37483 wxSize *arg2 = 0 ;
37484 wxSize result;
37485 void *argp1 = 0 ;
37486 int res1 = 0 ;
37487 wxSize temp2 ;
37488 PyObject * obj0 = 0 ;
37489 PyObject * obj1 = 0 ;
37490 char * kwnames[] = {
37491 (char *) "self",(char *) "sz", NULL
37492 };
37493
37494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37496 if (!SWIG_IsOK(res1)) {
37497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37498 }
37499 arg1 = reinterpret_cast< wxWindow * >(argp1);
37500 {
37501 arg2 = &temp2;
37502 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37503 }
37504 {
37505 PyThreadState* __tstate = wxPyBeginAllowThreads();
37506 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37507 wxPyEndAllowThreads(__tstate);
37508 if (PyErr_Occurred()) SWIG_fail;
37509 }
37510 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37511 return resultobj;
37512 fail:
37513 return NULL;
37514 }
37515
37516
37517 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37518 PyObject *resultobj = 0;
37519 wxWindow *arg1 = (wxWindow *) 0 ;
37520 wxPoint *arg2 = 0 ;
37521 wxPoint result;
37522 void *argp1 = 0 ;
37523 int res1 = 0 ;
37524 wxPoint temp2 ;
37525 PyObject * obj0 = 0 ;
37526 PyObject * obj1 = 0 ;
37527 char * kwnames[] = {
37528 (char *) "self",(char *) "pt", NULL
37529 };
37530
37531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37533 if (!SWIG_IsOK(res1)) {
37534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37535 }
37536 arg1 = reinterpret_cast< wxWindow * >(argp1);
37537 {
37538 arg2 = &temp2;
37539 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37540 }
37541 {
37542 PyThreadState* __tstate = wxPyBeginAllowThreads();
37543 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37544 wxPyEndAllowThreads(__tstate);
37545 if (PyErr_Occurred()) SWIG_fail;
37546 }
37547 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37548 return resultobj;
37549 fail:
37550 return NULL;
37551 }
37552
37553
37554 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37555 PyObject *resultobj = 0;
37556 wxWindow *arg1 = (wxWindow *) 0 ;
37557 wxSize *arg2 = 0 ;
37558 wxSize result;
37559 void *argp1 = 0 ;
37560 int res1 = 0 ;
37561 wxSize temp2 ;
37562 PyObject * obj0 = 0 ;
37563 PyObject * obj1 = 0 ;
37564 char * kwnames[] = {
37565 (char *) "self",(char *) "sz", NULL
37566 };
37567
37568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37570 if (!SWIG_IsOK(res1)) {
37571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37572 }
37573 arg1 = reinterpret_cast< wxWindow * >(argp1);
37574 {
37575 arg2 = &temp2;
37576 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37577 }
37578 {
37579 PyThreadState* __tstate = wxPyBeginAllowThreads();
37580 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37581 wxPyEndAllowThreads(__tstate);
37582 if (PyErr_Occurred()) SWIG_fail;
37583 }
37584 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37585 return resultobj;
37586 fail:
37587 return NULL;
37588 }
37589
37590
37591 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37592 PyObject *resultobj = 0;
37593 wxWindow *arg1 = (wxWindow *) 0 ;
37594 int arg2 ;
37595 int arg3 ;
37596 void *argp1 = 0 ;
37597 int res1 = 0 ;
37598 int val2 ;
37599 int ecode2 = 0 ;
37600 int val3 ;
37601 int ecode3 = 0 ;
37602 PyObject * obj0 = 0 ;
37603 PyObject * obj1 = 0 ;
37604 PyObject * obj2 = 0 ;
37605 char * kwnames[] = {
37606 (char *) "self",(char *) "x",(char *) "y", NULL
37607 };
37608
37609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37611 if (!SWIG_IsOK(res1)) {
37612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37613 }
37614 arg1 = reinterpret_cast< wxWindow * >(argp1);
37615 ecode2 = SWIG_AsVal_int(obj1, &val2);
37616 if (!SWIG_IsOK(ecode2)) {
37617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37618 }
37619 arg2 = static_cast< int >(val2);
37620 ecode3 = SWIG_AsVal_int(obj2, &val3);
37621 if (!SWIG_IsOK(ecode3)) {
37622 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37623 }
37624 arg3 = static_cast< int >(val3);
37625 {
37626 PyThreadState* __tstate = wxPyBeginAllowThreads();
37627 (arg1)->WarpPointer(arg2,arg3);
37628 wxPyEndAllowThreads(__tstate);
37629 if (PyErr_Occurred()) SWIG_fail;
37630 }
37631 resultobj = SWIG_Py_Void();
37632 return resultobj;
37633 fail:
37634 return NULL;
37635 }
37636
37637
37638 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37639 PyObject *resultobj = 0;
37640 wxWindow *arg1 = (wxWindow *) 0 ;
37641 void *argp1 = 0 ;
37642 int res1 = 0 ;
37643 PyObject *swig_obj[1] ;
37644
37645 if (!args) SWIG_fail;
37646 swig_obj[0] = args;
37647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37648 if (!SWIG_IsOK(res1)) {
37649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37650 }
37651 arg1 = reinterpret_cast< wxWindow * >(argp1);
37652 {
37653 PyThreadState* __tstate = wxPyBeginAllowThreads();
37654 (arg1)->CaptureMouse();
37655 wxPyEndAllowThreads(__tstate);
37656 if (PyErr_Occurred()) SWIG_fail;
37657 }
37658 resultobj = SWIG_Py_Void();
37659 return resultobj;
37660 fail:
37661 return NULL;
37662 }
37663
37664
37665 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37666 PyObject *resultobj = 0;
37667 wxWindow *arg1 = (wxWindow *) 0 ;
37668 void *argp1 = 0 ;
37669 int res1 = 0 ;
37670 PyObject *swig_obj[1] ;
37671
37672 if (!args) SWIG_fail;
37673 swig_obj[0] = args;
37674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37675 if (!SWIG_IsOK(res1)) {
37676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37677 }
37678 arg1 = reinterpret_cast< wxWindow * >(argp1);
37679 {
37680 PyThreadState* __tstate = wxPyBeginAllowThreads();
37681 (arg1)->ReleaseMouse();
37682 wxPyEndAllowThreads(__tstate);
37683 if (PyErr_Occurred()) SWIG_fail;
37684 }
37685 resultobj = SWIG_Py_Void();
37686 return resultobj;
37687 fail:
37688 return NULL;
37689 }
37690
37691
37692 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37693 PyObject *resultobj = 0;
37694 wxWindow *result = 0 ;
37695
37696 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37697 {
37698 if (!wxPyCheckForApp()) SWIG_fail;
37699 PyThreadState* __tstate = wxPyBeginAllowThreads();
37700 result = (wxWindow *)wxWindow::GetCapture();
37701 wxPyEndAllowThreads(__tstate);
37702 if (PyErr_Occurred()) SWIG_fail;
37703 }
37704 {
37705 resultobj = wxPyMake_wxObject(result, 0);
37706 }
37707 return resultobj;
37708 fail:
37709 return NULL;
37710 }
37711
37712
37713 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37714 PyObject *resultobj = 0;
37715 wxWindow *arg1 = (wxWindow *) 0 ;
37716 bool result;
37717 void *argp1 = 0 ;
37718 int res1 = 0 ;
37719 PyObject *swig_obj[1] ;
37720
37721 if (!args) SWIG_fail;
37722 swig_obj[0] = args;
37723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37724 if (!SWIG_IsOK(res1)) {
37725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37726 }
37727 arg1 = reinterpret_cast< wxWindow * >(argp1);
37728 {
37729 PyThreadState* __tstate = wxPyBeginAllowThreads();
37730 result = (bool)((wxWindow const *)arg1)->HasCapture();
37731 wxPyEndAllowThreads(__tstate);
37732 if (PyErr_Occurred()) SWIG_fail;
37733 }
37734 {
37735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37736 }
37737 return resultobj;
37738 fail:
37739 return NULL;
37740 }
37741
37742
37743 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37744 PyObject *resultobj = 0;
37745 wxWindow *arg1 = (wxWindow *) 0 ;
37746 bool arg2 = (bool) true ;
37747 wxRect *arg3 = (wxRect *) NULL ;
37748 void *argp1 = 0 ;
37749 int res1 = 0 ;
37750 bool val2 ;
37751 int ecode2 = 0 ;
37752 void *argp3 = 0 ;
37753 int res3 = 0 ;
37754 PyObject * obj0 = 0 ;
37755 PyObject * obj1 = 0 ;
37756 PyObject * obj2 = 0 ;
37757 char * kwnames[] = {
37758 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37759 };
37760
37761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37763 if (!SWIG_IsOK(res1)) {
37764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37765 }
37766 arg1 = reinterpret_cast< wxWindow * >(argp1);
37767 if (obj1) {
37768 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37769 if (!SWIG_IsOK(ecode2)) {
37770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37771 }
37772 arg2 = static_cast< bool >(val2);
37773 }
37774 if (obj2) {
37775 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37776 if (!SWIG_IsOK(res3)) {
37777 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37778 }
37779 arg3 = reinterpret_cast< wxRect * >(argp3);
37780 }
37781 {
37782 PyThreadState* __tstate = wxPyBeginAllowThreads();
37783 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37784 wxPyEndAllowThreads(__tstate);
37785 if (PyErr_Occurred()) SWIG_fail;
37786 }
37787 resultobj = SWIG_Py_Void();
37788 return resultobj;
37789 fail:
37790 return NULL;
37791 }
37792
37793
37794 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37795 PyObject *resultobj = 0;
37796 wxWindow *arg1 = (wxWindow *) 0 ;
37797 wxRect *arg2 = 0 ;
37798 bool arg3 = (bool) true ;
37799 void *argp1 = 0 ;
37800 int res1 = 0 ;
37801 wxRect temp2 ;
37802 bool val3 ;
37803 int ecode3 = 0 ;
37804 PyObject * obj0 = 0 ;
37805 PyObject * obj1 = 0 ;
37806 PyObject * obj2 = 0 ;
37807 char * kwnames[] = {
37808 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37809 };
37810
37811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37813 if (!SWIG_IsOK(res1)) {
37814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37815 }
37816 arg1 = reinterpret_cast< wxWindow * >(argp1);
37817 {
37818 arg2 = &temp2;
37819 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37820 }
37821 if (obj2) {
37822 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37823 if (!SWIG_IsOK(ecode3)) {
37824 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37825 }
37826 arg3 = static_cast< bool >(val3);
37827 }
37828 {
37829 PyThreadState* __tstate = wxPyBeginAllowThreads();
37830 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37831 wxPyEndAllowThreads(__tstate);
37832 if (PyErr_Occurred()) SWIG_fail;
37833 }
37834 resultobj = SWIG_Py_Void();
37835 return resultobj;
37836 fail:
37837 return NULL;
37838 }
37839
37840
37841 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37842 PyObject *resultobj = 0;
37843 wxWindow *arg1 = (wxWindow *) 0 ;
37844 void *argp1 = 0 ;
37845 int res1 = 0 ;
37846 PyObject *swig_obj[1] ;
37847
37848 if (!args) SWIG_fail;
37849 swig_obj[0] = args;
37850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37851 if (!SWIG_IsOK(res1)) {
37852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
37853 }
37854 arg1 = reinterpret_cast< wxWindow * >(argp1);
37855 {
37856 PyThreadState* __tstate = wxPyBeginAllowThreads();
37857 (arg1)->Update();
37858 wxPyEndAllowThreads(__tstate);
37859 if (PyErr_Occurred()) SWIG_fail;
37860 }
37861 resultobj = SWIG_Py_Void();
37862 return resultobj;
37863 fail:
37864 return NULL;
37865 }
37866
37867
37868 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37869 PyObject *resultobj = 0;
37870 wxWindow *arg1 = (wxWindow *) 0 ;
37871 void *argp1 = 0 ;
37872 int res1 = 0 ;
37873 PyObject *swig_obj[1] ;
37874
37875 if (!args) SWIG_fail;
37876 swig_obj[0] = args;
37877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37878 if (!SWIG_IsOK(res1)) {
37879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
37880 }
37881 arg1 = reinterpret_cast< wxWindow * >(argp1);
37882 {
37883 PyThreadState* __tstate = wxPyBeginAllowThreads();
37884 (arg1)->ClearBackground();
37885 wxPyEndAllowThreads(__tstate);
37886 if (PyErr_Occurred()) SWIG_fail;
37887 }
37888 resultobj = SWIG_Py_Void();
37889 return resultobj;
37890 fail:
37891 return NULL;
37892 }
37893
37894
37895 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37896 PyObject *resultobj = 0;
37897 wxWindow *arg1 = (wxWindow *) 0 ;
37898 void *argp1 = 0 ;
37899 int res1 = 0 ;
37900 PyObject *swig_obj[1] ;
37901
37902 if (!args) SWIG_fail;
37903 swig_obj[0] = args;
37904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37905 if (!SWIG_IsOK(res1)) {
37906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
37907 }
37908 arg1 = reinterpret_cast< wxWindow * >(argp1);
37909 {
37910 PyThreadState* __tstate = wxPyBeginAllowThreads();
37911 (arg1)->Freeze();
37912 wxPyEndAllowThreads(__tstate);
37913 if (PyErr_Occurred()) SWIG_fail;
37914 }
37915 resultobj = SWIG_Py_Void();
37916 return resultobj;
37917 fail:
37918 return NULL;
37919 }
37920
37921
37922 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37923 PyObject *resultobj = 0;
37924 wxWindow *arg1 = (wxWindow *) 0 ;
37925 bool result;
37926 void *argp1 = 0 ;
37927 int res1 = 0 ;
37928 PyObject *swig_obj[1] ;
37929
37930 if (!args) SWIG_fail;
37931 swig_obj[0] = args;
37932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37933 if (!SWIG_IsOK(res1)) {
37934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37935 }
37936 arg1 = reinterpret_cast< wxWindow * >(argp1);
37937 {
37938 PyThreadState* __tstate = wxPyBeginAllowThreads();
37939 result = (bool)((wxWindow const *)arg1)->IsFrozen();
37940 wxPyEndAllowThreads(__tstate);
37941 if (PyErr_Occurred()) SWIG_fail;
37942 }
37943 {
37944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37945 }
37946 return resultobj;
37947 fail:
37948 return NULL;
37949 }
37950
37951
37952 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37953 PyObject *resultobj = 0;
37954 wxWindow *arg1 = (wxWindow *) 0 ;
37955 void *argp1 = 0 ;
37956 int res1 = 0 ;
37957 PyObject *swig_obj[1] ;
37958
37959 if (!args) SWIG_fail;
37960 swig_obj[0] = args;
37961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37962 if (!SWIG_IsOK(res1)) {
37963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
37964 }
37965 arg1 = reinterpret_cast< wxWindow * >(argp1);
37966 {
37967 PyThreadState* __tstate = wxPyBeginAllowThreads();
37968 (arg1)->Thaw();
37969 wxPyEndAllowThreads(__tstate);
37970 if (PyErr_Occurred()) SWIG_fail;
37971 }
37972 resultobj = SWIG_Py_Void();
37973 return resultobj;
37974 fail:
37975 return NULL;
37976 }
37977
37978
37979 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37980 PyObject *resultobj = 0;
37981 wxWindow *arg1 = (wxWindow *) 0 ;
37982 wxDC *arg2 = 0 ;
37983 void *argp1 = 0 ;
37984 int res1 = 0 ;
37985 void *argp2 = 0 ;
37986 int res2 = 0 ;
37987 PyObject * obj0 = 0 ;
37988 PyObject * obj1 = 0 ;
37989 char * kwnames[] = {
37990 (char *) "self",(char *) "dc", NULL
37991 };
37992
37993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
37994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37995 if (!SWIG_IsOK(res1)) {
37996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
37997 }
37998 arg1 = reinterpret_cast< wxWindow * >(argp1);
37999 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
38000 if (!SWIG_IsOK(res2)) {
38001 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38002 }
38003 if (!argp2) {
38004 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38005 }
38006 arg2 = reinterpret_cast< wxDC * >(argp2);
38007 {
38008 PyThreadState* __tstate = wxPyBeginAllowThreads();
38009 (arg1)->PrepareDC(*arg2);
38010 wxPyEndAllowThreads(__tstate);
38011 if (PyErr_Occurred()) SWIG_fail;
38012 }
38013 resultobj = SWIG_Py_Void();
38014 return resultobj;
38015 fail:
38016 return NULL;
38017 }
38018
38019
38020 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38021 PyObject *resultobj = 0;
38022 wxWindow *arg1 = (wxWindow *) 0 ;
38023 bool result;
38024 void *argp1 = 0 ;
38025 int res1 = 0 ;
38026 PyObject *swig_obj[1] ;
38027
38028 if (!args) SWIG_fail;
38029 swig_obj[0] = args;
38030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38031 if (!SWIG_IsOK(res1)) {
38032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
38033 }
38034 arg1 = reinterpret_cast< wxWindow * >(argp1);
38035 {
38036 PyThreadState* __tstate = wxPyBeginAllowThreads();
38037 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
38038 wxPyEndAllowThreads(__tstate);
38039 if (PyErr_Occurred()) SWIG_fail;
38040 }
38041 {
38042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38043 }
38044 return resultobj;
38045 fail:
38046 return NULL;
38047 }
38048
38049
38050 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38051 PyObject *resultobj = 0;
38052 wxWindow *arg1 = (wxWindow *) 0 ;
38053 wxRegion *result = 0 ;
38054 void *argp1 = 0 ;
38055 int res1 = 0 ;
38056 PyObject *swig_obj[1] ;
38057
38058 if (!args) SWIG_fail;
38059 swig_obj[0] = args;
38060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38061 if (!SWIG_IsOK(res1)) {
38062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
38063 }
38064 arg1 = reinterpret_cast< wxWindow * >(argp1);
38065 {
38066 PyThreadState* __tstate = wxPyBeginAllowThreads();
38067 {
38068 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
38069 result = (wxRegion *) &_result_ref;
38070 }
38071 wxPyEndAllowThreads(__tstate);
38072 if (PyErr_Occurred()) SWIG_fail;
38073 }
38074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
38075 return resultobj;
38076 fail:
38077 return NULL;
38078 }
38079
38080
38081 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38082 PyObject *resultobj = 0;
38083 wxWindow *arg1 = (wxWindow *) 0 ;
38084 wxRect result;
38085 void *argp1 = 0 ;
38086 int res1 = 0 ;
38087 PyObject *swig_obj[1] ;
38088
38089 if (!args) SWIG_fail;
38090 swig_obj[0] = args;
38091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38092 if (!SWIG_IsOK(res1)) {
38093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38094 }
38095 arg1 = reinterpret_cast< wxWindow * >(argp1);
38096 {
38097 PyThreadState* __tstate = wxPyBeginAllowThreads();
38098 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
38099 wxPyEndAllowThreads(__tstate);
38100 if (PyErr_Occurred()) SWIG_fail;
38101 }
38102 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
38103 return resultobj;
38104 fail:
38105 return NULL;
38106 }
38107
38108
38109 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38110 PyObject *resultobj = 0;
38111 wxWindow *arg1 = (wxWindow *) 0 ;
38112 int arg2 ;
38113 int arg3 ;
38114 int arg4 = (int) 1 ;
38115 int arg5 = (int) 1 ;
38116 bool result;
38117 void *argp1 = 0 ;
38118 int res1 = 0 ;
38119 int val2 ;
38120 int ecode2 = 0 ;
38121 int val3 ;
38122 int ecode3 = 0 ;
38123 int val4 ;
38124 int ecode4 = 0 ;
38125 int val5 ;
38126 int ecode5 = 0 ;
38127 PyObject * obj0 = 0 ;
38128 PyObject * obj1 = 0 ;
38129 PyObject * obj2 = 0 ;
38130 PyObject * obj3 = 0 ;
38131 PyObject * obj4 = 0 ;
38132 char * kwnames[] = {
38133 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
38134 };
38135
38136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38138 if (!SWIG_IsOK(res1)) {
38139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
38140 }
38141 arg1 = reinterpret_cast< wxWindow * >(argp1);
38142 ecode2 = SWIG_AsVal_int(obj1, &val2);
38143 if (!SWIG_IsOK(ecode2)) {
38144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
38145 }
38146 arg2 = static_cast< int >(val2);
38147 ecode3 = SWIG_AsVal_int(obj2, &val3);
38148 if (!SWIG_IsOK(ecode3)) {
38149 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
38150 }
38151 arg3 = static_cast< int >(val3);
38152 if (obj3) {
38153 ecode4 = SWIG_AsVal_int(obj3, &val4);
38154 if (!SWIG_IsOK(ecode4)) {
38155 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
38156 }
38157 arg4 = static_cast< int >(val4);
38158 }
38159 if (obj4) {
38160 ecode5 = SWIG_AsVal_int(obj4, &val5);
38161 if (!SWIG_IsOK(ecode5)) {
38162 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38163 }
38164 arg5 = static_cast< int >(val5);
38165 }
38166 {
38167 PyThreadState* __tstate = wxPyBeginAllowThreads();
38168 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38169 wxPyEndAllowThreads(__tstate);
38170 if (PyErr_Occurred()) SWIG_fail;
38171 }
38172 {
38173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38174 }
38175 return resultobj;
38176 fail:
38177 return NULL;
38178 }
38179
38180
38181 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38182 PyObject *resultobj = 0;
38183 wxWindow *arg1 = (wxWindow *) 0 ;
38184 wxPoint *arg2 = 0 ;
38185 bool result;
38186 void *argp1 = 0 ;
38187 int res1 = 0 ;
38188 wxPoint temp2 ;
38189 PyObject * obj0 = 0 ;
38190 PyObject * obj1 = 0 ;
38191 char * kwnames[] = {
38192 (char *) "self",(char *) "pt", NULL
38193 };
38194
38195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38197 if (!SWIG_IsOK(res1)) {
38198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38199 }
38200 arg1 = reinterpret_cast< wxWindow * >(argp1);
38201 {
38202 arg2 = &temp2;
38203 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38204 }
38205 {
38206 PyThreadState* __tstate = wxPyBeginAllowThreads();
38207 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38208 wxPyEndAllowThreads(__tstate);
38209 if (PyErr_Occurred()) SWIG_fail;
38210 }
38211 {
38212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38213 }
38214 return resultobj;
38215 fail:
38216 return NULL;
38217 }
38218
38219
38220 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38221 PyObject *resultobj = 0;
38222 wxWindow *arg1 = (wxWindow *) 0 ;
38223 wxRect *arg2 = 0 ;
38224 bool result;
38225 void *argp1 = 0 ;
38226 int res1 = 0 ;
38227 wxRect temp2 ;
38228 PyObject * obj0 = 0 ;
38229 PyObject * obj1 = 0 ;
38230 char * kwnames[] = {
38231 (char *) "self",(char *) "rect", NULL
38232 };
38233
38234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",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_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38238 }
38239 arg1 = reinterpret_cast< wxWindow * >(argp1);
38240 {
38241 arg2 = &temp2;
38242 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38243 }
38244 {
38245 PyThreadState* __tstate = wxPyBeginAllowThreads();
38246 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect 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_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38260 PyObject *resultobj = 0;
38261 wxWindow *arg1 = (wxWindow *) 0 ;
38262 SwigValueWrapper<wxVisualAttributes > result;
38263 void *argp1 = 0 ;
38264 int res1 = 0 ;
38265 PyObject *swig_obj[1] ;
38266
38267 if (!args) SWIG_fail;
38268 swig_obj[0] = args;
38269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38270 if (!SWIG_IsOK(res1)) {
38271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38272 }
38273 arg1 = reinterpret_cast< wxWindow * >(argp1);
38274 {
38275 PyThreadState* __tstate = wxPyBeginAllowThreads();
38276 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38277 wxPyEndAllowThreads(__tstate);
38278 if (PyErr_Occurred()) SWIG_fail;
38279 }
38280 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38281 return resultobj;
38282 fail:
38283 return NULL;
38284 }
38285
38286
38287 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38288 PyObject *resultobj = 0;
38289 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38290 SwigValueWrapper<wxVisualAttributes > result;
38291 int val1 ;
38292 int ecode1 = 0 ;
38293 PyObject * obj0 = 0 ;
38294 char * kwnames[] = {
38295 (char *) "variant", NULL
38296 };
38297
38298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38299 if (obj0) {
38300 ecode1 = SWIG_AsVal_int(obj0, &val1);
38301 if (!SWIG_IsOK(ecode1)) {
38302 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38303 }
38304 arg1 = static_cast< wxWindowVariant >(val1);
38305 }
38306 {
38307 if (!wxPyCheckForApp()) SWIG_fail;
38308 PyThreadState* __tstate = wxPyBeginAllowThreads();
38309 result = wxWindow::GetClassDefaultAttributes(arg1);
38310 wxPyEndAllowThreads(__tstate);
38311 if (PyErr_Occurred()) SWIG_fail;
38312 }
38313 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38314 return resultobj;
38315 fail:
38316 return NULL;
38317 }
38318
38319
38320 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38321 PyObject *resultobj = 0;
38322 wxWindow *arg1 = (wxWindow *) 0 ;
38323 wxColour *arg2 = 0 ;
38324 bool result;
38325 void *argp1 = 0 ;
38326 int res1 = 0 ;
38327 wxColour temp2 ;
38328 PyObject * obj0 = 0 ;
38329 PyObject * obj1 = 0 ;
38330 char * kwnames[] = {
38331 (char *) "self",(char *) "colour", NULL
38332 };
38333
38334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38336 if (!SWIG_IsOK(res1)) {
38337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38338 }
38339 arg1 = reinterpret_cast< wxWindow * >(argp1);
38340 {
38341 arg2 = &temp2;
38342 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38343 }
38344 {
38345 PyThreadState* __tstate = wxPyBeginAllowThreads();
38346 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38347 wxPyEndAllowThreads(__tstate);
38348 if (PyErr_Occurred()) SWIG_fail;
38349 }
38350 {
38351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38352 }
38353 return resultobj;
38354 fail:
38355 return NULL;
38356 }
38357
38358
38359 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38360 PyObject *resultobj = 0;
38361 wxWindow *arg1 = (wxWindow *) 0 ;
38362 wxColour *arg2 = 0 ;
38363 void *argp1 = 0 ;
38364 int res1 = 0 ;
38365 wxColour temp2 ;
38366 PyObject * obj0 = 0 ;
38367 PyObject * obj1 = 0 ;
38368 char * kwnames[] = {
38369 (char *) "self",(char *) "colour", NULL
38370 };
38371
38372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38374 if (!SWIG_IsOK(res1)) {
38375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38376 }
38377 arg1 = reinterpret_cast< wxWindow * >(argp1);
38378 {
38379 arg2 = &temp2;
38380 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38381 }
38382 {
38383 PyThreadState* __tstate = wxPyBeginAllowThreads();
38384 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38385 wxPyEndAllowThreads(__tstate);
38386 if (PyErr_Occurred()) SWIG_fail;
38387 }
38388 resultobj = SWIG_Py_Void();
38389 return resultobj;
38390 fail:
38391 return NULL;
38392 }
38393
38394
38395 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38396 PyObject *resultobj = 0;
38397 wxWindow *arg1 = (wxWindow *) 0 ;
38398 wxColour *arg2 = 0 ;
38399 bool result;
38400 void *argp1 = 0 ;
38401 int res1 = 0 ;
38402 wxColour temp2 ;
38403 PyObject * obj0 = 0 ;
38404 PyObject * obj1 = 0 ;
38405 char * kwnames[] = {
38406 (char *) "self",(char *) "colour", NULL
38407 };
38408
38409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38411 if (!SWIG_IsOK(res1)) {
38412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38413 }
38414 arg1 = reinterpret_cast< wxWindow * >(argp1);
38415 {
38416 arg2 = &temp2;
38417 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38418 }
38419 {
38420 PyThreadState* __tstate = wxPyBeginAllowThreads();
38421 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38422 wxPyEndAllowThreads(__tstate);
38423 if (PyErr_Occurred()) SWIG_fail;
38424 }
38425 {
38426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38427 }
38428 return resultobj;
38429 fail:
38430 return NULL;
38431 }
38432
38433
38434 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38435 PyObject *resultobj = 0;
38436 wxWindow *arg1 = (wxWindow *) 0 ;
38437 wxColour *arg2 = 0 ;
38438 void *argp1 = 0 ;
38439 int res1 = 0 ;
38440 wxColour temp2 ;
38441 PyObject * obj0 = 0 ;
38442 PyObject * obj1 = 0 ;
38443 char * kwnames[] = {
38444 (char *) "self",(char *) "colour", NULL
38445 };
38446
38447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38449 if (!SWIG_IsOK(res1)) {
38450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38451 }
38452 arg1 = reinterpret_cast< wxWindow * >(argp1);
38453 {
38454 arg2 = &temp2;
38455 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38456 }
38457 {
38458 PyThreadState* __tstate = wxPyBeginAllowThreads();
38459 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38460 wxPyEndAllowThreads(__tstate);
38461 if (PyErr_Occurred()) SWIG_fail;
38462 }
38463 resultobj = SWIG_Py_Void();
38464 return resultobj;
38465 fail:
38466 return NULL;
38467 }
38468
38469
38470 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38471 PyObject *resultobj = 0;
38472 wxWindow *arg1 = (wxWindow *) 0 ;
38473 wxColour result;
38474 void *argp1 = 0 ;
38475 int res1 = 0 ;
38476 PyObject *swig_obj[1] ;
38477
38478 if (!args) SWIG_fail;
38479 swig_obj[0] = args;
38480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38481 if (!SWIG_IsOK(res1)) {
38482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38483 }
38484 arg1 = reinterpret_cast< wxWindow * >(argp1);
38485 {
38486 PyThreadState* __tstate = wxPyBeginAllowThreads();
38487 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38488 wxPyEndAllowThreads(__tstate);
38489 if (PyErr_Occurred()) SWIG_fail;
38490 }
38491 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38492 return resultobj;
38493 fail:
38494 return NULL;
38495 }
38496
38497
38498 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38499 PyObject *resultobj = 0;
38500 wxWindow *arg1 = (wxWindow *) 0 ;
38501 wxColour result;
38502 void *argp1 = 0 ;
38503 int res1 = 0 ;
38504 PyObject *swig_obj[1] ;
38505
38506 if (!args) SWIG_fail;
38507 swig_obj[0] = args;
38508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38509 if (!SWIG_IsOK(res1)) {
38510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38511 }
38512 arg1 = reinterpret_cast< wxWindow * >(argp1);
38513 {
38514 PyThreadState* __tstate = wxPyBeginAllowThreads();
38515 result = ((wxWindow const *)arg1)->GetForegroundColour();
38516 wxPyEndAllowThreads(__tstate);
38517 if (PyErr_Occurred()) SWIG_fail;
38518 }
38519 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38520 return resultobj;
38521 fail:
38522 return NULL;
38523 }
38524
38525
38526 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38527 PyObject *resultobj = 0;
38528 wxWindow *arg1 = (wxWindow *) 0 ;
38529 bool result;
38530 void *argp1 = 0 ;
38531 int res1 = 0 ;
38532 PyObject *swig_obj[1] ;
38533
38534 if (!args) SWIG_fail;
38535 swig_obj[0] = args;
38536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38537 if (!SWIG_IsOK(res1)) {
38538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38539 }
38540 arg1 = reinterpret_cast< wxWindow * >(argp1);
38541 {
38542 PyThreadState* __tstate = wxPyBeginAllowThreads();
38543 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38544 wxPyEndAllowThreads(__tstate);
38545 if (PyErr_Occurred()) SWIG_fail;
38546 }
38547 {
38548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38549 }
38550 return resultobj;
38551 fail:
38552 return NULL;
38553 }
38554
38555
38556 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38557 PyObject *resultobj = 0;
38558 wxWindow *arg1 = (wxWindow *) 0 ;
38559 bool result;
38560 void *argp1 = 0 ;
38561 int res1 = 0 ;
38562 PyObject *swig_obj[1] ;
38563
38564 if (!args) SWIG_fail;
38565 swig_obj[0] = args;
38566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38567 if (!SWIG_IsOK(res1)) {
38568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38569 }
38570 arg1 = reinterpret_cast< wxWindow * >(argp1);
38571 {
38572 PyThreadState* __tstate = wxPyBeginAllowThreads();
38573 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38574 wxPyEndAllowThreads(__tstate);
38575 if (PyErr_Occurred()) SWIG_fail;
38576 }
38577 {
38578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38579 }
38580 return resultobj;
38581 fail:
38582 return NULL;
38583 }
38584
38585
38586 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38587 PyObject *resultobj = 0;
38588 wxWindow *arg1 = (wxWindow *) 0 ;
38589 wxBackgroundStyle arg2 ;
38590 bool result;
38591 void *argp1 = 0 ;
38592 int res1 = 0 ;
38593 int val2 ;
38594 int ecode2 = 0 ;
38595 PyObject * obj0 = 0 ;
38596 PyObject * obj1 = 0 ;
38597 char * kwnames[] = {
38598 (char *) "self",(char *) "style", NULL
38599 };
38600
38601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38603 if (!SWIG_IsOK(res1)) {
38604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38605 }
38606 arg1 = reinterpret_cast< wxWindow * >(argp1);
38607 ecode2 = SWIG_AsVal_int(obj1, &val2);
38608 if (!SWIG_IsOK(ecode2)) {
38609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38610 }
38611 arg2 = static_cast< wxBackgroundStyle >(val2);
38612 {
38613 PyThreadState* __tstate = wxPyBeginAllowThreads();
38614 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38615 wxPyEndAllowThreads(__tstate);
38616 if (PyErr_Occurred()) SWIG_fail;
38617 }
38618 {
38619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38620 }
38621 return resultobj;
38622 fail:
38623 return NULL;
38624 }
38625
38626
38627 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38628 PyObject *resultobj = 0;
38629 wxWindow *arg1 = (wxWindow *) 0 ;
38630 wxBackgroundStyle result;
38631 void *argp1 = 0 ;
38632 int res1 = 0 ;
38633 PyObject *swig_obj[1] ;
38634
38635 if (!args) SWIG_fail;
38636 swig_obj[0] = args;
38637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38638 if (!SWIG_IsOK(res1)) {
38639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38640 }
38641 arg1 = reinterpret_cast< wxWindow * >(argp1);
38642 {
38643 PyThreadState* __tstate = wxPyBeginAllowThreads();
38644 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38645 wxPyEndAllowThreads(__tstate);
38646 if (PyErr_Occurred()) SWIG_fail;
38647 }
38648 resultobj = SWIG_From_int(static_cast< int >(result));
38649 return resultobj;
38650 fail:
38651 return NULL;
38652 }
38653
38654
38655 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38656 PyObject *resultobj = 0;
38657 wxWindow *arg1 = (wxWindow *) 0 ;
38658 bool result;
38659 void *argp1 = 0 ;
38660 int res1 = 0 ;
38661 PyObject *swig_obj[1] ;
38662
38663 if (!args) SWIG_fail;
38664 swig_obj[0] = args;
38665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38666 if (!SWIG_IsOK(res1)) {
38667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38668 }
38669 arg1 = reinterpret_cast< wxWindow * >(argp1);
38670 {
38671 PyThreadState* __tstate = wxPyBeginAllowThreads();
38672 result = (bool)(arg1)->HasTransparentBackground();
38673 wxPyEndAllowThreads(__tstate);
38674 if (PyErr_Occurred()) SWIG_fail;
38675 }
38676 {
38677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38678 }
38679 return resultobj;
38680 fail:
38681 return NULL;
38682 }
38683
38684
38685 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38686 PyObject *resultobj = 0;
38687 wxWindow *arg1 = (wxWindow *) 0 ;
38688 wxCursor *arg2 = 0 ;
38689 bool result;
38690 void *argp1 = 0 ;
38691 int res1 = 0 ;
38692 void *argp2 = 0 ;
38693 int res2 = 0 ;
38694 PyObject * obj0 = 0 ;
38695 PyObject * obj1 = 0 ;
38696 char * kwnames[] = {
38697 (char *) "self",(char *) "cursor", NULL
38698 };
38699
38700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38702 if (!SWIG_IsOK(res1)) {
38703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38704 }
38705 arg1 = reinterpret_cast< wxWindow * >(argp1);
38706 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38707 if (!SWIG_IsOK(res2)) {
38708 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38709 }
38710 if (!argp2) {
38711 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38712 }
38713 arg2 = reinterpret_cast< wxCursor * >(argp2);
38714 {
38715 PyThreadState* __tstate = wxPyBeginAllowThreads();
38716 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38717 wxPyEndAllowThreads(__tstate);
38718 if (PyErr_Occurred()) SWIG_fail;
38719 }
38720 {
38721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38722 }
38723 return resultobj;
38724 fail:
38725 return NULL;
38726 }
38727
38728
38729 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38730 PyObject *resultobj = 0;
38731 wxWindow *arg1 = (wxWindow *) 0 ;
38732 wxCursor result;
38733 void *argp1 = 0 ;
38734 int res1 = 0 ;
38735 PyObject *swig_obj[1] ;
38736
38737 if (!args) SWIG_fail;
38738 swig_obj[0] = args;
38739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38740 if (!SWIG_IsOK(res1)) {
38741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38742 }
38743 arg1 = reinterpret_cast< wxWindow * >(argp1);
38744 {
38745 PyThreadState* __tstate = wxPyBeginAllowThreads();
38746 result = (arg1)->GetCursor();
38747 wxPyEndAllowThreads(__tstate);
38748 if (PyErr_Occurred()) SWIG_fail;
38749 }
38750 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38751 return resultobj;
38752 fail:
38753 return NULL;
38754 }
38755
38756
38757 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38758 PyObject *resultobj = 0;
38759 wxWindow *arg1 = (wxWindow *) 0 ;
38760 wxFont *arg2 = 0 ;
38761 bool result;
38762 void *argp1 = 0 ;
38763 int res1 = 0 ;
38764 void *argp2 = 0 ;
38765 int res2 = 0 ;
38766 PyObject * obj0 = 0 ;
38767 PyObject * obj1 = 0 ;
38768 char * kwnames[] = {
38769 (char *) "self",(char *) "font", NULL
38770 };
38771
38772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38774 if (!SWIG_IsOK(res1)) {
38775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38776 }
38777 arg1 = reinterpret_cast< wxWindow * >(argp1);
38778 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38779 if (!SWIG_IsOK(res2)) {
38780 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38781 }
38782 if (!argp2) {
38783 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38784 }
38785 arg2 = reinterpret_cast< wxFont * >(argp2);
38786 {
38787 PyThreadState* __tstate = wxPyBeginAllowThreads();
38788 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38789 wxPyEndAllowThreads(__tstate);
38790 if (PyErr_Occurred()) SWIG_fail;
38791 }
38792 {
38793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38794 }
38795 return resultobj;
38796 fail:
38797 return NULL;
38798 }
38799
38800
38801 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38802 PyObject *resultobj = 0;
38803 wxWindow *arg1 = (wxWindow *) 0 ;
38804 wxFont *arg2 = 0 ;
38805 void *argp1 = 0 ;
38806 int res1 = 0 ;
38807 void *argp2 = 0 ;
38808 int res2 = 0 ;
38809 PyObject * obj0 = 0 ;
38810 PyObject * obj1 = 0 ;
38811 char * kwnames[] = {
38812 (char *) "self",(char *) "font", NULL
38813 };
38814
38815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38817 if (!SWIG_IsOK(res1)) {
38818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38819 }
38820 arg1 = reinterpret_cast< wxWindow * >(argp1);
38821 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38822 if (!SWIG_IsOK(res2)) {
38823 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38824 }
38825 if (!argp2) {
38826 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38827 }
38828 arg2 = reinterpret_cast< wxFont * >(argp2);
38829 {
38830 PyThreadState* __tstate = wxPyBeginAllowThreads();
38831 (arg1)->SetOwnFont((wxFont const &)*arg2);
38832 wxPyEndAllowThreads(__tstate);
38833 if (PyErr_Occurred()) SWIG_fail;
38834 }
38835 resultobj = SWIG_Py_Void();
38836 return resultobj;
38837 fail:
38838 return NULL;
38839 }
38840
38841
38842 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38843 PyObject *resultobj = 0;
38844 wxWindow *arg1 = (wxWindow *) 0 ;
38845 wxFont result;
38846 void *argp1 = 0 ;
38847 int res1 = 0 ;
38848 PyObject *swig_obj[1] ;
38849
38850 if (!args) SWIG_fail;
38851 swig_obj[0] = args;
38852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38853 if (!SWIG_IsOK(res1)) {
38854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38855 }
38856 arg1 = reinterpret_cast< wxWindow * >(argp1);
38857 {
38858 PyThreadState* __tstate = wxPyBeginAllowThreads();
38859 result = (arg1)->GetFont();
38860 wxPyEndAllowThreads(__tstate);
38861 if (PyErr_Occurred()) SWIG_fail;
38862 }
38863 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
38864 return resultobj;
38865 fail:
38866 return NULL;
38867 }
38868
38869
38870 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38871 PyObject *resultobj = 0;
38872 wxWindow *arg1 = (wxWindow *) 0 ;
38873 wxCaret *arg2 = (wxCaret *) 0 ;
38874 void *argp1 = 0 ;
38875 int res1 = 0 ;
38876 int res2 = 0 ;
38877 PyObject * obj0 = 0 ;
38878 PyObject * obj1 = 0 ;
38879 char * kwnames[] = {
38880 (char *) "self",(char *) "caret", NULL
38881 };
38882
38883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
38884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38885 if (!SWIG_IsOK(res1)) {
38886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
38887 }
38888 arg1 = reinterpret_cast< wxWindow * >(argp1);
38889 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
38890 if (!SWIG_IsOK(res2)) {
38891 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
38892 }
38893 {
38894 PyThreadState* __tstate = wxPyBeginAllowThreads();
38895 (arg1)->SetCaret(arg2);
38896 wxPyEndAllowThreads(__tstate);
38897 if (PyErr_Occurred()) SWIG_fail;
38898 }
38899 resultobj = SWIG_Py_Void();
38900 return resultobj;
38901 fail:
38902 return NULL;
38903 }
38904
38905
38906 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38907 PyObject *resultobj = 0;
38908 wxWindow *arg1 = (wxWindow *) 0 ;
38909 wxCaret *result = 0 ;
38910 void *argp1 = 0 ;
38911 int res1 = 0 ;
38912 PyObject *swig_obj[1] ;
38913
38914 if (!args) SWIG_fail;
38915 swig_obj[0] = args;
38916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38917 if (!SWIG_IsOK(res1)) {
38918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
38919 }
38920 arg1 = reinterpret_cast< wxWindow * >(argp1);
38921 {
38922 PyThreadState* __tstate = wxPyBeginAllowThreads();
38923 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
38924 wxPyEndAllowThreads(__tstate);
38925 if (PyErr_Occurred()) SWIG_fail;
38926 }
38927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
38928 return resultobj;
38929 fail:
38930 return NULL;
38931 }
38932
38933
38934 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38935 PyObject *resultobj = 0;
38936 wxWindow *arg1 = (wxWindow *) 0 ;
38937 int result;
38938 void *argp1 = 0 ;
38939 int res1 = 0 ;
38940 PyObject *swig_obj[1] ;
38941
38942 if (!args) SWIG_fail;
38943 swig_obj[0] = args;
38944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38945 if (!SWIG_IsOK(res1)) {
38946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
38947 }
38948 arg1 = reinterpret_cast< wxWindow * >(argp1);
38949 {
38950 PyThreadState* __tstate = wxPyBeginAllowThreads();
38951 result = (int)((wxWindow const *)arg1)->GetCharHeight();
38952 wxPyEndAllowThreads(__tstate);
38953 if (PyErr_Occurred()) SWIG_fail;
38954 }
38955 resultobj = SWIG_From_int(static_cast< int >(result));
38956 return resultobj;
38957 fail:
38958 return NULL;
38959 }
38960
38961
38962 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38963 PyObject *resultobj = 0;
38964 wxWindow *arg1 = (wxWindow *) 0 ;
38965 int result;
38966 void *argp1 = 0 ;
38967 int res1 = 0 ;
38968 PyObject *swig_obj[1] ;
38969
38970 if (!args) SWIG_fail;
38971 swig_obj[0] = args;
38972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38973 if (!SWIG_IsOK(res1)) {
38974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
38975 }
38976 arg1 = reinterpret_cast< wxWindow * >(argp1);
38977 {
38978 PyThreadState* __tstate = wxPyBeginAllowThreads();
38979 result = (int)((wxWindow const *)arg1)->GetCharWidth();
38980 wxPyEndAllowThreads(__tstate);
38981 if (PyErr_Occurred()) SWIG_fail;
38982 }
38983 resultobj = SWIG_From_int(static_cast< int >(result));
38984 return resultobj;
38985 fail:
38986 return NULL;
38987 }
38988
38989
38990 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38991 PyObject *resultobj = 0;
38992 wxWindow *arg1 = (wxWindow *) 0 ;
38993 wxString *arg2 = 0 ;
38994 int *arg3 = (int *) 0 ;
38995 int *arg4 = (int *) 0 ;
38996 void *argp1 = 0 ;
38997 int res1 = 0 ;
38998 bool temp2 = false ;
38999 int temp3 ;
39000 int res3 = SWIG_TMPOBJ ;
39001 int temp4 ;
39002 int res4 = SWIG_TMPOBJ ;
39003 PyObject * obj0 = 0 ;
39004 PyObject * obj1 = 0 ;
39005 char * kwnames[] = {
39006 (char *) "self",(char *) "string", NULL
39007 };
39008
39009 arg3 = &temp3;
39010 arg4 = &temp4;
39011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
39012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39013 if (!SWIG_IsOK(res1)) {
39014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39015 }
39016 arg1 = reinterpret_cast< wxWindow * >(argp1);
39017 {
39018 arg2 = wxString_in_helper(obj1);
39019 if (arg2 == NULL) SWIG_fail;
39020 temp2 = true;
39021 }
39022 {
39023 PyThreadState* __tstate = wxPyBeginAllowThreads();
39024 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
39025 wxPyEndAllowThreads(__tstate);
39026 if (PyErr_Occurred()) SWIG_fail;
39027 }
39028 resultobj = SWIG_Py_Void();
39029 if (SWIG_IsTmpObj(res3)) {
39030 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39031 } else {
39032 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39033 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39034 }
39035 if (SWIG_IsTmpObj(res4)) {
39036 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39037 } else {
39038 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39039 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39040 }
39041 {
39042 if (temp2)
39043 delete arg2;
39044 }
39045 return resultobj;
39046 fail:
39047 {
39048 if (temp2)
39049 delete arg2;
39050 }
39051 return NULL;
39052 }
39053
39054
39055 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39056 PyObject *resultobj = 0;
39057 wxWindow *arg1 = (wxWindow *) 0 ;
39058 wxString *arg2 = 0 ;
39059 int *arg3 = (int *) 0 ;
39060 int *arg4 = (int *) 0 ;
39061 int *arg5 = (int *) 0 ;
39062 int *arg6 = (int *) 0 ;
39063 wxFont *arg7 = (wxFont *) NULL ;
39064 void *argp1 = 0 ;
39065 int res1 = 0 ;
39066 bool temp2 = false ;
39067 int temp3 ;
39068 int res3 = SWIG_TMPOBJ ;
39069 int temp4 ;
39070 int res4 = SWIG_TMPOBJ ;
39071 int temp5 ;
39072 int res5 = SWIG_TMPOBJ ;
39073 int temp6 ;
39074 int res6 = SWIG_TMPOBJ ;
39075 void *argp7 = 0 ;
39076 int res7 = 0 ;
39077 PyObject * obj0 = 0 ;
39078 PyObject * obj1 = 0 ;
39079 PyObject * obj2 = 0 ;
39080 char * kwnames[] = {
39081 (char *) "self",(char *) "string",(char *) "font", NULL
39082 };
39083
39084 arg3 = &temp3;
39085 arg4 = &temp4;
39086 arg5 = &temp5;
39087 arg6 = &temp6;
39088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39090 if (!SWIG_IsOK(res1)) {
39091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39092 }
39093 arg1 = reinterpret_cast< wxWindow * >(argp1);
39094 {
39095 arg2 = wxString_in_helper(obj1);
39096 if (arg2 == NULL) SWIG_fail;
39097 temp2 = true;
39098 }
39099 if (obj2) {
39100 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
39101 if (!SWIG_IsOK(res7)) {
39102 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
39103 }
39104 arg7 = reinterpret_cast< wxFont * >(argp7);
39105 }
39106 {
39107 PyThreadState* __tstate = wxPyBeginAllowThreads();
39108 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
39109 wxPyEndAllowThreads(__tstate);
39110 if (PyErr_Occurred()) SWIG_fail;
39111 }
39112 resultobj = SWIG_Py_Void();
39113 if (SWIG_IsTmpObj(res3)) {
39114 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39115 } else {
39116 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39117 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39118 }
39119 if (SWIG_IsTmpObj(res4)) {
39120 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39121 } else {
39122 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39123 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39124 }
39125 if (SWIG_IsTmpObj(res5)) {
39126 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
39127 } else {
39128 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39129 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
39130 }
39131 if (SWIG_IsTmpObj(res6)) {
39132 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
39133 } else {
39134 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39135 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
39136 }
39137 {
39138 if (temp2)
39139 delete arg2;
39140 }
39141 return resultobj;
39142 fail:
39143 {
39144 if (temp2)
39145 delete arg2;
39146 }
39147 return NULL;
39148 }
39149
39150
39151 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39152 PyObject *resultobj = 0;
39153 wxWindow *arg1 = (wxWindow *) 0 ;
39154 int *arg2 = (int *) 0 ;
39155 int *arg3 = (int *) 0 ;
39156 void *argp1 = 0 ;
39157 int res1 = 0 ;
39158 int temp2 ;
39159 int res2 = 0 ;
39160 int temp3 ;
39161 int res3 = 0 ;
39162 PyObject * obj0 = 0 ;
39163 PyObject * obj1 = 0 ;
39164 PyObject * obj2 = 0 ;
39165 char * kwnames[] = {
39166 (char *) "self",(char *) "x",(char *) "y", NULL
39167 };
39168
39169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39171 if (!SWIG_IsOK(res1)) {
39172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39173 }
39174 arg1 = reinterpret_cast< wxWindow * >(argp1);
39175 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39176 int val;
39177 int ecode = SWIG_AsVal_int(obj1, &val);
39178 if (!SWIG_IsOK(ecode)) {
39179 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39180 }
39181 temp2 = static_cast< int >(val);
39182 arg2 = &temp2;
39183 res2 = SWIG_AddTmpMask(ecode);
39184 }
39185 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39186 int val;
39187 int ecode = SWIG_AsVal_int(obj2, &val);
39188 if (!SWIG_IsOK(ecode)) {
39189 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39190 }
39191 temp3 = static_cast< int >(val);
39192 arg3 = &temp3;
39193 res3 = SWIG_AddTmpMask(ecode);
39194 }
39195 {
39196 PyThreadState* __tstate = wxPyBeginAllowThreads();
39197 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39198 wxPyEndAllowThreads(__tstate);
39199 if (PyErr_Occurred()) SWIG_fail;
39200 }
39201 resultobj = SWIG_Py_Void();
39202 if (SWIG_IsTmpObj(res2)) {
39203 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39204 } else {
39205 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39206 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39207 }
39208 if (SWIG_IsTmpObj(res3)) {
39209 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39210 } else {
39211 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39212 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39213 }
39214 return resultobj;
39215 fail:
39216 return NULL;
39217 }
39218
39219
39220 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39221 PyObject *resultobj = 0;
39222 wxWindow *arg1 = (wxWindow *) 0 ;
39223 int *arg2 = (int *) 0 ;
39224 int *arg3 = (int *) 0 ;
39225 void *argp1 = 0 ;
39226 int res1 = 0 ;
39227 int temp2 ;
39228 int res2 = 0 ;
39229 int temp3 ;
39230 int res3 = 0 ;
39231 PyObject * obj0 = 0 ;
39232 PyObject * obj1 = 0 ;
39233 PyObject * obj2 = 0 ;
39234 char * kwnames[] = {
39235 (char *) "self",(char *) "x",(char *) "y", NULL
39236 };
39237
39238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39240 if (!SWIG_IsOK(res1)) {
39241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39242 }
39243 arg1 = reinterpret_cast< wxWindow * >(argp1);
39244 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39245 int val;
39246 int ecode = SWIG_AsVal_int(obj1, &val);
39247 if (!SWIG_IsOK(ecode)) {
39248 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39249 }
39250 temp2 = static_cast< int >(val);
39251 arg2 = &temp2;
39252 res2 = SWIG_AddTmpMask(ecode);
39253 }
39254 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39255 int val;
39256 int ecode = SWIG_AsVal_int(obj2, &val);
39257 if (!SWIG_IsOK(ecode)) {
39258 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39259 }
39260 temp3 = static_cast< int >(val);
39261 arg3 = &temp3;
39262 res3 = SWIG_AddTmpMask(ecode);
39263 }
39264 {
39265 PyThreadState* __tstate = wxPyBeginAllowThreads();
39266 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39267 wxPyEndAllowThreads(__tstate);
39268 if (PyErr_Occurred()) SWIG_fail;
39269 }
39270 resultobj = SWIG_Py_Void();
39271 if (SWIG_IsTmpObj(res2)) {
39272 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39273 } else {
39274 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39275 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39276 }
39277 if (SWIG_IsTmpObj(res3)) {
39278 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39279 } else {
39280 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39281 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39282 }
39283 return resultobj;
39284 fail:
39285 return NULL;
39286 }
39287
39288
39289 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39290 PyObject *resultobj = 0;
39291 wxWindow *arg1 = (wxWindow *) 0 ;
39292 wxPoint *arg2 = 0 ;
39293 wxPoint result;
39294 void *argp1 = 0 ;
39295 int res1 = 0 ;
39296 wxPoint temp2 ;
39297 PyObject * obj0 = 0 ;
39298 PyObject * obj1 = 0 ;
39299 char * kwnames[] = {
39300 (char *) "self",(char *) "pt", NULL
39301 };
39302
39303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39305 if (!SWIG_IsOK(res1)) {
39306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39307 }
39308 arg1 = reinterpret_cast< wxWindow * >(argp1);
39309 {
39310 arg2 = &temp2;
39311 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39312 }
39313 {
39314 PyThreadState* __tstate = wxPyBeginAllowThreads();
39315 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39316 wxPyEndAllowThreads(__tstate);
39317 if (PyErr_Occurred()) SWIG_fail;
39318 }
39319 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39320 return resultobj;
39321 fail:
39322 return NULL;
39323 }
39324
39325
39326 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39327 PyObject *resultobj = 0;
39328 wxWindow *arg1 = (wxWindow *) 0 ;
39329 wxPoint *arg2 = 0 ;
39330 wxPoint result;
39331 void *argp1 = 0 ;
39332 int res1 = 0 ;
39333 wxPoint temp2 ;
39334 PyObject * obj0 = 0 ;
39335 PyObject * obj1 = 0 ;
39336 char * kwnames[] = {
39337 (char *) "self",(char *) "pt", NULL
39338 };
39339
39340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39342 if (!SWIG_IsOK(res1)) {
39343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39344 }
39345 arg1 = reinterpret_cast< wxWindow * >(argp1);
39346 {
39347 arg2 = &temp2;
39348 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39349 }
39350 {
39351 PyThreadState* __tstate = wxPyBeginAllowThreads();
39352 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39353 wxPyEndAllowThreads(__tstate);
39354 if (PyErr_Occurred()) SWIG_fail;
39355 }
39356 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39357 return resultobj;
39358 fail:
39359 return NULL;
39360 }
39361
39362
39363 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39364 PyObject *resultobj = 0;
39365 wxWindow *arg1 = (wxWindow *) 0 ;
39366 int arg2 ;
39367 int arg3 ;
39368 wxHitTest result;
39369 void *argp1 = 0 ;
39370 int res1 = 0 ;
39371 int val2 ;
39372 int ecode2 = 0 ;
39373 int val3 ;
39374 int ecode3 = 0 ;
39375 PyObject * obj0 = 0 ;
39376 PyObject * obj1 = 0 ;
39377 PyObject * obj2 = 0 ;
39378 char * kwnames[] = {
39379 (char *) "self",(char *) "x",(char *) "y", NULL
39380 };
39381
39382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39384 if (!SWIG_IsOK(res1)) {
39385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39386 }
39387 arg1 = reinterpret_cast< wxWindow * >(argp1);
39388 ecode2 = SWIG_AsVal_int(obj1, &val2);
39389 if (!SWIG_IsOK(ecode2)) {
39390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39391 }
39392 arg2 = static_cast< int >(val2);
39393 ecode3 = SWIG_AsVal_int(obj2, &val3);
39394 if (!SWIG_IsOK(ecode3)) {
39395 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39396 }
39397 arg3 = static_cast< int >(val3);
39398 {
39399 PyThreadState* __tstate = wxPyBeginAllowThreads();
39400 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39401 wxPyEndAllowThreads(__tstate);
39402 if (PyErr_Occurred()) SWIG_fail;
39403 }
39404 resultobj = SWIG_From_int(static_cast< int >(result));
39405 return resultobj;
39406 fail:
39407 return NULL;
39408 }
39409
39410
39411 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39412 PyObject *resultobj = 0;
39413 wxWindow *arg1 = (wxWindow *) 0 ;
39414 wxPoint *arg2 = 0 ;
39415 wxHitTest result;
39416 void *argp1 = 0 ;
39417 int res1 = 0 ;
39418 wxPoint temp2 ;
39419 PyObject * obj0 = 0 ;
39420 PyObject * obj1 = 0 ;
39421 char * kwnames[] = {
39422 (char *) "self",(char *) "pt", NULL
39423 };
39424
39425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39427 if (!SWIG_IsOK(res1)) {
39428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39429 }
39430 arg1 = reinterpret_cast< wxWindow * >(argp1);
39431 {
39432 arg2 = &temp2;
39433 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39434 }
39435 {
39436 PyThreadState* __tstate = wxPyBeginAllowThreads();
39437 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39438 wxPyEndAllowThreads(__tstate);
39439 if (PyErr_Occurred()) SWIG_fail;
39440 }
39441 resultobj = SWIG_From_int(static_cast< int >(result));
39442 return resultobj;
39443 fail:
39444 return NULL;
39445 }
39446
39447
39448 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39449 PyObject *resultobj = 0;
39450 wxWindow *arg1 = (wxWindow *) 0 ;
39451 long arg2 ;
39452 wxBorder result;
39453 void *argp1 = 0 ;
39454 int res1 = 0 ;
39455 long val2 ;
39456 int ecode2 = 0 ;
39457
39458 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39460 if (!SWIG_IsOK(res1)) {
39461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39462 }
39463 arg1 = reinterpret_cast< wxWindow * >(argp1);
39464 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39465 if (!SWIG_IsOK(ecode2)) {
39466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39467 }
39468 arg2 = static_cast< long >(val2);
39469 {
39470 PyThreadState* __tstate = wxPyBeginAllowThreads();
39471 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39472 wxPyEndAllowThreads(__tstate);
39473 if (PyErr_Occurred()) SWIG_fail;
39474 }
39475 resultobj = SWIG_From_int(static_cast< int >(result));
39476 return resultobj;
39477 fail:
39478 return NULL;
39479 }
39480
39481
39482 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39483 PyObject *resultobj = 0;
39484 wxWindow *arg1 = (wxWindow *) 0 ;
39485 wxBorder result;
39486 void *argp1 = 0 ;
39487 int res1 = 0 ;
39488
39489 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39491 if (!SWIG_IsOK(res1)) {
39492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39493 }
39494 arg1 = reinterpret_cast< wxWindow * >(argp1);
39495 {
39496 PyThreadState* __tstate = wxPyBeginAllowThreads();
39497 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39498 wxPyEndAllowThreads(__tstate);
39499 if (PyErr_Occurred()) SWIG_fail;
39500 }
39501 resultobj = SWIG_From_int(static_cast< int >(result));
39502 return resultobj;
39503 fail:
39504 return NULL;
39505 }
39506
39507
39508 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39509 int argc;
39510 PyObject *argv[3];
39511
39512 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39513 --argc;
39514 if (argc == 1) {
39515 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39516 }
39517 if (argc == 2) {
39518 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39519 }
39520
39521 fail:
39522 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39523 return NULL;
39524 }
39525
39526
39527 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39528 PyObject *resultobj = 0;
39529 wxWindow *arg1 = (wxWindow *) 0 ;
39530 long arg2 = (long) wxUPDATE_UI_NONE ;
39531 void *argp1 = 0 ;
39532 int res1 = 0 ;
39533 long val2 ;
39534 int ecode2 = 0 ;
39535 PyObject * obj0 = 0 ;
39536 PyObject * obj1 = 0 ;
39537 char * kwnames[] = {
39538 (char *) "self",(char *) "flags", NULL
39539 };
39540
39541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39543 if (!SWIG_IsOK(res1)) {
39544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39545 }
39546 arg1 = reinterpret_cast< wxWindow * >(argp1);
39547 if (obj1) {
39548 ecode2 = SWIG_AsVal_long(obj1, &val2);
39549 if (!SWIG_IsOK(ecode2)) {
39550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39551 }
39552 arg2 = static_cast< long >(val2);
39553 }
39554 {
39555 PyThreadState* __tstate = wxPyBeginAllowThreads();
39556 (arg1)->UpdateWindowUI(arg2);
39557 wxPyEndAllowThreads(__tstate);
39558 if (PyErr_Occurred()) SWIG_fail;
39559 }
39560 resultobj = SWIG_Py_Void();
39561 return resultobj;
39562 fail:
39563 return NULL;
39564 }
39565
39566
39567 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39568 PyObject *resultobj = 0;
39569 wxWindow *arg1 = (wxWindow *) 0 ;
39570 wxMenu *arg2 = (wxMenu *) 0 ;
39571 int arg3 = (int) -1 ;
39572 int arg4 = (int) -1 ;
39573 bool result;
39574 void *argp1 = 0 ;
39575 int res1 = 0 ;
39576 void *argp2 = 0 ;
39577 int res2 = 0 ;
39578 int val3 ;
39579 int ecode3 = 0 ;
39580 int val4 ;
39581 int ecode4 = 0 ;
39582 PyObject * obj0 = 0 ;
39583 PyObject * obj1 = 0 ;
39584 PyObject * obj2 = 0 ;
39585 PyObject * obj3 = 0 ;
39586 char * kwnames[] = {
39587 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39588 };
39589
39590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39592 if (!SWIG_IsOK(res1)) {
39593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39594 }
39595 arg1 = reinterpret_cast< wxWindow * >(argp1);
39596 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39597 if (!SWIG_IsOK(res2)) {
39598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39599 }
39600 arg2 = reinterpret_cast< wxMenu * >(argp2);
39601 if (obj2) {
39602 ecode3 = SWIG_AsVal_int(obj2, &val3);
39603 if (!SWIG_IsOK(ecode3)) {
39604 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39605 }
39606 arg3 = static_cast< int >(val3);
39607 }
39608 if (obj3) {
39609 ecode4 = SWIG_AsVal_int(obj3, &val4);
39610 if (!SWIG_IsOK(ecode4)) {
39611 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39612 }
39613 arg4 = static_cast< int >(val4);
39614 }
39615 {
39616 PyThreadState* __tstate = wxPyBeginAllowThreads();
39617 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39618 wxPyEndAllowThreads(__tstate);
39619 if (PyErr_Occurred()) SWIG_fail;
39620 }
39621 {
39622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39623 }
39624 return resultobj;
39625 fail:
39626 return NULL;
39627 }
39628
39629
39630 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39631 PyObject *resultobj = 0;
39632 wxWindow *arg1 = (wxWindow *) 0 ;
39633 wxMenu *arg2 = (wxMenu *) 0 ;
39634 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39635 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39636 bool result;
39637 void *argp1 = 0 ;
39638 int res1 = 0 ;
39639 void *argp2 = 0 ;
39640 int res2 = 0 ;
39641 wxPoint temp3 ;
39642 PyObject * obj0 = 0 ;
39643 PyObject * obj1 = 0 ;
39644 PyObject * obj2 = 0 ;
39645 char * kwnames[] = {
39646 (char *) "self",(char *) "menu",(char *) "pos", NULL
39647 };
39648
39649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39651 if (!SWIG_IsOK(res1)) {
39652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39653 }
39654 arg1 = reinterpret_cast< wxWindow * >(argp1);
39655 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39656 if (!SWIG_IsOK(res2)) {
39657 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39658 }
39659 arg2 = reinterpret_cast< wxMenu * >(argp2);
39660 if (obj2) {
39661 {
39662 arg3 = &temp3;
39663 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39664 }
39665 }
39666 {
39667 PyThreadState* __tstate = wxPyBeginAllowThreads();
39668 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39669 wxPyEndAllowThreads(__tstate);
39670 if (PyErr_Occurred()) SWIG_fail;
39671 }
39672 {
39673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39674 }
39675 return resultobj;
39676 fail:
39677 return NULL;
39678 }
39679
39680
39681 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39682 PyObject *resultobj = 0;
39683 wxWindow *arg1 = (wxWindow *) 0 ;
39684 bool result;
39685 void *argp1 = 0 ;
39686 int res1 = 0 ;
39687 PyObject *swig_obj[1] ;
39688
39689 if (!args) SWIG_fail;
39690 swig_obj[0] = args;
39691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39692 if (!SWIG_IsOK(res1)) {
39693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39694 }
39695 arg1 = reinterpret_cast< wxWindow * >(argp1);
39696 {
39697 PyThreadState* __tstate = wxPyBeginAllowThreads();
39698 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39699 wxPyEndAllowThreads(__tstate);
39700 if (PyErr_Occurred()) SWIG_fail;
39701 }
39702 {
39703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39704 }
39705 return resultobj;
39706 fail:
39707 return NULL;
39708 }
39709
39710
39711 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39712 PyObject *resultobj = 0;
39713 wxWindow *arg1 = (wxWindow *) 0 ;
39714 long result;
39715 void *argp1 = 0 ;
39716 int res1 = 0 ;
39717 PyObject *swig_obj[1] ;
39718
39719 if (!args) SWIG_fail;
39720 swig_obj[0] = args;
39721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39722 if (!SWIG_IsOK(res1)) {
39723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39724 }
39725 arg1 = reinterpret_cast< wxWindow * >(argp1);
39726 {
39727 PyThreadState* __tstate = wxPyBeginAllowThreads();
39728 result = (long)wxWindow_GetHandle(arg1);
39729 wxPyEndAllowThreads(__tstate);
39730 if (PyErr_Occurred()) SWIG_fail;
39731 }
39732 resultobj = SWIG_From_long(static_cast< long >(result));
39733 return resultobj;
39734 fail:
39735 return NULL;
39736 }
39737
39738
39739 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39740 PyObject *resultobj = 0;
39741 wxWindow *arg1 = (wxWindow *) 0 ;
39742 long arg2 ;
39743 void *argp1 = 0 ;
39744 int res1 = 0 ;
39745 long val2 ;
39746 int ecode2 = 0 ;
39747 PyObject * obj0 = 0 ;
39748 PyObject * obj1 = 0 ;
39749 char * kwnames[] = {
39750 (char *) "self",(char *) "handle", NULL
39751 };
39752
39753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39755 if (!SWIG_IsOK(res1)) {
39756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39757 }
39758 arg1 = reinterpret_cast< wxWindow * >(argp1);
39759 ecode2 = SWIG_AsVal_long(obj1, &val2);
39760 if (!SWIG_IsOK(ecode2)) {
39761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39762 }
39763 arg2 = static_cast< long >(val2);
39764 {
39765 PyThreadState* __tstate = wxPyBeginAllowThreads();
39766 wxWindow_AssociateHandle(arg1,arg2);
39767 wxPyEndAllowThreads(__tstate);
39768 if (PyErr_Occurred()) SWIG_fail;
39769 }
39770 resultobj = SWIG_Py_Void();
39771 return resultobj;
39772 fail:
39773 return NULL;
39774 }
39775
39776
39777 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39778 PyObject *resultobj = 0;
39779 wxWindow *arg1 = (wxWindow *) 0 ;
39780 void *argp1 = 0 ;
39781 int res1 = 0 ;
39782 PyObject *swig_obj[1] ;
39783
39784 if (!args) SWIG_fail;
39785 swig_obj[0] = args;
39786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39787 if (!SWIG_IsOK(res1)) {
39788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39789 }
39790 arg1 = reinterpret_cast< wxWindow * >(argp1);
39791 {
39792 PyThreadState* __tstate = wxPyBeginAllowThreads();
39793 (arg1)->DissociateHandle();
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_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39805 PyObject *resultobj = 0;
39806 wxWindow *arg1 = (wxWindow *) 0 ;
39807 int arg2 ;
39808 bool 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 *) "orient", NULL
39817 };
39818
39819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",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_HasScrollbar" "', 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_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39828 }
39829 arg2 = static_cast< int >(val2);
39830 {
39831 PyThreadState* __tstate = wxPyBeginAllowThreads();
39832 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39833 wxPyEndAllowThreads(__tstate);
39834 if (PyErr_Occurred()) SWIG_fail;
39835 }
39836 {
39837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39838 }
39839 return resultobj;
39840 fail:
39841 return NULL;
39842 }
39843
39844
39845 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39846 PyObject *resultobj = 0;
39847 wxWindow *arg1 = (wxWindow *) 0 ;
39848 int arg2 ;
39849 int arg3 ;
39850 int arg4 ;
39851 int arg5 ;
39852 bool arg6 = (bool) true ;
39853 void *argp1 = 0 ;
39854 int res1 = 0 ;
39855 int val2 ;
39856 int ecode2 = 0 ;
39857 int val3 ;
39858 int ecode3 = 0 ;
39859 int val4 ;
39860 int ecode4 = 0 ;
39861 int val5 ;
39862 int ecode5 = 0 ;
39863 bool val6 ;
39864 int ecode6 = 0 ;
39865 PyObject * obj0 = 0 ;
39866 PyObject * obj1 = 0 ;
39867 PyObject * obj2 = 0 ;
39868 PyObject * obj3 = 0 ;
39869 PyObject * obj4 = 0 ;
39870 PyObject * obj5 = 0 ;
39871 char * kwnames[] = {
39872 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
39873 };
39874
39875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39877 if (!SWIG_IsOK(res1)) {
39878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
39879 }
39880 arg1 = reinterpret_cast< wxWindow * >(argp1);
39881 ecode2 = SWIG_AsVal_int(obj1, &val2);
39882 if (!SWIG_IsOK(ecode2)) {
39883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
39884 }
39885 arg2 = static_cast< int >(val2);
39886 ecode3 = SWIG_AsVal_int(obj2, &val3);
39887 if (!SWIG_IsOK(ecode3)) {
39888 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
39889 }
39890 arg3 = static_cast< int >(val3);
39891 ecode4 = SWIG_AsVal_int(obj3, &val4);
39892 if (!SWIG_IsOK(ecode4)) {
39893 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
39894 }
39895 arg4 = static_cast< int >(val4);
39896 ecode5 = SWIG_AsVal_int(obj4, &val5);
39897 if (!SWIG_IsOK(ecode5)) {
39898 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
39899 }
39900 arg5 = static_cast< int >(val5);
39901 if (obj5) {
39902 ecode6 = SWIG_AsVal_bool(obj5, &val6);
39903 if (!SWIG_IsOK(ecode6)) {
39904 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
39905 }
39906 arg6 = static_cast< bool >(val6);
39907 }
39908 {
39909 PyThreadState* __tstate = wxPyBeginAllowThreads();
39910 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
39911 wxPyEndAllowThreads(__tstate);
39912 if (PyErr_Occurred()) SWIG_fail;
39913 }
39914 resultobj = SWIG_Py_Void();
39915 return resultobj;
39916 fail:
39917 return NULL;
39918 }
39919
39920
39921 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39922 PyObject *resultobj = 0;
39923 wxWindow *arg1 = (wxWindow *) 0 ;
39924 int arg2 ;
39925 int arg3 ;
39926 bool arg4 = (bool) true ;
39927 void *argp1 = 0 ;
39928 int res1 = 0 ;
39929 int val2 ;
39930 int ecode2 = 0 ;
39931 int val3 ;
39932 int ecode3 = 0 ;
39933 bool val4 ;
39934 int ecode4 = 0 ;
39935 PyObject * obj0 = 0 ;
39936 PyObject * obj1 = 0 ;
39937 PyObject * obj2 = 0 ;
39938 PyObject * obj3 = 0 ;
39939 char * kwnames[] = {
39940 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
39941 };
39942
39943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",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_SetScrollPos" "', 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_SetScrollPos" "', 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_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
39957 }
39958 arg3 = static_cast< int >(val3);
39959 if (obj3) {
39960 ecode4 = SWIG_AsVal_bool(obj3, &val4);
39961 if (!SWIG_IsOK(ecode4)) {
39962 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
39963 }
39964 arg4 = static_cast< bool >(val4);
39965 }
39966 {
39967 PyThreadState* __tstate = wxPyBeginAllowThreads();
39968 (arg1)->SetScrollPos(arg2,arg3,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_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39980 PyObject *resultobj = 0;
39981 wxWindow *arg1 = (wxWindow *) 0 ;
39982 int arg2 ;
39983 int 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 *) "orientation", NULL
39992 };
39993
39994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",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_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
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_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
40003 }
40004 arg2 = static_cast< int >(val2);
40005 {
40006 PyThreadState* __tstate = wxPyBeginAllowThreads();
40007 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
40008 wxPyEndAllowThreads(__tstate);
40009 if (PyErr_Occurred()) SWIG_fail;
40010 }
40011 resultobj = SWIG_From_int(static_cast< int >(result));
40012 return resultobj;
40013 fail:
40014 return NULL;
40015 }
40016
40017
40018 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40019 PyObject *resultobj = 0;
40020 wxWindow *arg1 = (wxWindow *) 0 ;
40021 int arg2 ;
40022 int result;
40023 void *argp1 = 0 ;
40024 int res1 = 0 ;
40025 int val2 ;
40026 int ecode2 = 0 ;
40027 PyObject * obj0 = 0 ;
40028 PyObject * obj1 = 0 ;
40029 char * kwnames[] = {
40030 (char *) "self",(char *) "orientation", NULL
40031 };
40032
40033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
40034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40035 if (!SWIG_IsOK(res1)) {
40036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
40037 }
40038 arg1 = reinterpret_cast< wxWindow * >(argp1);
40039 ecode2 = SWIG_AsVal_int(obj1, &val2);
40040 if (!SWIG_IsOK(ecode2)) {
40041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
40042 }
40043 arg2 = static_cast< int >(val2);
40044 {
40045 PyThreadState* __tstate = wxPyBeginAllowThreads();
40046 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
40047 wxPyEndAllowThreads(__tstate);
40048 if (PyErr_Occurred()) SWIG_fail;
40049 }
40050 resultobj = SWIG_From_int(static_cast< int >(result));
40051 return resultobj;
40052 fail:
40053 return NULL;
40054 }
40055
40056
40057 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40058 PyObject *resultobj = 0;
40059 wxWindow *arg1 = (wxWindow *) 0 ;
40060 int arg2 ;
40061 int result;
40062 void *argp1 = 0 ;
40063 int res1 = 0 ;
40064 int val2 ;
40065 int ecode2 = 0 ;
40066 PyObject * obj0 = 0 ;
40067 PyObject * obj1 = 0 ;
40068 char * kwnames[] = {
40069 (char *) "self",(char *) "orientation", NULL
40070 };
40071
40072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
40073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40074 if (!SWIG_IsOK(res1)) {
40075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
40076 }
40077 arg1 = reinterpret_cast< wxWindow * >(argp1);
40078 ecode2 = SWIG_AsVal_int(obj1, &val2);
40079 if (!SWIG_IsOK(ecode2)) {
40080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
40081 }
40082 arg2 = static_cast< int >(val2);
40083 {
40084 PyThreadState* __tstate = wxPyBeginAllowThreads();
40085 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
40086 wxPyEndAllowThreads(__tstate);
40087 if (PyErr_Occurred()) SWIG_fail;
40088 }
40089 resultobj = SWIG_From_int(static_cast< int >(result));
40090 return resultobj;
40091 fail:
40092 return NULL;
40093 }
40094
40095
40096 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40097 PyObject *resultobj = 0;
40098 wxWindow *arg1 = (wxWindow *) 0 ;
40099 int arg2 ;
40100 int arg3 ;
40101 wxRect *arg4 = (wxRect *) NULL ;
40102 void *argp1 = 0 ;
40103 int res1 = 0 ;
40104 int val2 ;
40105 int ecode2 = 0 ;
40106 int val3 ;
40107 int ecode3 = 0 ;
40108 void *argp4 = 0 ;
40109 int res4 = 0 ;
40110 PyObject * obj0 = 0 ;
40111 PyObject * obj1 = 0 ;
40112 PyObject * obj2 = 0 ;
40113 PyObject * obj3 = 0 ;
40114 char * kwnames[] = {
40115 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
40116 };
40117
40118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40120 if (!SWIG_IsOK(res1)) {
40121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
40122 }
40123 arg1 = reinterpret_cast< wxWindow * >(argp1);
40124 ecode2 = SWIG_AsVal_int(obj1, &val2);
40125 if (!SWIG_IsOK(ecode2)) {
40126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
40127 }
40128 arg2 = static_cast< int >(val2);
40129 ecode3 = SWIG_AsVal_int(obj2, &val3);
40130 if (!SWIG_IsOK(ecode3)) {
40131 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
40132 }
40133 arg3 = static_cast< int >(val3);
40134 if (obj3) {
40135 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
40136 if (!SWIG_IsOK(res4)) {
40137 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
40138 }
40139 arg4 = reinterpret_cast< wxRect * >(argp4);
40140 }
40141 {
40142 PyThreadState* __tstate = wxPyBeginAllowThreads();
40143 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
40144 wxPyEndAllowThreads(__tstate);
40145 if (PyErr_Occurred()) SWIG_fail;
40146 }
40147 resultobj = SWIG_Py_Void();
40148 return resultobj;
40149 fail:
40150 return NULL;
40151 }
40152
40153
40154 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40155 PyObject *resultobj = 0;
40156 wxWindow *arg1 = (wxWindow *) 0 ;
40157 int arg2 ;
40158 bool result;
40159 void *argp1 = 0 ;
40160 int res1 = 0 ;
40161 int val2 ;
40162 int ecode2 = 0 ;
40163 PyObject * obj0 = 0 ;
40164 PyObject * obj1 = 0 ;
40165 char * kwnames[] = {
40166 (char *) "self",(char *) "lines", NULL
40167 };
40168
40169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40171 if (!SWIG_IsOK(res1)) {
40172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40173 }
40174 arg1 = reinterpret_cast< wxWindow * >(argp1);
40175 ecode2 = SWIG_AsVal_int(obj1, &val2);
40176 if (!SWIG_IsOK(ecode2)) {
40177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40178 }
40179 arg2 = static_cast< int >(val2);
40180 {
40181 PyThreadState* __tstate = wxPyBeginAllowThreads();
40182 result = (bool)(arg1)->ScrollLines(arg2);
40183 wxPyEndAllowThreads(__tstate);
40184 if (PyErr_Occurred()) SWIG_fail;
40185 }
40186 {
40187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40188 }
40189 return resultobj;
40190 fail:
40191 return NULL;
40192 }
40193
40194
40195 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40196 PyObject *resultobj = 0;
40197 wxWindow *arg1 = (wxWindow *) 0 ;
40198 int arg2 ;
40199 bool result;
40200 void *argp1 = 0 ;
40201 int res1 = 0 ;
40202 int val2 ;
40203 int ecode2 = 0 ;
40204 PyObject * obj0 = 0 ;
40205 PyObject * obj1 = 0 ;
40206 char * kwnames[] = {
40207 (char *) "self",(char *) "pages", NULL
40208 };
40209
40210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40212 if (!SWIG_IsOK(res1)) {
40213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40214 }
40215 arg1 = reinterpret_cast< wxWindow * >(argp1);
40216 ecode2 = SWIG_AsVal_int(obj1, &val2);
40217 if (!SWIG_IsOK(ecode2)) {
40218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40219 }
40220 arg2 = static_cast< int >(val2);
40221 {
40222 PyThreadState* __tstate = wxPyBeginAllowThreads();
40223 result = (bool)(arg1)->ScrollPages(arg2);
40224 wxPyEndAllowThreads(__tstate);
40225 if (PyErr_Occurred()) SWIG_fail;
40226 }
40227 {
40228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40229 }
40230 return resultobj;
40231 fail:
40232 return NULL;
40233 }
40234
40235
40236 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40237 PyObject *resultobj = 0;
40238 wxWindow *arg1 = (wxWindow *) 0 ;
40239 bool result;
40240 void *argp1 = 0 ;
40241 int res1 = 0 ;
40242 PyObject *swig_obj[1] ;
40243
40244 if (!args) SWIG_fail;
40245 swig_obj[0] = args;
40246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40247 if (!SWIG_IsOK(res1)) {
40248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40249 }
40250 arg1 = reinterpret_cast< wxWindow * >(argp1);
40251 {
40252 PyThreadState* __tstate = wxPyBeginAllowThreads();
40253 result = (bool)(arg1)->LineUp();
40254 wxPyEndAllowThreads(__tstate);
40255 if (PyErr_Occurred()) SWIG_fail;
40256 }
40257 {
40258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40259 }
40260 return resultobj;
40261 fail:
40262 return NULL;
40263 }
40264
40265
40266 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40267 PyObject *resultobj = 0;
40268 wxWindow *arg1 = (wxWindow *) 0 ;
40269 bool result;
40270 void *argp1 = 0 ;
40271 int res1 = 0 ;
40272 PyObject *swig_obj[1] ;
40273
40274 if (!args) SWIG_fail;
40275 swig_obj[0] = args;
40276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40277 if (!SWIG_IsOK(res1)) {
40278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40279 }
40280 arg1 = reinterpret_cast< wxWindow * >(argp1);
40281 {
40282 PyThreadState* __tstate = wxPyBeginAllowThreads();
40283 result = (bool)(arg1)->LineDown();
40284 wxPyEndAllowThreads(__tstate);
40285 if (PyErr_Occurred()) SWIG_fail;
40286 }
40287 {
40288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40289 }
40290 return resultobj;
40291 fail:
40292 return NULL;
40293 }
40294
40295
40296 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40297 PyObject *resultobj = 0;
40298 wxWindow *arg1 = (wxWindow *) 0 ;
40299 bool result;
40300 void *argp1 = 0 ;
40301 int res1 = 0 ;
40302 PyObject *swig_obj[1] ;
40303
40304 if (!args) SWIG_fail;
40305 swig_obj[0] = args;
40306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40307 if (!SWIG_IsOK(res1)) {
40308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40309 }
40310 arg1 = reinterpret_cast< wxWindow * >(argp1);
40311 {
40312 PyThreadState* __tstate = wxPyBeginAllowThreads();
40313 result = (bool)(arg1)->PageUp();
40314 wxPyEndAllowThreads(__tstate);
40315 if (PyErr_Occurred()) SWIG_fail;
40316 }
40317 {
40318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40319 }
40320 return resultobj;
40321 fail:
40322 return NULL;
40323 }
40324
40325
40326 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40327 PyObject *resultobj = 0;
40328 wxWindow *arg1 = (wxWindow *) 0 ;
40329 bool result;
40330 void *argp1 = 0 ;
40331 int res1 = 0 ;
40332 PyObject *swig_obj[1] ;
40333
40334 if (!args) SWIG_fail;
40335 swig_obj[0] = args;
40336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40337 if (!SWIG_IsOK(res1)) {
40338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40339 }
40340 arg1 = reinterpret_cast< wxWindow * >(argp1);
40341 {
40342 PyThreadState* __tstate = wxPyBeginAllowThreads();
40343 result = (bool)(arg1)->PageDown();
40344 wxPyEndAllowThreads(__tstate);
40345 if (PyErr_Occurred()) SWIG_fail;
40346 }
40347 {
40348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40349 }
40350 return resultobj;
40351 fail:
40352 return NULL;
40353 }
40354
40355
40356 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40357 PyObject *resultobj = 0;
40358 wxWindow *arg1 = (wxWindow *) 0 ;
40359 wxString *arg2 = 0 ;
40360 void *argp1 = 0 ;
40361 int res1 = 0 ;
40362 bool temp2 = false ;
40363 PyObject * obj0 = 0 ;
40364 PyObject * obj1 = 0 ;
40365 char * kwnames[] = {
40366 (char *) "self",(char *) "text", NULL
40367 };
40368
40369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40371 if (!SWIG_IsOK(res1)) {
40372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40373 }
40374 arg1 = reinterpret_cast< wxWindow * >(argp1);
40375 {
40376 arg2 = wxString_in_helper(obj1);
40377 if (arg2 == NULL) SWIG_fail;
40378 temp2 = true;
40379 }
40380 {
40381 PyThreadState* __tstate = wxPyBeginAllowThreads();
40382 (arg1)->SetHelpText((wxString const &)*arg2);
40383 wxPyEndAllowThreads(__tstate);
40384 if (PyErr_Occurred()) SWIG_fail;
40385 }
40386 resultobj = SWIG_Py_Void();
40387 {
40388 if (temp2)
40389 delete arg2;
40390 }
40391 return resultobj;
40392 fail:
40393 {
40394 if (temp2)
40395 delete arg2;
40396 }
40397 return NULL;
40398 }
40399
40400
40401 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40402 PyObject *resultobj = 0;
40403 wxWindow *arg1 = (wxWindow *) 0 ;
40404 wxString *arg2 = 0 ;
40405 void *argp1 = 0 ;
40406 int res1 = 0 ;
40407 bool temp2 = false ;
40408 PyObject * obj0 = 0 ;
40409 PyObject * obj1 = 0 ;
40410 char * kwnames[] = {
40411 (char *) "self",(char *) "text", NULL
40412 };
40413
40414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40416 if (!SWIG_IsOK(res1)) {
40417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40418 }
40419 arg1 = reinterpret_cast< wxWindow * >(argp1);
40420 {
40421 arg2 = wxString_in_helper(obj1);
40422 if (arg2 == NULL) SWIG_fail;
40423 temp2 = true;
40424 }
40425 {
40426 PyThreadState* __tstate = wxPyBeginAllowThreads();
40427 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40428 wxPyEndAllowThreads(__tstate);
40429 if (PyErr_Occurred()) SWIG_fail;
40430 }
40431 resultobj = SWIG_Py_Void();
40432 {
40433 if (temp2)
40434 delete arg2;
40435 }
40436 return resultobj;
40437 fail:
40438 {
40439 if (temp2)
40440 delete arg2;
40441 }
40442 return NULL;
40443 }
40444
40445
40446 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40447 PyObject *resultobj = 0;
40448 wxWindow *arg1 = (wxWindow *) 0 ;
40449 wxPoint *arg2 = 0 ;
40450 wxHelpEvent::Origin arg3 ;
40451 wxString result;
40452 void *argp1 = 0 ;
40453 int res1 = 0 ;
40454 wxPoint temp2 ;
40455 void *argp3 ;
40456 int res3 = 0 ;
40457 PyObject * obj0 = 0 ;
40458 PyObject * obj1 = 0 ;
40459 PyObject * obj2 = 0 ;
40460 char * kwnames[] = {
40461 (char *) "self",(char *) "pt",(char *) "origin", NULL
40462 };
40463
40464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40466 if (!SWIG_IsOK(res1)) {
40467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40468 }
40469 arg1 = reinterpret_cast< wxWindow * >(argp1);
40470 {
40471 arg2 = &temp2;
40472 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40473 }
40474 {
40475 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40476 if (!SWIG_IsOK(res3)) {
40477 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40478 }
40479 if (!argp3) {
40480 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40481 } else {
40482 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40483 arg3 = *temp;
40484 if (SWIG_IsNewObj(res3)) delete temp;
40485 }
40486 }
40487 {
40488 PyThreadState* __tstate = wxPyBeginAllowThreads();
40489 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40490 wxPyEndAllowThreads(__tstate);
40491 if (PyErr_Occurred()) SWIG_fail;
40492 }
40493 {
40494 #if wxUSE_UNICODE
40495 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40496 #else
40497 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40498 #endif
40499 }
40500 return resultobj;
40501 fail:
40502 return NULL;
40503 }
40504
40505
40506 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40507 PyObject *resultobj = 0;
40508 wxWindow *arg1 = (wxWindow *) 0 ;
40509 wxString result;
40510 void *argp1 = 0 ;
40511 int res1 = 0 ;
40512 PyObject *swig_obj[1] ;
40513
40514 if (!args) SWIG_fail;
40515 swig_obj[0] = args;
40516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40517 if (!SWIG_IsOK(res1)) {
40518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40519 }
40520 arg1 = reinterpret_cast< wxWindow * >(argp1);
40521 {
40522 PyThreadState* __tstate = wxPyBeginAllowThreads();
40523 result = ((wxWindow const *)arg1)->GetHelpText();
40524 wxPyEndAllowThreads(__tstate);
40525 if (PyErr_Occurred()) SWIG_fail;
40526 }
40527 {
40528 #if wxUSE_UNICODE
40529 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40530 #else
40531 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40532 #endif
40533 }
40534 return resultobj;
40535 fail:
40536 return NULL;
40537 }
40538
40539
40540 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40541 PyObject *resultobj = 0;
40542 wxWindow *arg1 = (wxWindow *) 0 ;
40543 wxString *arg2 = 0 ;
40544 void *argp1 = 0 ;
40545 int res1 = 0 ;
40546 bool temp2 = false ;
40547 PyObject * obj0 = 0 ;
40548 PyObject * obj1 = 0 ;
40549 char * kwnames[] = {
40550 (char *) "self",(char *) "tip", NULL
40551 };
40552
40553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40555 if (!SWIG_IsOK(res1)) {
40556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40557 }
40558 arg1 = reinterpret_cast< wxWindow * >(argp1);
40559 {
40560 arg2 = wxString_in_helper(obj1);
40561 if (arg2 == NULL) SWIG_fail;
40562 temp2 = true;
40563 }
40564 {
40565 PyThreadState* __tstate = wxPyBeginAllowThreads();
40566 (arg1)->SetToolTip((wxString const &)*arg2);
40567 wxPyEndAllowThreads(__tstate);
40568 if (PyErr_Occurred()) SWIG_fail;
40569 }
40570 resultobj = SWIG_Py_Void();
40571 {
40572 if (temp2)
40573 delete arg2;
40574 }
40575 return resultobj;
40576 fail:
40577 {
40578 if (temp2)
40579 delete arg2;
40580 }
40581 return NULL;
40582 }
40583
40584
40585 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40586 PyObject *resultobj = 0;
40587 wxWindow *arg1 = (wxWindow *) 0 ;
40588 wxToolTip *arg2 = (wxToolTip *) 0 ;
40589 void *argp1 = 0 ;
40590 int res1 = 0 ;
40591 int res2 = 0 ;
40592 PyObject * obj0 = 0 ;
40593 PyObject * obj1 = 0 ;
40594 char * kwnames[] = {
40595 (char *) "self",(char *) "tip", NULL
40596 };
40597
40598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40600 if (!SWIG_IsOK(res1)) {
40601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40602 }
40603 arg1 = reinterpret_cast< wxWindow * >(argp1);
40604 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40605 if (!SWIG_IsOK(res2)) {
40606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40607 }
40608 {
40609 PyThreadState* __tstate = wxPyBeginAllowThreads();
40610 (arg1)->SetToolTip(arg2);
40611 wxPyEndAllowThreads(__tstate);
40612 if (PyErr_Occurred()) SWIG_fail;
40613 }
40614 resultobj = SWIG_Py_Void();
40615 return resultobj;
40616 fail:
40617 return NULL;
40618 }
40619
40620
40621 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40622 PyObject *resultobj = 0;
40623 wxWindow *arg1 = (wxWindow *) 0 ;
40624 wxToolTip *result = 0 ;
40625 void *argp1 = 0 ;
40626 int res1 = 0 ;
40627 PyObject *swig_obj[1] ;
40628
40629 if (!args) SWIG_fail;
40630 swig_obj[0] = args;
40631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40632 if (!SWIG_IsOK(res1)) {
40633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40634 }
40635 arg1 = reinterpret_cast< wxWindow * >(argp1);
40636 {
40637 PyThreadState* __tstate = wxPyBeginAllowThreads();
40638 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40639 wxPyEndAllowThreads(__tstate);
40640 if (PyErr_Occurred()) SWIG_fail;
40641 }
40642 {
40643 resultobj = wxPyMake_wxObject(result, (bool)0);
40644 }
40645 return resultobj;
40646 fail:
40647 return NULL;
40648 }
40649
40650
40651 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40652 PyObject *resultobj = 0;
40653 wxWindow *arg1 = (wxWindow *) 0 ;
40654 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40655 void *argp1 = 0 ;
40656 int res1 = 0 ;
40657 int res2 = 0 ;
40658 PyObject * obj0 = 0 ;
40659 PyObject * obj1 = 0 ;
40660 char * kwnames[] = {
40661 (char *) "self",(char *) "dropTarget", NULL
40662 };
40663
40664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40666 if (!SWIG_IsOK(res1)) {
40667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40668 }
40669 arg1 = reinterpret_cast< wxWindow * >(argp1);
40670 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40671 if (!SWIG_IsOK(res2)) {
40672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40673 }
40674 {
40675 PyThreadState* __tstate = wxPyBeginAllowThreads();
40676 (arg1)->SetDropTarget(arg2);
40677 wxPyEndAllowThreads(__tstate);
40678 if (PyErr_Occurred()) SWIG_fail;
40679 }
40680 resultobj = SWIG_Py_Void();
40681 return resultobj;
40682 fail:
40683 return NULL;
40684 }
40685
40686
40687 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40688 PyObject *resultobj = 0;
40689 wxWindow *arg1 = (wxWindow *) 0 ;
40690 wxPyDropTarget *result = 0 ;
40691 void *argp1 = 0 ;
40692 int res1 = 0 ;
40693 PyObject *swig_obj[1] ;
40694
40695 if (!args) SWIG_fail;
40696 swig_obj[0] = args;
40697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40698 if (!SWIG_IsOK(res1)) {
40699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40700 }
40701 arg1 = reinterpret_cast< wxWindow * >(argp1);
40702 {
40703 PyThreadState* __tstate = wxPyBeginAllowThreads();
40704 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40705 wxPyEndAllowThreads(__tstate);
40706 if (PyErr_Occurred()) SWIG_fail;
40707 }
40708 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40709 return resultobj;
40710 fail:
40711 return NULL;
40712 }
40713
40714
40715 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40716 PyObject *resultobj = 0;
40717 wxWindow *arg1 = (wxWindow *) 0 ;
40718 bool arg2 ;
40719 void *argp1 = 0 ;
40720 int res1 = 0 ;
40721 bool val2 ;
40722 int ecode2 = 0 ;
40723 PyObject * obj0 = 0 ;
40724 PyObject * obj1 = 0 ;
40725 char * kwnames[] = {
40726 (char *) "self",(char *) "accept", NULL
40727 };
40728
40729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40731 if (!SWIG_IsOK(res1)) {
40732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40733 }
40734 arg1 = reinterpret_cast< wxWindow * >(argp1);
40735 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40736 if (!SWIG_IsOK(ecode2)) {
40737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40738 }
40739 arg2 = static_cast< bool >(val2);
40740 {
40741 PyThreadState* __tstate = wxPyBeginAllowThreads();
40742 wxWindow_DragAcceptFiles(arg1,arg2);
40743 wxPyEndAllowThreads(__tstate);
40744 if (PyErr_Occurred()) SWIG_fail;
40745 }
40746 resultobj = SWIG_Py_Void();
40747 return resultobj;
40748 fail:
40749 return NULL;
40750 }
40751
40752
40753 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40754 PyObject *resultobj = 0;
40755 wxWindow *arg1 = (wxWindow *) 0 ;
40756 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40757 void *argp1 = 0 ;
40758 int res1 = 0 ;
40759 int res2 = 0 ;
40760 PyObject * obj0 = 0 ;
40761 PyObject * obj1 = 0 ;
40762 char * kwnames[] = {
40763 (char *) "self",(char *) "constraints", NULL
40764 };
40765
40766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40768 if (!SWIG_IsOK(res1)) {
40769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40770 }
40771 arg1 = reinterpret_cast< wxWindow * >(argp1);
40772 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40773 if (!SWIG_IsOK(res2)) {
40774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40775 }
40776 {
40777 PyThreadState* __tstate = wxPyBeginAllowThreads();
40778 (arg1)->SetConstraints(arg2);
40779 wxPyEndAllowThreads(__tstate);
40780 if (PyErr_Occurred()) SWIG_fail;
40781 }
40782 resultobj = SWIG_Py_Void();
40783 return resultobj;
40784 fail:
40785 return NULL;
40786 }
40787
40788
40789 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40790 PyObject *resultobj = 0;
40791 wxWindow *arg1 = (wxWindow *) 0 ;
40792 wxLayoutConstraints *result = 0 ;
40793 void *argp1 = 0 ;
40794 int res1 = 0 ;
40795 PyObject *swig_obj[1] ;
40796
40797 if (!args) SWIG_fail;
40798 swig_obj[0] = args;
40799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40800 if (!SWIG_IsOK(res1)) {
40801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40802 }
40803 arg1 = reinterpret_cast< wxWindow * >(argp1);
40804 {
40805 PyThreadState* __tstate = wxPyBeginAllowThreads();
40806 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40807 wxPyEndAllowThreads(__tstate);
40808 if (PyErr_Occurred()) SWIG_fail;
40809 }
40810 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40811 return resultobj;
40812 fail:
40813 return NULL;
40814 }
40815
40816
40817 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40818 PyObject *resultobj = 0;
40819 wxWindow *arg1 = (wxWindow *) 0 ;
40820 bool arg2 ;
40821 void *argp1 = 0 ;
40822 int res1 = 0 ;
40823 bool val2 ;
40824 int ecode2 = 0 ;
40825 PyObject * obj0 = 0 ;
40826 PyObject * obj1 = 0 ;
40827 char * kwnames[] = {
40828 (char *) "self",(char *) "autoLayout", NULL
40829 };
40830
40831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40833 if (!SWIG_IsOK(res1)) {
40834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40835 }
40836 arg1 = reinterpret_cast< wxWindow * >(argp1);
40837 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40838 if (!SWIG_IsOK(ecode2)) {
40839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40840 }
40841 arg2 = static_cast< bool >(val2);
40842 {
40843 PyThreadState* __tstate = wxPyBeginAllowThreads();
40844 (arg1)->SetAutoLayout(arg2);
40845 wxPyEndAllowThreads(__tstate);
40846 if (PyErr_Occurred()) SWIG_fail;
40847 }
40848 resultobj = SWIG_Py_Void();
40849 return resultobj;
40850 fail:
40851 return NULL;
40852 }
40853
40854
40855 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40856 PyObject *resultobj = 0;
40857 wxWindow *arg1 = (wxWindow *) 0 ;
40858 bool result;
40859 void *argp1 = 0 ;
40860 int res1 = 0 ;
40861 PyObject *swig_obj[1] ;
40862
40863 if (!args) SWIG_fail;
40864 swig_obj[0] = args;
40865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40866 if (!SWIG_IsOK(res1)) {
40867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
40868 }
40869 arg1 = reinterpret_cast< wxWindow * >(argp1);
40870 {
40871 PyThreadState* __tstate = wxPyBeginAllowThreads();
40872 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
40873 wxPyEndAllowThreads(__tstate);
40874 if (PyErr_Occurred()) SWIG_fail;
40875 }
40876 {
40877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40878 }
40879 return resultobj;
40880 fail:
40881 return NULL;
40882 }
40883
40884
40885 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40886 PyObject *resultobj = 0;
40887 wxWindow *arg1 = (wxWindow *) 0 ;
40888 bool result;
40889 void *argp1 = 0 ;
40890 int res1 = 0 ;
40891 PyObject *swig_obj[1] ;
40892
40893 if (!args) SWIG_fail;
40894 swig_obj[0] = args;
40895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40896 if (!SWIG_IsOK(res1)) {
40897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
40898 }
40899 arg1 = reinterpret_cast< wxWindow * >(argp1);
40900 {
40901 PyThreadState* __tstate = wxPyBeginAllowThreads();
40902 result = (bool)(arg1)->Layout();
40903 wxPyEndAllowThreads(__tstate);
40904 if (PyErr_Occurred()) SWIG_fail;
40905 }
40906 {
40907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40908 }
40909 return resultobj;
40910 fail:
40911 return NULL;
40912 }
40913
40914
40915 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40916 PyObject *resultobj = 0;
40917 wxWindow *arg1 = (wxWindow *) 0 ;
40918 wxSizer *arg2 = (wxSizer *) 0 ;
40919 bool arg3 = (bool) true ;
40920 void *argp1 = 0 ;
40921 int res1 = 0 ;
40922 int res2 = 0 ;
40923 bool val3 ;
40924 int ecode3 = 0 ;
40925 PyObject * obj0 = 0 ;
40926 PyObject * obj1 = 0 ;
40927 PyObject * obj2 = 0 ;
40928 char * kwnames[] = {
40929 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40930 };
40931
40932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40934 if (!SWIG_IsOK(res1)) {
40935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40936 }
40937 arg1 = reinterpret_cast< wxWindow * >(argp1);
40938 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40939 if (!SWIG_IsOK(res2)) {
40940 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40941 }
40942 if (obj2) {
40943 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40944 if (!SWIG_IsOK(ecode3)) {
40945 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
40946 }
40947 arg3 = static_cast< bool >(val3);
40948 }
40949 {
40950 PyThreadState* __tstate = wxPyBeginAllowThreads();
40951 (arg1)->SetSizer(arg2,arg3);
40952 wxPyEndAllowThreads(__tstate);
40953 if (PyErr_Occurred()) SWIG_fail;
40954 }
40955 resultobj = SWIG_Py_Void();
40956 return resultobj;
40957 fail:
40958 return NULL;
40959 }
40960
40961
40962 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40963 PyObject *resultobj = 0;
40964 wxWindow *arg1 = (wxWindow *) 0 ;
40965 wxSizer *arg2 = (wxSizer *) 0 ;
40966 bool arg3 = (bool) true ;
40967 void *argp1 = 0 ;
40968 int res1 = 0 ;
40969 int res2 = 0 ;
40970 bool val3 ;
40971 int ecode3 = 0 ;
40972 PyObject * obj0 = 0 ;
40973 PyObject * obj1 = 0 ;
40974 PyObject * obj2 = 0 ;
40975 char * kwnames[] = {
40976 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40977 };
40978
40979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40981 if (!SWIG_IsOK(res1)) {
40982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
40983 }
40984 arg1 = reinterpret_cast< wxWindow * >(argp1);
40985 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40986 if (!SWIG_IsOK(res2)) {
40987 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
40988 }
40989 if (obj2) {
40990 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40991 if (!SWIG_IsOK(ecode3)) {
40992 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
40993 }
40994 arg3 = static_cast< bool >(val3);
40995 }
40996 {
40997 PyThreadState* __tstate = wxPyBeginAllowThreads();
40998 (arg1)->SetSizerAndFit(arg2,arg3);
40999 wxPyEndAllowThreads(__tstate);
41000 if (PyErr_Occurred()) SWIG_fail;
41001 }
41002 resultobj = SWIG_Py_Void();
41003 return resultobj;
41004 fail:
41005 return NULL;
41006 }
41007
41008
41009 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41010 PyObject *resultobj = 0;
41011 wxWindow *arg1 = (wxWindow *) 0 ;
41012 wxSizer *result = 0 ;
41013 void *argp1 = 0 ;
41014 int res1 = 0 ;
41015 PyObject *swig_obj[1] ;
41016
41017 if (!args) SWIG_fail;
41018 swig_obj[0] = args;
41019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41020 if (!SWIG_IsOK(res1)) {
41021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41022 }
41023 arg1 = reinterpret_cast< wxWindow * >(argp1);
41024 {
41025 PyThreadState* __tstate = wxPyBeginAllowThreads();
41026 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
41027 wxPyEndAllowThreads(__tstate);
41028 if (PyErr_Occurred()) SWIG_fail;
41029 }
41030 {
41031 resultobj = wxPyMake_wxObject(result, (bool)0);
41032 }
41033 return resultobj;
41034 fail:
41035 return NULL;
41036 }
41037
41038
41039 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41040 PyObject *resultobj = 0;
41041 wxWindow *arg1 = (wxWindow *) 0 ;
41042 wxSizer *arg2 = (wxSizer *) 0 ;
41043 void *argp1 = 0 ;
41044 int res1 = 0 ;
41045 void *argp2 = 0 ;
41046 int res2 = 0 ;
41047 PyObject * obj0 = 0 ;
41048 PyObject * obj1 = 0 ;
41049 char * kwnames[] = {
41050 (char *) "self",(char *) "sizer", NULL
41051 };
41052
41053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
41054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41055 if (!SWIG_IsOK(res1)) {
41056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41057 }
41058 arg1 = reinterpret_cast< wxWindow * >(argp1);
41059 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
41060 if (!SWIG_IsOK(res2)) {
41061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41062 }
41063 arg2 = reinterpret_cast< wxSizer * >(argp2);
41064 {
41065 PyThreadState* __tstate = wxPyBeginAllowThreads();
41066 (arg1)->SetContainingSizer(arg2);
41067 wxPyEndAllowThreads(__tstate);
41068 if (PyErr_Occurred()) SWIG_fail;
41069 }
41070 resultobj = SWIG_Py_Void();
41071 return resultobj;
41072 fail:
41073 return NULL;
41074 }
41075
41076
41077 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41078 PyObject *resultobj = 0;
41079 wxWindow *arg1 = (wxWindow *) 0 ;
41080 wxSizer *result = 0 ;
41081 void *argp1 = 0 ;
41082 int res1 = 0 ;
41083 PyObject *swig_obj[1] ;
41084
41085 if (!args) SWIG_fail;
41086 swig_obj[0] = args;
41087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41088 if (!SWIG_IsOK(res1)) {
41089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41090 }
41091 arg1 = reinterpret_cast< wxWindow * >(argp1);
41092 {
41093 PyThreadState* __tstate = wxPyBeginAllowThreads();
41094 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
41095 wxPyEndAllowThreads(__tstate);
41096 if (PyErr_Occurred()) SWIG_fail;
41097 }
41098 {
41099 resultobj = wxPyMake_wxObject(result, (bool)0);
41100 }
41101 return resultobj;
41102 fail:
41103 return NULL;
41104 }
41105
41106
41107 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41108 PyObject *resultobj = 0;
41109 wxWindow *arg1 = (wxWindow *) 0 ;
41110 void *argp1 = 0 ;
41111 int res1 = 0 ;
41112 PyObject *swig_obj[1] ;
41113
41114 if (!args) SWIG_fail;
41115 swig_obj[0] = args;
41116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41117 if (!SWIG_IsOK(res1)) {
41118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
41119 }
41120 arg1 = reinterpret_cast< wxWindow * >(argp1);
41121 {
41122 PyThreadState* __tstate = wxPyBeginAllowThreads();
41123 (arg1)->InheritAttributes();
41124 wxPyEndAllowThreads(__tstate);
41125 if (PyErr_Occurred()) SWIG_fail;
41126 }
41127 resultobj = SWIG_Py_Void();
41128 return resultobj;
41129 fail:
41130 return NULL;
41131 }
41132
41133
41134 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41135 PyObject *resultobj = 0;
41136 wxWindow *arg1 = (wxWindow *) 0 ;
41137 bool result;
41138 void *argp1 = 0 ;
41139 int res1 = 0 ;
41140 PyObject *swig_obj[1] ;
41141
41142 if (!args) SWIG_fail;
41143 swig_obj[0] = args;
41144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41145 if (!SWIG_IsOK(res1)) {
41146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41147 }
41148 arg1 = reinterpret_cast< wxWindow * >(argp1);
41149 {
41150 PyThreadState* __tstate = wxPyBeginAllowThreads();
41151 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41152 wxPyEndAllowThreads(__tstate);
41153 if (PyErr_Occurred()) SWIG_fail;
41154 }
41155 {
41156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41157 }
41158 return resultobj;
41159 fail:
41160 return NULL;
41161 }
41162
41163
41164 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41165 PyObject *resultobj = 0;
41166 wxWindow *arg1 = (wxWindow *) 0 ;
41167 bool result;
41168 void *argp1 = 0 ;
41169 int res1 = 0 ;
41170 PyObject *swig_obj[1] ;
41171
41172 if (!args) SWIG_fail;
41173 swig_obj[0] = args;
41174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41175 if (!SWIG_IsOK(res1)) {
41176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41177 }
41178 arg1 = reinterpret_cast< wxWindow * >(argp1);
41179 {
41180 PyThreadState* __tstate = wxPyBeginAllowThreads();
41181 result = (bool)(arg1)->CanSetTransparent();
41182 wxPyEndAllowThreads(__tstate);
41183 if (PyErr_Occurred()) SWIG_fail;
41184 }
41185 {
41186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41187 }
41188 return resultobj;
41189 fail:
41190 return NULL;
41191 }
41192
41193
41194 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41195 PyObject *resultobj = 0;
41196 wxWindow *arg1 = (wxWindow *) 0 ;
41197 byte arg2 ;
41198 bool result;
41199 void *argp1 = 0 ;
41200 int res1 = 0 ;
41201 unsigned char val2 ;
41202 int ecode2 = 0 ;
41203 PyObject * obj0 = 0 ;
41204 PyObject * obj1 = 0 ;
41205 char * kwnames[] = {
41206 (char *) "self",(char *) "alpha", NULL
41207 };
41208
41209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41211 if (!SWIG_IsOK(res1)) {
41212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41213 }
41214 arg1 = reinterpret_cast< wxWindow * >(argp1);
41215 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41216 if (!SWIG_IsOK(ecode2)) {
41217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41218 }
41219 arg2 = static_cast< byte >(val2);
41220 {
41221 PyThreadState* __tstate = wxPyBeginAllowThreads();
41222 result = (bool)(arg1)->SetTransparent(arg2);
41223 wxPyEndAllowThreads(__tstate);
41224 if (PyErr_Occurred()) SWIG_fail;
41225 }
41226 {
41227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41228 }
41229 return resultobj;
41230 fail:
41231 return NULL;
41232 }
41233
41234
41235 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41236 PyObject *obj;
41237 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41238 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41239 return SWIG_Py_Void();
41240 }
41241
41242 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41243 return SWIG_Python_InitShadowInstance(args);
41244 }
41245
41246 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41247 PyObject *resultobj = 0;
41248 long arg1 ;
41249 wxWindow *arg2 = (wxWindow *) NULL ;
41250 wxWindow *result = 0 ;
41251 long val1 ;
41252 int ecode1 = 0 ;
41253 void *argp2 = 0 ;
41254 int res2 = 0 ;
41255 PyObject * obj0 = 0 ;
41256 PyObject * obj1 = 0 ;
41257 char * kwnames[] = {
41258 (char *) "id",(char *) "parent", NULL
41259 };
41260
41261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41262 ecode1 = SWIG_AsVal_long(obj0, &val1);
41263 if (!SWIG_IsOK(ecode1)) {
41264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41265 }
41266 arg1 = static_cast< long >(val1);
41267 if (obj1) {
41268 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41269 if (!SWIG_IsOK(res2)) {
41270 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41271 }
41272 arg2 = reinterpret_cast< wxWindow * >(argp2);
41273 }
41274 {
41275 if (!wxPyCheckForApp()) SWIG_fail;
41276 PyThreadState* __tstate = wxPyBeginAllowThreads();
41277 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41278 wxPyEndAllowThreads(__tstate);
41279 if (PyErr_Occurred()) SWIG_fail;
41280 }
41281 {
41282 resultobj = wxPyMake_wxObject(result, 0);
41283 }
41284 return resultobj;
41285 fail:
41286 return NULL;
41287 }
41288
41289
41290 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41291 PyObject *resultobj = 0;
41292 wxString *arg1 = 0 ;
41293 wxWindow *arg2 = (wxWindow *) NULL ;
41294 wxWindow *result = 0 ;
41295 bool temp1 = false ;
41296 void *argp2 = 0 ;
41297 int res2 = 0 ;
41298 PyObject * obj0 = 0 ;
41299 PyObject * obj1 = 0 ;
41300 char * kwnames[] = {
41301 (char *) "name",(char *) "parent", NULL
41302 };
41303
41304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41305 {
41306 arg1 = wxString_in_helper(obj0);
41307 if (arg1 == NULL) SWIG_fail;
41308 temp1 = true;
41309 }
41310 if (obj1) {
41311 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41312 if (!SWIG_IsOK(res2)) {
41313 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41314 }
41315 arg2 = reinterpret_cast< wxWindow * >(argp2);
41316 }
41317 {
41318 if (!wxPyCheckForApp()) SWIG_fail;
41319 PyThreadState* __tstate = wxPyBeginAllowThreads();
41320 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41321 wxPyEndAllowThreads(__tstate);
41322 if (PyErr_Occurred()) SWIG_fail;
41323 }
41324 {
41325 resultobj = wxPyMake_wxObject(result, 0);
41326 }
41327 {
41328 if (temp1)
41329 delete arg1;
41330 }
41331 return resultobj;
41332 fail:
41333 {
41334 if (temp1)
41335 delete arg1;
41336 }
41337 return NULL;
41338 }
41339
41340
41341 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41342 PyObject *resultobj = 0;
41343 wxString *arg1 = 0 ;
41344 wxWindow *arg2 = (wxWindow *) NULL ;
41345 wxWindow *result = 0 ;
41346 bool temp1 = false ;
41347 void *argp2 = 0 ;
41348 int res2 = 0 ;
41349 PyObject * obj0 = 0 ;
41350 PyObject * obj1 = 0 ;
41351 char * kwnames[] = {
41352 (char *) "label",(char *) "parent", NULL
41353 };
41354
41355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41356 {
41357 arg1 = wxString_in_helper(obj0);
41358 if (arg1 == NULL) SWIG_fail;
41359 temp1 = true;
41360 }
41361 if (obj1) {
41362 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41363 if (!SWIG_IsOK(res2)) {
41364 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41365 }
41366 arg2 = reinterpret_cast< wxWindow * >(argp2);
41367 }
41368 {
41369 if (!wxPyCheckForApp()) SWIG_fail;
41370 PyThreadState* __tstate = wxPyBeginAllowThreads();
41371 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41372 wxPyEndAllowThreads(__tstate);
41373 if (PyErr_Occurred()) SWIG_fail;
41374 }
41375 {
41376 resultobj = wxPyMake_wxObject(result, 0);
41377 }
41378 {
41379 if (temp1)
41380 delete arg1;
41381 }
41382 return resultobj;
41383 fail:
41384 {
41385 if (temp1)
41386 delete arg1;
41387 }
41388 return NULL;
41389 }
41390
41391
41392 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41393 PyObject *resultobj = 0;
41394 wxWindow *arg1 = (wxWindow *) 0 ;
41395 unsigned long arg2 ;
41396 wxWindow *result = 0 ;
41397 void *argp1 = 0 ;
41398 int res1 = 0 ;
41399 unsigned long val2 ;
41400 int ecode2 = 0 ;
41401 PyObject * obj0 = 0 ;
41402 PyObject * obj1 = 0 ;
41403 char * kwnames[] = {
41404 (char *) "parent",(char *) "_hWnd", NULL
41405 };
41406
41407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41409 if (!SWIG_IsOK(res1)) {
41410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41411 }
41412 arg1 = reinterpret_cast< wxWindow * >(argp1);
41413 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41414 if (!SWIG_IsOK(ecode2)) {
41415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41416 }
41417 arg2 = static_cast< unsigned long >(val2);
41418 {
41419 if (!wxPyCheckForApp()) SWIG_fail;
41420 PyThreadState* __tstate = wxPyBeginAllowThreads();
41421 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41422 wxPyEndAllowThreads(__tstate);
41423 if (PyErr_Occurred()) SWIG_fail;
41424 }
41425 {
41426 resultobj = wxPyMake_wxObject(result, 0);
41427 }
41428 return resultobj;
41429 fail:
41430 return NULL;
41431 }
41432
41433
41434 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41435 PyObject *resultobj = 0;
41436 PyObject *result = 0 ;
41437
41438 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41439 {
41440 PyThreadState* __tstate = wxPyBeginAllowThreads();
41441 result = (PyObject *)GetTopLevelWindows();
41442 wxPyEndAllowThreads(__tstate);
41443 if (PyErr_Occurred()) SWIG_fail;
41444 }
41445 resultobj = result;
41446 return resultobj;
41447 fail:
41448 return NULL;
41449 }
41450
41451
41452 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41453 PyObject *resultobj = 0;
41454 wxValidator *result = 0 ;
41455
41456 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41457 {
41458 PyThreadState* __tstate = wxPyBeginAllowThreads();
41459 result = (wxValidator *)new wxValidator();
41460 wxPyEndAllowThreads(__tstate);
41461 if (PyErr_Occurred()) SWIG_fail;
41462 }
41463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41464 return resultobj;
41465 fail:
41466 return NULL;
41467 }
41468
41469
41470 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41471 PyObject *resultobj = 0;
41472 wxValidator *arg1 = (wxValidator *) 0 ;
41473 wxValidator *result = 0 ;
41474 void *argp1 = 0 ;
41475 int res1 = 0 ;
41476 PyObject *swig_obj[1] ;
41477
41478 if (!args) SWIG_fail;
41479 swig_obj[0] = args;
41480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41481 if (!SWIG_IsOK(res1)) {
41482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41483 }
41484 arg1 = reinterpret_cast< wxValidator * >(argp1);
41485 {
41486 PyThreadState* __tstate = wxPyBeginAllowThreads();
41487 result = (wxValidator *)(arg1)->Clone();
41488 wxPyEndAllowThreads(__tstate);
41489 if (PyErr_Occurred()) SWIG_fail;
41490 }
41491 {
41492 resultobj = wxPyMake_wxObject(result, 0);
41493 }
41494 return resultobj;
41495 fail:
41496 return NULL;
41497 }
41498
41499
41500 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41501 PyObject *resultobj = 0;
41502 wxValidator *arg1 = (wxValidator *) 0 ;
41503 wxWindow *arg2 = (wxWindow *) 0 ;
41504 bool result;
41505 void *argp1 = 0 ;
41506 int res1 = 0 ;
41507 void *argp2 = 0 ;
41508 int res2 = 0 ;
41509 PyObject * obj0 = 0 ;
41510 PyObject * obj1 = 0 ;
41511 char * kwnames[] = {
41512 (char *) "self",(char *) "parent", NULL
41513 };
41514
41515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41517 if (!SWIG_IsOK(res1)) {
41518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41519 }
41520 arg1 = reinterpret_cast< wxValidator * >(argp1);
41521 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41522 if (!SWIG_IsOK(res2)) {
41523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41524 }
41525 arg2 = reinterpret_cast< wxWindow * >(argp2);
41526 {
41527 PyThreadState* __tstate = wxPyBeginAllowThreads();
41528 result = (bool)(arg1)->Validate(arg2);
41529 wxPyEndAllowThreads(__tstate);
41530 if (PyErr_Occurred()) SWIG_fail;
41531 }
41532 {
41533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41534 }
41535 return resultobj;
41536 fail:
41537 return NULL;
41538 }
41539
41540
41541 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41542 PyObject *resultobj = 0;
41543 wxValidator *arg1 = (wxValidator *) 0 ;
41544 bool result;
41545 void *argp1 = 0 ;
41546 int res1 = 0 ;
41547 PyObject *swig_obj[1] ;
41548
41549 if (!args) SWIG_fail;
41550 swig_obj[0] = args;
41551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41552 if (!SWIG_IsOK(res1)) {
41553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41554 }
41555 arg1 = reinterpret_cast< wxValidator * >(argp1);
41556 {
41557 PyThreadState* __tstate = wxPyBeginAllowThreads();
41558 result = (bool)(arg1)->TransferToWindow();
41559 wxPyEndAllowThreads(__tstate);
41560 if (PyErr_Occurred()) SWIG_fail;
41561 }
41562 {
41563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41564 }
41565 return resultobj;
41566 fail:
41567 return NULL;
41568 }
41569
41570
41571 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41572 PyObject *resultobj = 0;
41573 wxValidator *arg1 = (wxValidator *) 0 ;
41574 bool result;
41575 void *argp1 = 0 ;
41576 int res1 = 0 ;
41577 PyObject *swig_obj[1] ;
41578
41579 if (!args) SWIG_fail;
41580 swig_obj[0] = args;
41581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41582 if (!SWIG_IsOK(res1)) {
41583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41584 }
41585 arg1 = reinterpret_cast< wxValidator * >(argp1);
41586 {
41587 PyThreadState* __tstate = wxPyBeginAllowThreads();
41588 result = (bool)(arg1)->TransferFromWindow();
41589 wxPyEndAllowThreads(__tstate);
41590 if (PyErr_Occurred()) SWIG_fail;
41591 }
41592 {
41593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41594 }
41595 return resultobj;
41596 fail:
41597 return NULL;
41598 }
41599
41600
41601 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41602 PyObject *resultobj = 0;
41603 wxValidator *arg1 = (wxValidator *) 0 ;
41604 wxWindow *result = 0 ;
41605 void *argp1 = 0 ;
41606 int res1 = 0 ;
41607 PyObject *swig_obj[1] ;
41608
41609 if (!args) SWIG_fail;
41610 swig_obj[0] = args;
41611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41612 if (!SWIG_IsOK(res1)) {
41613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41614 }
41615 arg1 = reinterpret_cast< wxValidator * >(argp1);
41616 {
41617 PyThreadState* __tstate = wxPyBeginAllowThreads();
41618 result = (wxWindow *)(arg1)->GetWindow();
41619 wxPyEndAllowThreads(__tstate);
41620 if (PyErr_Occurred()) SWIG_fail;
41621 }
41622 {
41623 resultobj = wxPyMake_wxObject(result, 0);
41624 }
41625 return resultobj;
41626 fail:
41627 return NULL;
41628 }
41629
41630
41631 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41632 PyObject *resultobj = 0;
41633 wxValidator *arg1 = (wxValidator *) 0 ;
41634 wxWindow *arg2 = (wxWindow *) 0 ;
41635 void *argp1 = 0 ;
41636 int res1 = 0 ;
41637 void *argp2 = 0 ;
41638 int res2 = 0 ;
41639 PyObject * obj0 = 0 ;
41640 PyObject * obj1 = 0 ;
41641 char * kwnames[] = {
41642 (char *) "self",(char *) "window", NULL
41643 };
41644
41645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41647 if (!SWIG_IsOK(res1)) {
41648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41649 }
41650 arg1 = reinterpret_cast< wxValidator * >(argp1);
41651 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41652 if (!SWIG_IsOK(res2)) {
41653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41654 }
41655 arg2 = reinterpret_cast< wxWindow * >(argp2);
41656 {
41657 PyThreadState* __tstate = wxPyBeginAllowThreads();
41658 (arg1)->SetWindow(arg2);
41659 wxPyEndAllowThreads(__tstate);
41660 if (PyErr_Occurred()) SWIG_fail;
41661 }
41662 resultobj = SWIG_Py_Void();
41663 return resultobj;
41664 fail:
41665 return NULL;
41666 }
41667
41668
41669 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41670 PyObject *resultobj = 0;
41671 bool result;
41672
41673 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41674 {
41675 PyThreadState* __tstate = wxPyBeginAllowThreads();
41676 result = (bool)wxValidator::IsSilent();
41677 wxPyEndAllowThreads(__tstate);
41678 if (PyErr_Occurred()) SWIG_fail;
41679 }
41680 {
41681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41682 }
41683 return resultobj;
41684 fail:
41685 return NULL;
41686 }
41687
41688
41689 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41690 PyObject *resultobj = 0;
41691 int arg1 = (int) true ;
41692 int val1 ;
41693 int ecode1 = 0 ;
41694 PyObject * obj0 = 0 ;
41695 char * kwnames[] = {
41696 (char *) "doIt", NULL
41697 };
41698
41699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41700 if (obj0) {
41701 ecode1 = SWIG_AsVal_int(obj0, &val1);
41702 if (!SWIG_IsOK(ecode1)) {
41703 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41704 }
41705 arg1 = static_cast< int >(val1);
41706 }
41707 {
41708 PyThreadState* __tstate = wxPyBeginAllowThreads();
41709 wxValidator::SetBellOnError(arg1);
41710 wxPyEndAllowThreads(__tstate);
41711 if (PyErr_Occurred()) SWIG_fail;
41712 }
41713 resultobj = SWIG_Py_Void();
41714 return resultobj;
41715 fail:
41716 return NULL;
41717 }
41718
41719
41720 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41721 PyObject *obj;
41722 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41723 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41724 return SWIG_Py_Void();
41725 }
41726
41727 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41728 return SWIG_Python_InitShadowInstance(args);
41729 }
41730
41731 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41732 PyObject *resultobj = 0;
41733 wxPyValidator *result = 0 ;
41734
41735 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41736 {
41737 PyThreadState* __tstate = wxPyBeginAllowThreads();
41738 result = (wxPyValidator *)new wxPyValidator();
41739 wxPyEndAllowThreads(__tstate);
41740 if (PyErr_Occurred()) SWIG_fail;
41741 }
41742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41743 return resultobj;
41744 fail:
41745 return NULL;
41746 }
41747
41748
41749 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41750 PyObject *resultobj = 0;
41751 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41752 PyObject *arg2 = (PyObject *) 0 ;
41753 PyObject *arg3 = (PyObject *) 0 ;
41754 int arg4 = (int) 1 ;
41755 void *argp1 = 0 ;
41756 int res1 = 0 ;
41757 int val4 ;
41758 int ecode4 = 0 ;
41759 PyObject * obj0 = 0 ;
41760 PyObject * obj1 = 0 ;
41761 PyObject * obj2 = 0 ;
41762 PyObject * obj3 = 0 ;
41763 char * kwnames[] = {
41764 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41765 };
41766
41767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41769 if (!SWIG_IsOK(res1)) {
41770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41771 }
41772 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41773 arg2 = obj1;
41774 arg3 = obj2;
41775 if (obj3) {
41776 ecode4 = SWIG_AsVal_int(obj3, &val4);
41777 if (!SWIG_IsOK(ecode4)) {
41778 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41779 }
41780 arg4 = static_cast< int >(val4);
41781 }
41782 {
41783 PyThreadState* __tstate = wxPyBeginAllowThreads();
41784 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41785 wxPyEndAllowThreads(__tstate);
41786 if (PyErr_Occurred()) SWIG_fail;
41787 }
41788 resultobj = SWIG_Py_Void();
41789 return resultobj;
41790 fail:
41791 return NULL;
41792 }
41793
41794
41795 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41796 PyObject *obj;
41797 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41798 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41799 return SWIG_Py_Void();
41800 }
41801
41802 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41803 return SWIG_Python_InitShadowInstance(args);
41804 }
41805
41806 SWIGINTERN int DefaultValidator_set(PyObject *) {
41807 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41808 return 1;
41809 }
41810
41811
41812 SWIGINTERN PyObject *DefaultValidator_get(void) {
41813 PyObject *pyobj = 0;
41814
41815 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41816 return pyobj;
41817 }
41818
41819
41820 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41821 PyObject *resultobj = 0;
41822 wxString const &arg1_defvalue = wxPyEmptyString ;
41823 wxString *arg1 = (wxString *) &arg1_defvalue ;
41824 long arg2 = (long) 0 ;
41825 wxMenu *result = 0 ;
41826 bool temp1 = false ;
41827 long val2 ;
41828 int ecode2 = 0 ;
41829 PyObject * obj0 = 0 ;
41830 PyObject * obj1 = 0 ;
41831 char * kwnames[] = {
41832 (char *) "title",(char *) "style", NULL
41833 };
41834
41835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41836 if (obj0) {
41837 {
41838 arg1 = wxString_in_helper(obj0);
41839 if (arg1 == NULL) SWIG_fail;
41840 temp1 = true;
41841 }
41842 }
41843 if (obj1) {
41844 ecode2 = SWIG_AsVal_long(obj1, &val2);
41845 if (!SWIG_IsOK(ecode2)) {
41846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
41847 }
41848 arg2 = static_cast< long >(val2);
41849 }
41850 {
41851 if (!wxPyCheckForApp()) SWIG_fail;
41852 PyThreadState* __tstate = wxPyBeginAllowThreads();
41853 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
41854 wxPyEndAllowThreads(__tstate);
41855 if (PyErr_Occurred()) SWIG_fail;
41856 }
41857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
41858 {
41859 if (temp1)
41860 delete arg1;
41861 }
41862 return resultobj;
41863 fail:
41864 {
41865 if (temp1)
41866 delete arg1;
41867 }
41868 return NULL;
41869 }
41870
41871
41872 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41873 PyObject *resultobj = 0;
41874 wxMenu *arg1 = (wxMenu *) 0 ;
41875 int arg2 ;
41876 wxString const &arg3_defvalue = wxPyEmptyString ;
41877 wxString *arg3 = (wxString *) &arg3_defvalue ;
41878 wxString const &arg4_defvalue = wxPyEmptyString ;
41879 wxString *arg4 = (wxString *) &arg4_defvalue ;
41880 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41881 wxMenuItem *result = 0 ;
41882 void *argp1 = 0 ;
41883 int res1 = 0 ;
41884 int val2 ;
41885 int ecode2 = 0 ;
41886 bool temp3 = false ;
41887 bool temp4 = false ;
41888 int val5 ;
41889 int ecode5 = 0 ;
41890 PyObject * obj0 = 0 ;
41891 PyObject * obj1 = 0 ;
41892 PyObject * obj2 = 0 ;
41893 PyObject * obj3 = 0 ;
41894 PyObject * obj4 = 0 ;
41895 char * kwnames[] = {
41896 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
41897 };
41898
41899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41901 if (!SWIG_IsOK(res1)) {
41902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
41903 }
41904 arg1 = reinterpret_cast< wxMenu * >(argp1);
41905 ecode2 = SWIG_AsVal_int(obj1, &val2);
41906 if (!SWIG_IsOK(ecode2)) {
41907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
41908 }
41909 arg2 = static_cast< int >(val2);
41910 if (obj2) {
41911 {
41912 arg3 = wxString_in_helper(obj2);
41913 if (arg3 == NULL) SWIG_fail;
41914 temp3 = true;
41915 }
41916 }
41917 if (obj3) {
41918 {
41919 arg4 = wxString_in_helper(obj3);
41920 if (arg4 == NULL) SWIG_fail;
41921 temp4 = true;
41922 }
41923 }
41924 if (obj4) {
41925 ecode5 = SWIG_AsVal_int(obj4, &val5);
41926 if (!SWIG_IsOK(ecode5)) {
41927 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
41928 }
41929 arg5 = static_cast< wxItemKind >(val5);
41930 }
41931 {
41932 PyThreadState* __tstate = wxPyBeginAllowThreads();
41933 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
41934 wxPyEndAllowThreads(__tstate);
41935 if (PyErr_Occurred()) SWIG_fail;
41936 }
41937 {
41938 resultobj = wxPyMake_wxObject(result, (bool)0);
41939 }
41940 {
41941 if (temp3)
41942 delete arg3;
41943 }
41944 {
41945 if (temp4)
41946 delete arg4;
41947 }
41948 return resultobj;
41949 fail:
41950 {
41951 if (temp3)
41952 delete arg3;
41953 }
41954 {
41955 if (temp4)
41956 delete arg4;
41957 }
41958 return NULL;
41959 }
41960
41961
41962 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41963 PyObject *resultobj = 0;
41964 wxMenu *arg1 = (wxMenu *) 0 ;
41965 wxMenuItem *result = 0 ;
41966 void *argp1 = 0 ;
41967 int res1 = 0 ;
41968 PyObject *swig_obj[1] ;
41969
41970 if (!args) SWIG_fail;
41971 swig_obj[0] = args;
41972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41973 if (!SWIG_IsOK(res1)) {
41974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
41975 }
41976 arg1 = reinterpret_cast< wxMenu * >(argp1);
41977 {
41978 PyThreadState* __tstate = wxPyBeginAllowThreads();
41979 result = (wxMenuItem *)(arg1)->AppendSeparator();
41980 wxPyEndAllowThreads(__tstate);
41981 if (PyErr_Occurred()) SWIG_fail;
41982 }
41983 {
41984 resultobj = wxPyMake_wxObject(result, (bool)0);
41985 }
41986 return resultobj;
41987 fail:
41988 return NULL;
41989 }
41990
41991
41992 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41993 PyObject *resultobj = 0;
41994 wxMenu *arg1 = (wxMenu *) 0 ;
41995 int arg2 ;
41996 wxString *arg3 = 0 ;
41997 wxString const &arg4_defvalue = wxPyEmptyString ;
41998 wxString *arg4 = (wxString *) &arg4_defvalue ;
41999 wxMenuItem *result = 0 ;
42000 void *argp1 = 0 ;
42001 int res1 = 0 ;
42002 int val2 ;
42003 int ecode2 = 0 ;
42004 bool temp3 = false ;
42005 bool temp4 = false ;
42006 PyObject * obj0 = 0 ;
42007 PyObject * obj1 = 0 ;
42008 PyObject * obj2 = 0 ;
42009 PyObject * obj3 = 0 ;
42010 char * kwnames[] = {
42011 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42012 };
42013
42014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42016 if (!SWIG_IsOK(res1)) {
42017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42018 }
42019 arg1 = reinterpret_cast< wxMenu * >(argp1);
42020 ecode2 = SWIG_AsVal_int(obj1, &val2);
42021 if (!SWIG_IsOK(ecode2)) {
42022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
42023 }
42024 arg2 = static_cast< int >(val2);
42025 {
42026 arg3 = wxString_in_helper(obj2);
42027 if (arg3 == NULL) SWIG_fail;
42028 temp3 = true;
42029 }
42030 if (obj3) {
42031 {
42032 arg4 = wxString_in_helper(obj3);
42033 if (arg4 == NULL) SWIG_fail;
42034 temp4 = true;
42035 }
42036 }
42037 {
42038 PyThreadState* __tstate = wxPyBeginAllowThreads();
42039 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42040 wxPyEndAllowThreads(__tstate);
42041 if (PyErr_Occurred()) SWIG_fail;
42042 }
42043 {
42044 resultobj = wxPyMake_wxObject(result, (bool)0);
42045 }
42046 {
42047 if (temp3)
42048 delete arg3;
42049 }
42050 {
42051 if (temp4)
42052 delete arg4;
42053 }
42054 return resultobj;
42055 fail:
42056 {
42057 if (temp3)
42058 delete arg3;
42059 }
42060 {
42061 if (temp4)
42062 delete arg4;
42063 }
42064 return NULL;
42065 }
42066
42067
42068 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42069 PyObject *resultobj = 0;
42070 wxMenu *arg1 = (wxMenu *) 0 ;
42071 int arg2 ;
42072 wxString *arg3 = 0 ;
42073 wxString const &arg4_defvalue = wxPyEmptyString ;
42074 wxString *arg4 = (wxString *) &arg4_defvalue ;
42075 wxMenuItem *result = 0 ;
42076 void *argp1 = 0 ;
42077 int res1 = 0 ;
42078 int val2 ;
42079 int ecode2 = 0 ;
42080 bool temp3 = false ;
42081 bool temp4 = false ;
42082 PyObject * obj0 = 0 ;
42083 PyObject * obj1 = 0 ;
42084 PyObject * obj2 = 0 ;
42085 PyObject * obj3 = 0 ;
42086 char * kwnames[] = {
42087 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42088 };
42089
42090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42092 if (!SWIG_IsOK(res1)) {
42093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42094 }
42095 arg1 = reinterpret_cast< wxMenu * >(argp1);
42096 ecode2 = SWIG_AsVal_int(obj1, &val2);
42097 if (!SWIG_IsOK(ecode2)) {
42098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
42099 }
42100 arg2 = static_cast< int >(val2);
42101 {
42102 arg3 = wxString_in_helper(obj2);
42103 if (arg3 == NULL) SWIG_fail;
42104 temp3 = true;
42105 }
42106 if (obj3) {
42107 {
42108 arg4 = wxString_in_helper(obj3);
42109 if (arg4 == NULL) SWIG_fail;
42110 temp4 = true;
42111 }
42112 }
42113 {
42114 PyThreadState* __tstate = wxPyBeginAllowThreads();
42115 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42116 wxPyEndAllowThreads(__tstate);
42117 if (PyErr_Occurred()) SWIG_fail;
42118 }
42119 {
42120 resultobj = wxPyMake_wxObject(result, (bool)0);
42121 }
42122 {
42123 if (temp3)
42124 delete arg3;
42125 }
42126 {
42127 if (temp4)
42128 delete arg4;
42129 }
42130 return resultobj;
42131 fail:
42132 {
42133 if (temp3)
42134 delete arg3;
42135 }
42136 {
42137 if (temp4)
42138 delete arg4;
42139 }
42140 return NULL;
42141 }
42142
42143
42144 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42145 PyObject *resultobj = 0;
42146 wxMenu *arg1 = (wxMenu *) 0 ;
42147 int arg2 ;
42148 wxString *arg3 = 0 ;
42149 wxMenu *arg4 = (wxMenu *) 0 ;
42150 wxString const &arg5_defvalue = wxPyEmptyString ;
42151 wxString *arg5 = (wxString *) &arg5_defvalue ;
42152 wxMenuItem *result = 0 ;
42153 void *argp1 = 0 ;
42154 int res1 = 0 ;
42155 int val2 ;
42156 int ecode2 = 0 ;
42157 bool temp3 = false ;
42158 void *argp4 = 0 ;
42159 int res4 = 0 ;
42160 bool temp5 = false ;
42161 PyObject * obj0 = 0 ;
42162 PyObject * obj1 = 0 ;
42163 PyObject * obj2 = 0 ;
42164 PyObject * obj3 = 0 ;
42165 PyObject * obj4 = 0 ;
42166 char * kwnames[] = {
42167 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42168 };
42169
42170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42172 if (!SWIG_IsOK(res1)) {
42173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42174 }
42175 arg1 = reinterpret_cast< wxMenu * >(argp1);
42176 ecode2 = SWIG_AsVal_int(obj1, &val2);
42177 if (!SWIG_IsOK(ecode2)) {
42178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42179 }
42180 arg2 = static_cast< int >(val2);
42181 {
42182 arg3 = wxString_in_helper(obj2);
42183 if (arg3 == NULL) SWIG_fail;
42184 temp3 = true;
42185 }
42186 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42187 if (!SWIG_IsOK(res4)) {
42188 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42189 }
42190 arg4 = reinterpret_cast< wxMenu * >(argp4);
42191 if (obj4) {
42192 {
42193 arg5 = wxString_in_helper(obj4);
42194 if (arg5 == NULL) SWIG_fail;
42195 temp5 = true;
42196 }
42197 }
42198 {
42199 PyThreadState* __tstate = wxPyBeginAllowThreads();
42200 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42201 wxPyEndAllowThreads(__tstate);
42202 if (PyErr_Occurred()) SWIG_fail;
42203 }
42204 {
42205 resultobj = wxPyMake_wxObject(result, (bool)0);
42206 }
42207 {
42208 if (temp3)
42209 delete arg3;
42210 }
42211 {
42212 if (temp5)
42213 delete arg5;
42214 }
42215 return resultobj;
42216 fail:
42217 {
42218 if (temp3)
42219 delete arg3;
42220 }
42221 {
42222 if (temp5)
42223 delete arg5;
42224 }
42225 return NULL;
42226 }
42227
42228
42229 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42230 PyObject *resultobj = 0;
42231 wxMenu *arg1 = (wxMenu *) 0 ;
42232 wxMenu *arg2 = (wxMenu *) 0 ;
42233 wxString *arg3 = 0 ;
42234 wxString const &arg4_defvalue = wxPyEmptyString ;
42235 wxString *arg4 = (wxString *) &arg4_defvalue ;
42236 wxMenuItem *result = 0 ;
42237 void *argp1 = 0 ;
42238 int res1 = 0 ;
42239 void *argp2 = 0 ;
42240 int res2 = 0 ;
42241 bool temp3 = false ;
42242 bool temp4 = false ;
42243 PyObject * obj0 = 0 ;
42244 PyObject * obj1 = 0 ;
42245 PyObject * obj2 = 0 ;
42246 PyObject * obj3 = 0 ;
42247 char * kwnames[] = {
42248 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42249 };
42250
42251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42253 if (!SWIG_IsOK(res1)) {
42254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42255 }
42256 arg1 = reinterpret_cast< wxMenu * >(argp1);
42257 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42258 if (!SWIG_IsOK(res2)) {
42259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42260 }
42261 arg2 = reinterpret_cast< wxMenu * >(argp2);
42262 {
42263 arg3 = wxString_in_helper(obj2);
42264 if (arg3 == NULL) SWIG_fail;
42265 temp3 = true;
42266 }
42267 if (obj3) {
42268 {
42269 arg4 = wxString_in_helper(obj3);
42270 if (arg4 == NULL) SWIG_fail;
42271 temp4 = true;
42272 }
42273 }
42274 {
42275 PyThreadState* __tstate = wxPyBeginAllowThreads();
42276 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42277 wxPyEndAllowThreads(__tstate);
42278 if (PyErr_Occurred()) SWIG_fail;
42279 }
42280 {
42281 resultobj = wxPyMake_wxObject(result, (bool)0);
42282 }
42283 {
42284 if (temp3)
42285 delete arg3;
42286 }
42287 {
42288 if (temp4)
42289 delete arg4;
42290 }
42291 return resultobj;
42292 fail:
42293 {
42294 if (temp3)
42295 delete arg3;
42296 }
42297 {
42298 if (temp4)
42299 delete arg4;
42300 }
42301 return NULL;
42302 }
42303
42304
42305 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42306 PyObject *resultobj = 0;
42307 wxMenu *arg1 = (wxMenu *) 0 ;
42308 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42309 wxMenuItem *result = 0 ;
42310 void *argp1 = 0 ;
42311 int res1 = 0 ;
42312 int res2 = 0 ;
42313 PyObject * obj0 = 0 ;
42314 PyObject * obj1 = 0 ;
42315 char * kwnames[] = {
42316 (char *) "self",(char *) "item", NULL
42317 };
42318
42319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42321 if (!SWIG_IsOK(res1)) {
42322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42323 }
42324 arg1 = reinterpret_cast< wxMenu * >(argp1);
42325 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42326 if (!SWIG_IsOK(res2)) {
42327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42328 }
42329 {
42330 PyThreadState* __tstate = wxPyBeginAllowThreads();
42331 result = (wxMenuItem *)(arg1)->Append(arg2);
42332 wxPyEndAllowThreads(__tstate);
42333 if (PyErr_Occurred()) SWIG_fail;
42334 }
42335 {
42336 resultobj = wxPyMake_wxObject(result, (bool)0);
42337 }
42338 return resultobj;
42339 fail:
42340 return NULL;
42341 }
42342
42343
42344 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42345 PyObject *resultobj = 0;
42346 wxMenu *arg1 = (wxMenu *) 0 ;
42347 size_t arg2 ;
42348 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42349 wxMenuItem *result = 0 ;
42350 void *argp1 = 0 ;
42351 int res1 = 0 ;
42352 size_t val2 ;
42353 int ecode2 = 0 ;
42354 int res3 = 0 ;
42355 PyObject * obj0 = 0 ;
42356 PyObject * obj1 = 0 ;
42357 PyObject * obj2 = 0 ;
42358 char * kwnames[] = {
42359 (char *) "self",(char *) "pos",(char *) "item", NULL
42360 };
42361
42362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42364 if (!SWIG_IsOK(res1)) {
42365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42366 }
42367 arg1 = reinterpret_cast< wxMenu * >(argp1);
42368 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42369 if (!SWIG_IsOK(ecode2)) {
42370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42371 }
42372 arg2 = static_cast< size_t >(val2);
42373 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42374 if (!SWIG_IsOK(res3)) {
42375 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42376 }
42377 {
42378 PyThreadState* __tstate = wxPyBeginAllowThreads();
42379 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42380 wxPyEndAllowThreads(__tstate);
42381 if (PyErr_Occurred()) SWIG_fail;
42382 }
42383 {
42384 resultobj = wxPyMake_wxObject(result, (bool)0);
42385 }
42386 return resultobj;
42387 fail:
42388 return NULL;
42389 }
42390
42391
42392 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42393 PyObject *resultobj = 0;
42394 wxMenu *arg1 = (wxMenu *) 0 ;
42395 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42396 wxMenuItem *result = 0 ;
42397 void *argp1 = 0 ;
42398 int res1 = 0 ;
42399 int res2 = 0 ;
42400 PyObject * obj0 = 0 ;
42401 PyObject * obj1 = 0 ;
42402 char * kwnames[] = {
42403 (char *) "self",(char *) "item", NULL
42404 };
42405
42406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42408 if (!SWIG_IsOK(res1)) {
42409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42410 }
42411 arg1 = reinterpret_cast< wxMenu * >(argp1);
42412 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42413 if (!SWIG_IsOK(res2)) {
42414 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42415 }
42416 {
42417 PyThreadState* __tstate = wxPyBeginAllowThreads();
42418 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42419 wxPyEndAllowThreads(__tstate);
42420 if (PyErr_Occurred()) SWIG_fail;
42421 }
42422 {
42423 resultobj = wxPyMake_wxObject(result, (bool)0);
42424 }
42425 return resultobj;
42426 fail:
42427 return NULL;
42428 }
42429
42430
42431 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42432 PyObject *resultobj = 0;
42433 wxMenu *arg1 = (wxMenu *) 0 ;
42434 void *argp1 = 0 ;
42435 int res1 = 0 ;
42436 PyObject *swig_obj[1] ;
42437
42438 if (!args) SWIG_fail;
42439 swig_obj[0] = args;
42440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42441 if (!SWIG_IsOK(res1)) {
42442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42443 }
42444 arg1 = reinterpret_cast< wxMenu * >(argp1);
42445 {
42446 PyThreadState* __tstate = wxPyBeginAllowThreads();
42447 (arg1)->Break();
42448 wxPyEndAllowThreads(__tstate);
42449 if (PyErr_Occurred()) SWIG_fail;
42450 }
42451 resultobj = SWIG_Py_Void();
42452 return resultobj;
42453 fail:
42454 return NULL;
42455 }
42456
42457
42458 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42459 PyObject *resultobj = 0;
42460 wxMenu *arg1 = (wxMenu *) 0 ;
42461 size_t arg2 ;
42462 int arg3 ;
42463 wxString const &arg4_defvalue = wxPyEmptyString ;
42464 wxString *arg4 = (wxString *) &arg4_defvalue ;
42465 wxString const &arg5_defvalue = wxPyEmptyString ;
42466 wxString *arg5 = (wxString *) &arg5_defvalue ;
42467 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42468 wxMenuItem *result = 0 ;
42469 void *argp1 = 0 ;
42470 int res1 = 0 ;
42471 size_t val2 ;
42472 int ecode2 = 0 ;
42473 int val3 ;
42474 int ecode3 = 0 ;
42475 bool temp4 = false ;
42476 bool temp5 = false ;
42477 int val6 ;
42478 int ecode6 = 0 ;
42479 PyObject * obj0 = 0 ;
42480 PyObject * obj1 = 0 ;
42481 PyObject * obj2 = 0 ;
42482 PyObject * obj3 = 0 ;
42483 PyObject * obj4 = 0 ;
42484 PyObject * obj5 = 0 ;
42485 char * kwnames[] = {
42486 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42487 };
42488
42489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42491 if (!SWIG_IsOK(res1)) {
42492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42493 }
42494 arg1 = reinterpret_cast< wxMenu * >(argp1);
42495 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42496 if (!SWIG_IsOK(ecode2)) {
42497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42498 }
42499 arg2 = static_cast< size_t >(val2);
42500 ecode3 = SWIG_AsVal_int(obj2, &val3);
42501 if (!SWIG_IsOK(ecode3)) {
42502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42503 }
42504 arg3 = static_cast< int >(val3);
42505 if (obj3) {
42506 {
42507 arg4 = wxString_in_helper(obj3);
42508 if (arg4 == NULL) SWIG_fail;
42509 temp4 = true;
42510 }
42511 }
42512 if (obj4) {
42513 {
42514 arg5 = wxString_in_helper(obj4);
42515 if (arg5 == NULL) SWIG_fail;
42516 temp5 = true;
42517 }
42518 }
42519 if (obj5) {
42520 ecode6 = SWIG_AsVal_int(obj5, &val6);
42521 if (!SWIG_IsOK(ecode6)) {
42522 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42523 }
42524 arg6 = static_cast< wxItemKind >(val6);
42525 }
42526 {
42527 PyThreadState* __tstate = wxPyBeginAllowThreads();
42528 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42529 wxPyEndAllowThreads(__tstate);
42530 if (PyErr_Occurred()) SWIG_fail;
42531 }
42532 {
42533 resultobj = wxPyMake_wxObject(result, (bool)0);
42534 }
42535 {
42536 if (temp4)
42537 delete arg4;
42538 }
42539 {
42540 if (temp5)
42541 delete arg5;
42542 }
42543 return resultobj;
42544 fail:
42545 {
42546 if (temp4)
42547 delete arg4;
42548 }
42549 {
42550 if (temp5)
42551 delete arg5;
42552 }
42553 return NULL;
42554 }
42555
42556
42557 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42558 PyObject *resultobj = 0;
42559 wxMenu *arg1 = (wxMenu *) 0 ;
42560 size_t arg2 ;
42561 wxMenuItem *result = 0 ;
42562 void *argp1 = 0 ;
42563 int res1 = 0 ;
42564 size_t val2 ;
42565 int ecode2 = 0 ;
42566 PyObject * obj0 = 0 ;
42567 PyObject * obj1 = 0 ;
42568 char * kwnames[] = {
42569 (char *) "self",(char *) "pos", NULL
42570 };
42571
42572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42574 if (!SWIG_IsOK(res1)) {
42575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42576 }
42577 arg1 = reinterpret_cast< wxMenu * >(argp1);
42578 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42579 if (!SWIG_IsOK(ecode2)) {
42580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42581 }
42582 arg2 = static_cast< size_t >(val2);
42583 {
42584 PyThreadState* __tstate = wxPyBeginAllowThreads();
42585 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42586 wxPyEndAllowThreads(__tstate);
42587 if (PyErr_Occurred()) SWIG_fail;
42588 }
42589 {
42590 resultobj = wxPyMake_wxObject(result, (bool)0);
42591 }
42592 return resultobj;
42593 fail:
42594 return NULL;
42595 }
42596
42597
42598 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42599 PyObject *resultobj = 0;
42600 wxMenu *arg1 = (wxMenu *) 0 ;
42601 size_t arg2 ;
42602 int arg3 ;
42603 wxString *arg4 = 0 ;
42604 wxString const &arg5_defvalue = wxPyEmptyString ;
42605 wxString *arg5 = (wxString *) &arg5_defvalue ;
42606 wxMenuItem *result = 0 ;
42607 void *argp1 = 0 ;
42608 int res1 = 0 ;
42609 size_t val2 ;
42610 int ecode2 = 0 ;
42611 int val3 ;
42612 int ecode3 = 0 ;
42613 bool temp4 = false ;
42614 bool temp5 = false ;
42615 PyObject * obj0 = 0 ;
42616 PyObject * obj1 = 0 ;
42617 PyObject * obj2 = 0 ;
42618 PyObject * obj3 = 0 ;
42619 PyObject * obj4 = 0 ;
42620 char * kwnames[] = {
42621 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42622 };
42623
42624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42626 if (!SWIG_IsOK(res1)) {
42627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42628 }
42629 arg1 = reinterpret_cast< wxMenu * >(argp1);
42630 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42631 if (!SWIG_IsOK(ecode2)) {
42632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42633 }
42634 arg2 = static_cast< size_t >(val2);
42635 ecode3 = SWIG_AsVal_int(obj2, &val3);
42636 if (!SWIG_IsOK(ecode3)) {
42637 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42638 }
42639 arg3 = static_cast< int >(val3);
42640 {
42641 arg4 = wxString_in_helper(obj3);
42642 if (arg4 == NULL) SWIG_fail;
42643 temp4 = true;
42644 }
42645 if (obj4) {
42646 {
42647 arg5 = wxString_in_helper(obj4);
42648 if (arg5 == NULL) SWIG_fail;
42649 temp5 = true;
42650 }
42651 }
42652 {
42653 PyThreadState* __tstate = wxPyBeginAllowThreads();
42654 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42655 wxPyEndAllowThreads(__tstate);
42656 if (PyErr_Occurred()) SWIG_fail;
42657 }
42658 {
42659 resultobj = wxPyMake_wxObject(result, (bool)0);
42660 }
42661 {
42662 if (temp4)
42663 delete arg4;
42664 }
42665 {
42666 if (temp5)
42667 delete arg5;
42668 }
42669 return resultobj;
42670 fail:
42671 {
42672 if (temp4)
42673 delete arg4;
42674 }
42675 {
42676 if (temp5)
42677 delete arg5;
42678 }
42679 return NULL;
42680 }
42681
42682
42683 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42684 PyObject *resultobj = 0;
42685 wxMenu *arg1 = (wxMenu *) 0 ;
42686 size_t arg2 ;
42687 int arg3 ;
42688 wxString *arg4 = 0 ;
42689 wxString const &arg5_defvalue = wxPyEmptyString ;
42690 wxString *arg5 = (wxString *) &arg5_defvalue ;
42691 wxMenuItem *result = 0 ;
42692 void *argp1 = 0 ;
42693 int res1 = 0 ;
42694 size_t val2 ;
42695 int ecode2 = 0 ;
42696 int val3 ;
42697 int ecode3 = 0 ;
42698 bool temp4 = false ;
42699 bool temp5 = false ;
42700 PyObject * obj0 = 0 ;
42701 PyObject * obj1 = 0 ;
42702 PyObject * obj2 = 0 ;
42703 PyObject * obj3 = 0 ;
42704 PyObject * obj4 = 0 ;
42705 char * kwnames[] = {
42706 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42707 };
42708
42709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42711 if (!SWIG_IsOK(res1)) {
42712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42713 }
42714 arg1 = reinterpret_cast< wxMenu * >(argp1);
42715 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42716 if (!SWIG_IsOK(ecode2)) {
42717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42718 }
42719 arg2 = static_cast< size_t >(val2);
42720 ecode3 = SWIG_AsVal_int(obj2, &val3);
42721 if (!SWIG_IsOK(ecode3)) {
42722 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42723 }
42724 arg3 = static_cast< int >(val3);
42725 {
42726 arg4 = wxString_in_helper(obj3);
42727 if (arg4 == NULL) SWIG_fail;
42728 temp4 = true;
42729 }
42730 if (obj4) {
42731 {
42732 arg5 = wxString_in_helper(obj4);
42733 if (arg5 == NULL) SWIG_fail;
42734 temp5 = true;
42735 }
42736 }
42737 {
42738 PyThreadState* __tstate = wxPyBeginAllowThreads();
42739 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42740 wxPyEndAllowThreads(__tstate);
42741 if (PyErr_Occurred()) SWIG_fail;
42742 }
42743 {
42744 resultobj = wxPyMake_wxObject(result, (bool)0);
42745 }
42746 {
42747 if (temp4)
42748 delete arg4;
42749 }
42750 {
42751 if (temp5)
42752 delete arg5;
42753 }
42754 return resultobj;
42755 fail:
42756 {
42757 if (temp4)
42758 delete arg4;
42759 }
42760 {
42761 if (temp5)
42762 delete arg5;
42763 }
42764 return NULL;
42765 }
42766
42767
42768 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42769 PyObject *resultobj = 0;
42770 wxMenu *arg1 = (wxMenu *) 0 ;
42771 size_t arg2 ;
42772 int arg3 ;
42773 wxString *arg4 = 0 ;
42774 wxMenu *arg5 = (wxMenu *) 0 ;
42775 wxString const &arg6_defvalue = wxPyEmptyString ;
42776 wxString *arg6 = (wxString *) &arg6_defvalue ;
42777 wxMenuItem *result = 0 ;
42778 void *argp1 = 0 ;
42779 int res1 = 0 ;
42780 size_t val2 ;
42781 int ecode2 = 0 ;
42782 int val3 ;
42783 int ecode3 = 0 ;
42784 bool temp4 = false ;
42785 void *argp5 = 0 ;
42786 int res5 = 0 ;
42787 bool temp6 = false ;
42788 PyObject * obj0 = 0 ;
42789 PyObject * obj1 = 0 ;
42790 PyObject * obj2 = 0 ;
42791 PyObject * obj3 = 0 ;
42792 PyObject * obj4 = 0 ;
42793 PyObject * obj5 = 0 ;
42794 char * kwnames[] = {
42795 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42796 };
42797
42798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42800 if (!SWIG_IsOK(res1)) {
42801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42802 }
42803 arg1 = reinterpret_cast< wxMenu * >(argp1);
42804 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42805 if (!SWIG_IsOK(ecode2)) {
42806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42807 }
42808 arg2 = static_cast< size_t >(val2);
42809 ecode3 = SWIG_AsVal_int(obj2, &val3);
42810 if (!SWIG_IsOK(ecode3)) {
42811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42812 }
42813 arg3 = static_cast< int >(val3);
42814 {
42815 arg4 = wxString_in_helper(obj3);
42816 if (arg4 == NULL) SWIG_fail;
42817 temp4 = true;
42818 }
42819 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42820 if (!SWIG_IsOK(res5)) {
42821 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42822 }
42823 arg5 = reinterpret_cast< wxMenu * >(argp5);
42824 if (obj5) {
42825 {
42826 arg6 = wxString_in_helper(obj5);
42827 if (arg6 == NULL) SWIG_fail;
42828 temp6 = true;
42829 }
42830 }
42831 {
42832 PyThreadState* __tstate = wxPyBeginAllowThreads();
42833 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42834 wxPyEndAllowThreads(__tstate);
42835 if (PyErr_Occurred()) SWIG_fail;
42836 }
42837 {
42838 resultobj = wxPyMake_wxObject(result, (bool)0);
42839 }
42840 {
42841 if (temp4)
42842 delete arg4;
42843 }
42844 {
42845 if (temp6)
42846 delete arg6;
42847 }
42848 return resultobj;
42849 fail:
42850 {
42851 if (temp4)
42852 delete arg4;
42853 }
42854 {
42855 if (temp6)
42856 delete arg6;
42857 }
42858 return NULL;
42859 }
42860
42861
42862 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42863 PyObject *resultobj = 0;
42864 wxMenu *arg1 = (wxMenu *) 0 ;
42865 int arg2 ;
42866 wxString const &arg3_defvalue = wxPyEmptyString ;
42867 wxString *arg3 = (wxString *) &arg3_defvalue ;
42868 wxString const &arg4_defvalue = wxPyEmptyString ;
42869 wxString *arg4 = (wxString *) &arg4_defvalue ;
42870 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42871 wxMenuItem *result = 0 ;
42872 void *argp1 = 0 ;
42873 int res1 = 0 ;
42874 int val2 ;
42875 int ecode2 = 0 ;
42876 bool temp3 = false ;
42877 bool temp4 = false ;
42878 int val5 ;
42879 int ecode5 = 0 ;
42880 PyObject * obj0 = 0 ;
42881 PyObject * obj1 = 0 ;
42882 PyObject * obj2 = 0 ;
42883 PyObject * obj3 = 0 ;
42884 PyObject * obj4 = 0 ;
42885 char * kwnames[] = {
42886 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42887 };
42888
42889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42891 if (!SWIG_IsOK(res1)) {
42892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
42893 }
42894 arg1 = reinterpret_cast< wxMenu * >(argp1);
42895 ecode2 = SWIG_AsVal_int(obj1, &val2);
42896 if (!SWIG_IsOK(ecode2)) {
42897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
42898 }
42899 arg2 = static_cast< int >(val2);
42900 if (obj2) {
42901 {
42902 arg3 = wxString_in_helper(obj2);
42903 if (arg3 == NULL) SWIG_fail;
42904 temp3 = true;
42905 }
42906 }
42907 if (obj3) {
42908 {
42909 arg4 = wxString_in_helper(obj3);
42910 if (arg4 == NULL) SWIG_fail;
42911 temp4 = true;
42912 }
42913 }
42914 if (obj4) {
42915 ecode5 = SWIG_AsVal_int(obj4, &val5);
42916 if (!SWIG_IsOK(ecode5)) {
42917 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
42918 }
42919 arg5 = static_cast< wxItemKind >(val5);
42920 }
42921 {
42922 PyThreadState* __tstate = wxPyBeginAllowThreads();
42923 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42924 wxPyEndAllowThreads(__tstate);
42925 if (PyErr_Occurred()) SWIG_fail;
42926 }
42927 {
42928 resultobj = wxPyMake_wxObject(result, (bool)0);
42929 }
42930 {
42931 if (temp3)
42932 delete arg3;
42933 }
42934 {
42935 if (temp4)
42936 delete arg4;
42937 }
42938 return resultobj;
42939 fail:
42940 {
42941 if (temp3)
42942 delete arg3;
42943 }
42944 {
42945 if (temp4)
42946 delete arg4;
42947 }
42948 return NULL;
42949 }
42950
42951
42952 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42953 PyObject *resultobj = 0;
42954 wxMenu *arg1 = (wxMenu *) 0 ;
42955 wxMenuItem *result = 0 ;
42956 void *argp1 = 0 ;
42957 int res1 = 0 ;
42958 PyObject *swig_obj[1] ;
42959
42960 if (!args) SWIG_fail;
42961 swig_obj[0] = args;
42962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42963 if (!SWIG_IsOK(res1)) {
42964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42965 }
42966 arg1 = reinterpret_cast< wxMenu * >(argp1);
42967 {
42968 PyThreadState* __tstate = wxPyBeginAllowThreads();
42969 result = (wxMenuItem *)(arg1)->PrependSeparator();
42970 wxPyEndAllowThreads(__tstate);
42971 if (PyErr_Occurred()) SWIG_fail;
42972 }
42973 {
42974 resultobj = wxPyMake_wxObject(result, (bool)0);
42975 }
42976 return resultobj;
42977 fail:
42978 return NULL;
42979 }
42980
42981
42982 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42983 PyObject *resultobj = 0;
42984 wxMenu *arg1 = (wxMenu *) 0 ;
42985 int arg2 ;
42986 wxString *arg3 = 0 ;
42987 wxString const &arg4_defvalue = wxPyEmptyString ;
42988 wxString *arg4 = (wxString *) &arg4_defvalue ;
42989 wxMenuItem *result = 0 ;
42990 void *argp1 = 0 ;
42991 int res1 = 0 ;
42992 int val2 ;
42993 int ecode2 = 0 ;
42994 bool temp3 = false ;
42995 bool temp4 = false ;
42996 PyObject * obj0 = 0 ;
42997 PyObject * obj1 = 0 ;
42998 PyObject * obj2 = 0 ;
42999 PyObject * obj3 = 0 ;
43000 char * kwnames[] = {
43001 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43002 };
43003
43004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43006 if (!SWIG_IsOK(res1)) {
43007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43008 }
43009 arg1 = reinterpret_cast< wxMenu * >(argp1);
43010 ecode2 = SWIG_AsVal_int(obj1, &val2);
43011 if (!SWIG_IsOK(ecode2)) {
43012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
43013 }
43014 arg2 = static_cast< int >(val2);
43015 {
43016 arg3 = wxString_in_helper(obj2);
43017 if (arg3 == NULL) SWIG_fail;
43018 temp3 = true;
43019 }
43020 if (obj3) {
43021 {
43022 arg4 = wxString_in_helper(obj3);
43023 if (arg4 == NULL) SWIG_fail;
43024 temp4 = true;
43025 }
43026 }
43027 {
43028 PyThreadState* __tstate = wxPyBeginAllowThreads();
43029 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43030 wxPyEndAllowThreads(__tstate);
43031 if (PyErr_Occurred()) SWIG_fail;
43032 }
43033 {
43034 resultobj = wxPyMake_wxObject(result, (bool)0);
43035 }
43036 {
43037 if (temp3)
43038 delete arg3;
43039 }
43040 {
43041 if (temp4)
43042 delete arg4;
43043 }
43044 return resultobj;
43045 fail:
43046 {
43047 if (temp3)
43048 delete arg3;
43049 }
43050 {
43051 if (temp4)
43052 delete arg4;
43053 }
43054 return NULL;
43055 }
43056
43057
43058 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43059 PyObject *resultobj = 0;
43060 wxMenu *arg1 = (wxMenu *) 0 ;
43061 int arg2 ;
43062 wxString *arg3 = 0 ;
43063 wxString const &arg4_defvalue = wxPyEmptyString ;
43064 wxString *arg4 = (wxString *) &arg4_defvalue ;
43065 wxMenuItem *result = 0 ;
43066 void *argp1 = 0 ;
43067 int res1 = 0 ;
43068 int val2 ;
43069 int ecode2 = 0 ;
43070 bool temp3 = false ;
43071 bool temp4 = false ;
43072 PyObject * obj0 = 0 ;
43073 PyObject * obj1 = 0 ;
43074 PyObject * obj2 = 0 ;
43075 PyObject * obj3 = 0 ;
43076 char * kwnames[] = {
43077 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43078 };
43079
43080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43082 if (!SWIG_IsOK(res1)) {
43083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43084 }
43085 arg1 = reinterpret_cast< wxMenu * >(argp1);
43086 ecode2 = SWIG_AsVal_int(obj1, &val2);
43087 if (!SWIG_IsOK(ecode2)) {
43088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
43089 }
43090 arg2 = static_cast< int >(val2);
43091 {
43092 arg3 = wxString_in_helper(obj2);
43093 if (arg3 == NULL) SWIG_fail;
43094 temp3 = true;
43095 }
43096 if (obj3) {
43097 {
43098 arg4 = wxString_in_helper(obj3);
43099 if (arg4 == NULL) SWIG_fail;
43100 temp4 = true;
43101 }
43102 }
43103 {
43104 PyThreadState* __tstate = wxPyBeginAllowThreads();
43105 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43106 wxPyEndAllowThreads(__tstate);
43107 if (PyErr_Occurred()) SWIG_fail;
43108 }
43109 {
43110 resultobj = wxPyMake_wxObject(result, (bool)0);
43111 }
43112 {
43113 if (temp3)
43114 delete arg3;
43115 }
43116 {
43117 if (temp4)
43118 delete arg4;
43119 }
43120 return resultobj;
43121 fail:
43122 {
43123 if (temp3)
43124 delete arg3;
43125 }
43126 {
43127 if (temp4)
43128 delete arg4;
43129 }
43130 return NULL;
43131 }
43132
43133
43134 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43135 PyObject *resultobj = 0;
43136 wxMenu *arg1 = (wxMenu *) 0 ;
43137 int arg2 ;
43138 wxString *arg3 = 0 ;
43139 wxMenu *arg4 = (wxMenu *) 0 ;
43140 wxString const &arg5_defvalue = wxPyEmptyString ;
43141 wxString *arg5 = (wxString *) &arg5_defvalue ;
43142 wxMenuItem *result = 0 ;
43143 void *argp1 = 0 ;
43144 int res1 = 0 ;
43145 int val2 ;
43146 int ecode2 = 0 ;
43147 bool temp3 = false ;
43148 void *argp4 = 0 ;
43149 int res4 = 0 ;
43150 bool temp5 = false ;
43151 PyObject * obj0 = 0 ;
43152 PyObject * obj1 = 0 ;
43153 PyObject * obj2 = 0 ;
43154 PyObject * obj3 = 0 ;
43155 PyObject * obj4 = 0 ;
43156 char * kwnames[] = {
43157 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43158 };
43159
43160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43162 if (!SWIG_IsOK(res1)) {
43163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43164 }
43165 arg1 = reinterpret_cast< wxMenu * >(argp1);
43166 ecode2 = SWIG_AsVal_int(obj1, &val2);
43167 if (!SWIG_IsOK(ecode2)) {
43168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43169 }
43170 arg2 = static_cast< int >(val2);
43171 {
43172 arg3 = wxString_in_helper(obj2);
43173 if (arg3 == NULL) SWIG_fail;
43174 temp3 = true;
43175 }
43176 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43177 if (!SWIG_IsOK(res4)) {
43178 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43179 }
43180 arg4 = reinterpret_cast< wxMenu * >(argp4);
43181 if (obj4) {
43182 {
43183 arg5 = wxString_in_helper(obj4);
43184 if (arg5 == NULL) SWIG_fail;
43185 temp5 = true;
43186 }
43187 }
43188 {
43189 PyThreadState* __tstate = wxPyBeginAllowThreads();
43190 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43191 wxPyEndAllowThreads(__tstate);
43192 if (PyErr_Occurred()) SWIG_fail;
43193 }
43194 {
43195 resultobj = wxPyMake_wxObject(result, (bool)0);
43196 }
43197 {
43198 if (temp3)
43199 delete arg3;
43200 }
43201 {
43202 if (temp5)
43203 delete arg5;
43204 }
43205 return resultobj;
43206 fail:
43207 {
43208 if (temp3)
43209 delete arg3;
43210 }
43211 {
43212 if (temp5)
43213 delete arg5;
43214 }
43215 return NULL;
43216 }
43217
43218
43219 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43220 PyObject *resultobj = 0;
43221 wxMenu *arg1 = (wxMenu *) 0 ;
43222 int arg2 ;
43223 wxMenuItem *result = 0 ;
43224 void *argp1 = 0 ;
43225 int res1 = 0 ;
43226 int val2 ;
43227 int ecode2 = 0 ;
43228 PyObject * obj0 = 0 ;
43229 PyObject * obj1 = 0 ;
43230 char * kwnames[] = {
43231 (char *) "self",(char *) "id", NULL
43232 };
43233
43234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43236 if (!SWIG_IsOK(res1)) {
43237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43238 }
43239 arg1 = reinterpret_cast< wxMenu * >(argp1);
43240 ecode2 = SWIG_AsVal_int(obj1, &val2);
43241 if (!SWIG_IsOK(ecode2)) {
43242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43243 }
43244 arg2 = static_cast< int >(val2);
43245 {
43246 PyThreadState* __tstate = wxPyBeginAllowThreads();
43247 result = (wxMenuItem *)(arg1)->Remove(arg2);
43248 wxPyEndAllowThreads(__tstate);
43249 if (PyErr_Occurred()) SWIG_fail;
43250 }
43251 {
43252 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43253 }
43254 return resultobj;
43255 fail:
43256 return NULL;
43257 }
43258
43259
43260 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43261 PyObject *resultobj = 0;
43262 wxMenu *arg1 = (wxMenu *) 0 ;
43263 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43264 wxMenuItem *result = 0 ;
43265 void *argp1 = 0 ;
43266 int res1 = 0 ;
43267 void *argp2 = 0 ;
43268 int res2 = 0 ;
43269 PyObject * obj0 = 0 ;
43270 PyObject * obj1 = 0 ;
43271 char * kwnames[] = {
43272 (char *) "self",(char *) "item", NULL
43273 };
43274
43275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43277 if (!SWIG_IsOK(res1)) {
43278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43279 }
43280 arg1 = reinterpret_cast< wxMenu * >(argp1);
43281 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43282 if (!SWIG_IsOK(res2)) {
43283 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43284 }
43285 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43286 {
43287 PyThreadState* __tstate = wxPyBeginAllowThreads();
43288 result = (wxMenuItem *)(arg1)->Remove(arg2);
43289 wxPyEndAllowThreads(__tstate);
43290 if (PyErr_Occurred()) SWIG_fail;
43291 }
43292 {
43293 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43294 }
43295 return resultobj;
43296 fail:
43297 return NULL;
43298 }
43299
43300
43301 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43302 PyObject *resultobj = 0;
43303 wxMenu *arg1 = (wxMenu *) 0 ;
43304 int arg2 ;
43305 bool result;
43306 void *argp1 = 0 ;
43307 int res1 = 0 ;
43308 int val2 ;
43309 int ecode2 = 0 ;
43310 PyObject * obj0 = 0 ;
43311 PyObject * obj1 = 0 ;
43312 char * kwnames[] = {
43313 (char *) "self",(char *) "id", NULL
43314 };
43315
43316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43318 if (!SWIG_IsOK(res1)) {
43319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43320 }
43321 arg1 = reinterpret_cast< wxMenu * >(argp1);
43322 ecode2 = SWIG_AsVal_int(obj1, &val2);
43323 if (!SWIG_IsOK(ecode2)) {
43324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43325 }
43326 arg2 = static_cast< int >(val2);
43327 {
43328 PyThreadState* __tstate = wxPyBeginAllowThreads();
43329 result = (bool)(arg1)->Delete(arg2);
43330 wxPyEndAllowThreads(__tstate);
43331 if (PyErr_Occurred()) SWIG_fail;
43332 }
43333 {
43334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43335 }
43336 return resultobj;
43337 fail:
43338 return NULL;
43339 }
43340
43341
43342 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43343 PyObject *resultobj = 0;
43344 wxMenu *arg1 = (wxMenu *) 0 ;
43345 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43346 bool result;
43347 void *argp1 = 0 ;
43348 int res1 = 0 ;
43349 void *argp2 = 0 ;
43350 int res2 = 0 ;
43351 PyObject * obj0 = 0 ;
43352 PyObject * obj1 = 0 ;
43353 char * kwnames[] = {
43354 (char *) "self",(char *) "item", NULL
43355 };
43356
43357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43359 if (!SWIG_IsOK(res1)) {
43360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43361 }
43362 arg1 = reinterpret_cast< wxMenu * >(argp1);
43363 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43364 if (!SWIG_IsOK(res2)) {
43365 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43366 }
43367 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43368 {
43369 PyThreadState* __tstate = wxPyBeginAllowThreads();
43370 result = (bool)(arg1)->Delete(arg2);
43371 wxPyEndAllowThreads(__tstate);
43372 if (PyErr_Occurred()) SWIG_fail;
43373 }
43374 {
43375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43376 }
43377 return resultobj;
43378 fail:
43379 return NULL;
43380 }
43381
43382
43383 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43384 PyObject *resultobj = 0;
43385 wxMenu *arg1 = (wxMenu *) 0 ;
43386 void *argp1 = 0 ;
43387 int res1 = 0 ;
43388 PyObject *swig_obj[1] ;
43389
43390 if (!args) SWIG_fail;
43391 swig_obj[0] = args;
43392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43393 if (!SWIG_IsOK(res1)) {
43394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43395 }
43396 arg1 = reinterpret_cast< wxMenu * >(argp1);
43397 {
43398 PyThreadState* __tstate = wxPyBeginAllowThreads();
43399 wxMenu_Destroy(arg1);
43400 wxPyEndAllowThreads(__tstate);
43401 if (PyErr_Occurred()) SWIG_fail;
43402 }
43403 resultobj = SWIG_Py_Void();
43404 return resultobj;
43405 fail:
43406 return NULL;
43407 }
43408
43409
43410 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43411 PyObject *resultobj = 0;
43412 wxMenu *arg1 = (wxMenu *) 0 ;
43413 int arg2 ;
43414 bool result;
43415 void *argp1 = 0 ;
43416 int res1 = 0 ;
43417 int val2 ;
43418 int ecode2 = 0 ;
43419 PyObject * obj0 = 0 ;
43420 PyObject * obj1 = 0 ;
43421 char * kwnames[] = {
43422 (char *) "self",(char *) "id", NULL
43423 };
43424
43425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43427 if (!SWIG_IsOK(res1)) {
43428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43429 }
43430 arg1 = reinterpret_cast< wxMenu * >(argp1);
43431 ecode2 = SWIG_AsVal_int(obj1, &val2);
43432 if (!SWIG_IsOK(ecode2)) {
43433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43434 }
43435 arg2 = static_cast< int >(val2);
43436 {
43437 PyThreadState* __tstate = wxPyBeginAllowThreads();
43438 result = (bool)(arg1)->Destroy(arg2);
43439 wxPyEndAllowThreads(__tstate);
43440 if (PyErr_Occurred()) SWIG_fail;
43441 }
43442 {
43443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43444 }
43445 return resultobj;
43446 fail:
43447 return NULL;
43448 }
43449
43450
43451 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43452 PyObject *resultobj = 0;
43453 wxMenu *arg1 = (wxMenu *) 0 ;
43454 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43455 bool result;
43456 void *argp1 = 0 ;
43457 int res1 = 0 ;
43458 void *argp2 = 0 ;
43459 int res2 = 0 ;
43460 PyObject * obj0 = 0 ;
43461 PyObject * obj1 = 0 ;
43462 char * kwnames[] = {
43463 (char *) "self",(char *) "item", NULL
43464 };
43465
43466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43468 if (!SWIG_IsOK(res1)) {
43469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43470 }
43471 arg1 = reinterpret_cast< wxMenu * >(argp1);
43472 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43473 if (!SWIG_IsOK(res2)) {
43474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43475 }
43476 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43477 {
43478 PyThreadState* __tstate = wxPyBeginAllowThreads();
43479 result = (bool)(arg1)->Destroy(arg2);
43480 wxPyEndAllowThreads(__tstate);
43481 if (PyErr_Occurred()) SWIG_fail;
43482 }
43483 {
43484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43485 }
43486 return resultobj;
43487 fail:
43488 return NULL;
43489 }
43490
43491
43492 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43493 PyObject *resultobj = 0;
43494 wxMenu *arg1 = (wxMenu *) 0 ;
43495 size_t result;
43496 void *argp1 = 0 ;
43497 int res1 = 0 ;
43498 PyObject *swig_obj[1] ;
43499
43500 if (!args) SWIG_fail;
43501 swig_obj[0] = args;
43502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43503 if (!SWIG_IsOK(res1)) {
43504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43505 }
43506 arg1 = reinterpret_cast< wxMenu * >(argp1);
43507 {
43508 PyThreadState* __tstate = wxPyBeginAllowThreads();
43509 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43510 wxPyEndAllowThreads(__tstate);
43511 if (PyErr_Occurred()) SWIG_fail;
43512 }
43513 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43514 return resultobj;
43515 fail:
43516 return NULL;
43517 }
43518
43519
43520 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43521 PyObject *resultobj = 0;
43522 wxMenu *arg1 = (wxMenu *) 0 ;
43523 PyObject *result = 0 ;
43524 void *argp1 = 0 ;
43525 int res1 = 0 ;
43526 PyObject *swig_obj[1] ;
43527
43528 if (!args) SWIG_fail;
43529 swig_obj[0] = args;
43530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43531 if (!SWIG_IsOK(res1)) {
43532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43533 }
43534 arg1 = reinterpret_cast< wxMenu * >(argp1);
43535 {
43536 PyThreadState* __tstate = wxPyBeginAllowThreads();
43537 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43538 wxPyEndAllowThreads(__tstate);
43539 if (PyErr_Occurred()) SWIG_fail;
43540 }
43541 resultobj = result;
43542 return resultobj;
43543 fail:
43544 return NULL;
43545 }
43546
43547
43548 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43549 PyObject *resultobj = 0;
43550 wxMenu *arg1 = (wxMenu *) 0 ;
43551 wxString *arg2 = 0 ;
43552 int result;
43553 void *argp1 = 0 ;
43554 int res1 = 0 ;
43555 bool temp2 = false ;
43556 PyObject * obj0 = 0 ;
43557 PyObject * obj1 = 0 ;
43558 char * kwnames[] = {
43559 (char *) "self",(char *) "item", NULL
43560 };
43561
43562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",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_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43566 }
43567 arg1 = reinterpret_cast< wxMenu * >(argp1);
43568 {
43569 arg2 = wxString_in_helper(obj1);
43570 if (arg2 == NULL) SWIG_fail;
43571 temp2 = true;
43572 }
43573 {
43574 PyThreadState* __tstate = wxPyBeginAllowThreads();
43575 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43576 wxPyEndAllowThreads(__tstate);
43577 if (PyErr_Occurred()) SWIG_fail;
43578 }
43579 resultobj = SWIG_From_int(static_cast< int >(result));
43580 {
43581 if (temp2)
43582 delete arg2;
43583 }
43584 return resultobj;
43585 fail:
43586 {
43587 if (temp2)
43588 delete arg2;
43589 }
43590 return NULL;
43591 }
43592
43593
43594 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43595 PyObject *resultobj = 0;
43596 wxMenu *arg1 = (wxMenu *) 0 ;
43597 int arg2 ;
43598 wxMenuItem *result = 0 ;
43599 void *argp1 = 0 ;
43600 int res1 = 0 ;
43601 int val2 ;
43602 int ecode2 = 0 ;
43603 PyObject * obj0 = 0 ;
43604 PyObject * obj1 = 0 ;
43605 char * kwnames[] = {
43606 (char *) "self",(char *) "id", NULL
43607 };
43608
43609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43611 if (!SWIG_IsOK(res1)) {
43612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43613 }
43614 arg1 = reinterpret_cast< wxMenu * >(argp1);
43615 ecode2 = SWIG_AsVal_int(obj1, &val2);
43616 if (!SWIG_IsOK(ecode2)) {
43617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43618 }
43619 arg2 = static_cast< int >(val2);
43620 {
43621 PyThreadState* __tstate = wxPyBeginAllowThreads();
43622 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43623 wxPyEndAllowThreads(__tstate);
43624 if (PyErr_Occurred()) SWIG_fail;
43625 }
43626 {
43627 resultobj = wxPyMake_wxObject(result, (bool)0);
43628 }
43629 return resultobj;
43630 fail:
43631 return NULL;
43632 }
43633
43634
43635 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43636 PyObject *resultobj = 0;
43637 wxMenu *arg1 = (wxMenu *) 0 ;
43638 size_t arg2 ;
43639 wxMenuItem *result = 0 ;
43640 void *argp1 = 0 ;
43641 int res1 = 0 ;
43642 size_t val2 ;
43643 int ecode2 = 0 ;
43644 PyObject * obj0 = 0 ;
43645 PyObject * obj1 = 0 ;
43646 char * kwnames[] = {
43647 (char *) "self",(char *) "position", NULL
43648 };
43649
43650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",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_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43654 }
43655 arg1 = reinterpret_cast< wxMenu * >(argp1);
43656 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43657 if (!SWIG_IsOK(ecode2)) {
43658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43659 }
43660 arg2 = static_cast< size_t >(val2);
43661 {
43662 PyThreadState* __tstate = wxPyBeginAllowThreads();
43663 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43664 wxPyEndAllowThreads(__tstate);
43665 if (PyErr_Occurred()) SWIG_fail;
43666 }
43667 {
43668 resultobj = wxPyMake_wxObject(result, (bool)0);
43669 }
43670 return resultobj;
43671 fail:
43672 return NULL;
43673 }
43674
43675
43676 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43677 PyObject *resultobj = 0;
43678 wxMenu *arg1 = (wxMenu *) 0 ;
43679 int arg2 ;
43680 bool arg3 ;
43681 void *argp1 = 0 ;
43682 int res1 = 0 ;
43683 int val2 ;
43684 int ecode2 = 0 ;
43685 bool val3 ;
43686 int ecode3 = 0 ;
43687 PyObject * obj0 = 0 ;
43688 PyObject * obj1 = 0 ;
43689 PyObject * obj2 = 0 ;
43690 char * kwnames[] = {
43691 (char *) "self",(char *) "id",(char *) "enable", NULL
43692 };
43693
43694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43696 if (!SWIG_IsOK(res1)) {
43697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43698 }
43699 arg1 = reinterpret_cast< wxMenu * >(argp1);
43700 ecode2 = SWIG_AsVal_int(obj1, &val2);
43701 if (!SWIG_IsOK(ecode2)) {
43702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43703 }
43704 arg2 = static_cast< int >(val2);
43705 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43706 if (!SWIG_IsOK(ecode3)) {
43707 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43708 }
43709 arg3 = static_cast< bool >(val3);
43710 {
43711 PyThreadState* __tstate = wxPyBeginAllowThreads();
43712 (arg1)->Enable(arg2,arg3);
43713 wxPyEndAllowThreads(__tstate);
43714 if (PyErr_Occurred()) SWIG_fail;
43715 }
43716 resultobj = SWIG_Py_Void();
43717 return resultobj;
43718 fail:
43719 return NULL;
43720 }
43721
43722
43723 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43724 PyObject *resultobj = 0;
43725 wxMenu *arg1 = (wxMenu *) 0 ;
43726 int arg2 ;
43727 bool result;
43728 void *argp1 = 0 ;
43729 int res1 = 0 ;
43730 int val2 ;
43731 int ecode2 = 0 ;
43732 PyObject * obj0 = 0 ;
43733 PyObject * obj1 = 0 ;
43734 char * kwnames[] = {
43735 (char *) "self",(char *) "id", NULL
43736 };
43737
43738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43740 if (!SWIG_IsOK(res1)) {
43741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43742 }
43743 arg1 = reinterpret_cast< wxMenu * >(argp1);
43744 ecode2 = SWIG_AsVal_int(obj1, &val2);
43745 if (!SWIG_IsOK(ecode2)) {
43746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43747 }
43748 arg2 = static_cast< int >(val2);
43749 {
43750 PyThreadState* __tstate = wxPyBeginAllowThreads();
43751 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43752 wxPyEndAllowThreads(__tstate);
43753 if (PyErr_Occurred()) SWIG_fail;
43754 }
43755 {
43756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43757 }
43758 return resultobj;
43759 fail:
43760 return NULL;
43761 }
43762
43763
43764 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43765 PyObject *resultobj = 0;
43766 wxMenu *arg1 = (wxMenu *) 0 ;
43767 int arg2 ;
43768 bool arg3 ;
43769 void *argp1 = 0 ;
43770 int res1 = 0 ;
43771 int val2 ;
43772 int ecode2 = 0 ;
43773 bool val3 ;
43774 int ecode3 = 0 ;
43775 PyObject * obj0 = 0 ;
43776 PyObject * obj1 = 0 ;
43777 PyObject * obj2 = 0 ;
43778 char * kwnames[] = {
43779 (char *) "self",(char *) "id",(char *) "check", NULL
43780 };
43781
43782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43784 if (!SWIG_IsOK(res1)) {
43785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43786 }
43787 arg1 = reinterpret_cast< wxMenu * >(argp1);
43788 ecode2 = SWIG_AsVal_int(obj1, &val2);
43789 if (!SWIG_IsOK(ecode2)) {
43790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43791 }
43792 arg2 = static_cast< int >(val2);
43793 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43794 if (!SWIG_IsOK(ecode3)) {
43795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43796 }
43797 arg3 = static_cast< bool >(val3);
43798 {
43799 PyThreadState* __tstate = wxPyBeginAllowThreads();
43800 (arg1)->Check(arg2,arg3);
43801 wxPyEndAllowThreads(__tstate);
43802 if (PyErr_Occurred()) SWIG_fail;
43803 }
43804 resultobj = SWIG_Py_Void();
43805 return resultobj;
43806 fail:
43807 return NULL;
43808 }
43809
43810
43811 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43812 PyObject *resultobj = 0;
43813 wxMenu *arg1 = (wxMenu *) 0 ;
43814 int arg2 ;
43815 bool result;
43816 void *argp1 = 0 ;
43817 int res1 = 0 ;
43818 int val2 ;
43819 int ecode2 = 0 ;
43820 PyObject * obj0 = 0 ;
43821 PyObject * obj1 = 0 ;
43822 char * kwnames[] = {
43823 (char *) "self",(char *) "id", NULL
43824 };
43825
43826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43828 if (!SWIG_IsOK(res1)) {
43829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43830 }
43831 arg1 = reinterpret_cast< wxMenu * >(argp1);
43832 ecode2 = SWIG_AsVal_int(obj1, &val2);
43833 if (!SWIG_IsOK(ecode2)) {
43834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43835 }
43836 arg2 = static_cast< int >(val2);
43837 {
43838 PyThreadState* __tstate = wxPyBeginAllowThreads();
43839 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43840 wxPyEndAllowThreads(__tstate);
43841 if (PyErr_Occurred()) SWIG_fail;
43842 }
43843 {
43844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43845 }
43846 return resultobj;
43847 fail:
43848 return NULL;
43849 }
43850
43851
43852 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43853 PyObject *resultobj = 0;
43854 wxMenu *arg1 = (wxMenu *) 0 ;
43855 int arg2 ;
43856 wxString *arg3 = 0 ;
43857 void *argp1 = 0 ;
43858 int res1 = 0 ;
43859 int val2 ;
43860 int ecode2 = 0 ;
43861 bool temp3 = false ;
43862 PyObject * obj0 = 0 ;
43863 PyObject * obj1 = 0 ;
43864 PyObject * obj2 = 0 ;
43865 char * kwnames[] = {
43866 (char *) "self",(char *) "id",(char *) "label", NULL
43867 };
43868
43869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43871 if (!SWIG_IsOK(res1)) {
43872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
43873 }
43874 arg1 = reinterpret_cast< wxMenu * >(argp1);
43875 ecode2 = SWIG_AsVal_int(obj1, &val2);
43876 if (!SWIG_IsOK(ecode2)) {
43877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
43878 }
43879 arg2 = static_cast< int >(val2);
43880 {
43881 arg3 = wxString_in_helper(obj2);
43882 if (arg3 == NULL) SWIG_fail;
43883 temp3 = true;
43884 }
43885 {
43886 PyThreadState* __tstate = wxPyBeginAllowThreads();
43887 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43888 wxPyEndAllowThreads(__tstate);
43889 if (PyErr_Occurred()) SWIG_fail;
43890 }
43891 resultobj = SWIG_Py_Void();
43892 {
43893 if (temp3)
43894 delete arg3;
43895 }
43896 return resultobj;
43897 fail:
43898 {
43899 if (temp3)
43900 delete arg3;
43901 }
43902 return NULL;
43903 }
43904
43905
43906 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43907 PyObject *resultobj = 0;
43908 wxMenu *arg1 = (wxMenu *) 0 ;
43909 int arg2 ;
43910 wxString result;
43911 void *argp1 = 0 ;
43912 int res1 = 0 ;
43913 int val2 ;
43914 int ecode2 = 0 ;
43915 PyObject * obj0 = 0 ;
43916 PyObject * obj1 = 0 ;
43917 char * kwnames[] = {
43918 (char *) "self",(char *) "id", NULL
43919 };
43920
43921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43923 if (!SWIG_IsOK(res1)) {
43924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
43925 }
43926 arg1 = reinterpret_cast< wxMenu * >(argp1);
43927 ecode2 = SWIG_AsVal_int(obj1, &val2);
43928 if (!SWIG_IsOK(ecode2)) {
43929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
43930 }
43931 arg2 = static_cast< int >(val2);
43932 {
43933 PyThreadState* __tstate = wxPyBeginAllowThreads();
43934 result = ((wxMenu const *)arg1)->GetLabel(arg2);
43935 wxPyEndAllowThreads(__tstate);
43936 if (PyErr_Occurred()) SWIG_fail;
43937 }
43938 {
43939 #if wxUSE_UNICODE
43940 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43941 #else
43942 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43943 #endif
43944 }
43945 return resultobj;
43946 fail:
43947 return NULL;
43948 }
43949
43950
43951 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43952 PyObject *resultobj = 0;
43953 wxMenu *arg1 = (wxMenu *) 0 ;
43954 int arg2 ;
43955 wxString *arg3 = 0 ;
43956 void *argp1 = 0 ;
43957 int res1 = 0 ;
43958 int val2 ;
43959 int ecode2 = 0 ;
43960 bool temp3 = false ;
43961 PyObject * obj0 = 0 ;
43962 PyObject * obj1 = 0 ;
43963 PyObject * obj2 = 0 ;
43964 char * kwnames[] = {
43965 (char *) "self",(char *) "id",(char *) "helpString", NULL
43966 };
43967
43968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43970 if (!SWIG_IsOK(res1)) {
43971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
43972 }
43973 arg1 = reinterpret_cast< wxMenu * >(argp1);
43974 ecode2 = SWIG_AsVal_int(obj1, &val2);
43975 if (!SWIG_IsOK(ecode2)) {
43976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43977 }
43978 arg2 = static_cast< int >(val2);
43979 {
43980 arg3 = wxString_in_helper(obj2);
43981 if (arg3 == NULL) SWIG_fail;
43982 temp3 = true;
43983 }
43984 {
43985 PyThreadState* __tstate = wxPyBeginAllowThreads();
43986 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43987 wxPyEndAllowThreads(__tstate);
43988 if (PyErr_Occurred()) SWIG_fail;
43989 }
43990 resultobj = SWIG_Py_Void();
43991 {
43992 if (temp3)
43993 delete arg3;
43994 }
43995 return resultobj;
43996 fail:
43997 {
43998 if (temp3)
43999 delete arg3;
44000 }
44001 return NULL;
44002 }
44003
44004
44005 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44006 PyObject *resultobj = 0;
44007 wxMenu *arg1 = (wxMenu *) 0 ;
44008 int arg2 ;
44009 wxString result;
44010 void *argp1 = 0 ;
44011 int res1 = 0 ;
44012 int val2 ;
44013 int ecode2 = 0 ;
44014 PyObject * obj0 = 0 ;
44015 PyObject * obj1 = 0 ;
44016 char * kwnames[] = {
44017 (char *) "self",(char *) "id", NULL
44018 };
44019
44020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
44021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44022 if (!SWIG_IsOK(res1)) {
44023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
44024 }
44025 arg1 = reinterpret_cast< wxMenu * >(argp1);
44026 ecode2 = SWIG_AsVal_int(obj1, &val2);
44027 if (!SWIG_IsOK(ecode2)) {
44028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
44029 }
44030 arg2 = static_cast< int >(val2);
44031 {
44032 PyThreadState* __tstate = wxPyBeginAllowThreads();
44033 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
44034 wxPyEndAllowThreads(__tstate);
44035 if (PyErr_Occurred()) SWIG_fail;
44036 }
44037 {
44038 #if wxUSE_UNICODE
44039 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44040 #else
44041 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44042 #endif
44043 }
44044 return resultobj;
44045 fail:
44046 return NULL;
44047 }
44048
44049
44050 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44051 PyObject *resultobj = 0;
44052 wxMenu *arg1 = (wxMenu *) 0 ;
44053 wxString *arg2 = 0 ;
44054 void *argp1 = 0 ;
44055 int res1 = 0 ;
44056 bool temp2 = false ;
44057 PyObject * obj0 = 0 ;
44058 PyObject * obj1 = 0 ;
44059 char * kwnames[] = {
44060 (char *) "self",(char *) "title", NULL
44061 };
44062
44063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
44064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44065 if (!SWIG_IsOK(res1)) {
44066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
44067 }
44068 arg1 = reinterpret_cast< wxMenu * >(argp1);
44069 {
44070 arg2 = wxString_in_helper(obj1);
44071 if (arg2 == NULL) SWIG_fail;
44072 temp2 = true;
44073 }
44074 {
44075 PyThreadState* __tstate = wxPyBeginAllowThreads();
44076 (arg1)->SetTitle((wxString const &)*arg2);
44077 wxPyEndAllowThreads(__tstate);
44078 if (PyErr_Occurred()) SWIG_fail;
44079 }
44080 resultobj = SWIG_Py_Void();
44081 {
44082 if (temp2)
44083 delete arg2;
44084 }
44085 return resultobj;
44086 fail:
44087 {
44088 if (temp2)
44089 delete arg2;
44090 }
44091 return NULL;
44092 }
44093
44094
44095 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44096 PyObject *resultobj = 0;
44097 wxMenu *arg1 = (wxMenu *) 0 ;
44098 wxString result;
44099 void *argp1 = 0 ;
44100 int res1 = 0 ;
44101 PyObject *swig_obj[1] ;
44102
44103 if (!args) SWIG_fail;
44104 swig_obj[0] = args;
44105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44106 if (!SWIG_IsOK(res1)) {
44107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44108 }
44109 arg1 = reinterpret_cast< wxMenu * >(argp1);
44110 {
44111 PyThreadState* __tstate = wxPyBeginAllowThreads();
44112 result = ((wxMenu const *)arg1)->GetTitle();
44113 wxPyEndAllowThreads(__tstate);
44114 if (PyErr_Occurred()) SWIG_fail;
44115 }
44116 {
44117 #if wxUSE_UNICODE
44118 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44119 #else
44120 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44121 #endif
44122 }
44123 return resultobj;
44124 fail:
44125 return NULL;
44126 }
44127
44128
44129 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44130 PyObject *resultobj = 0;
44131 wxMenu *arg1 = (wxMenu *) 0 ;
44132 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
44133 void *argp1 = 0 ;
44134 int res1 = 0 ;
44135 void *argp2 = 0 ;
44136 int res2 = 0 ;
44137 PyObject * obj0 = 0 ;
44138 PyObject * obj1 = 0 ;
44139 char * kwnames[] = {
44140 (char *) "self",(char *) "handler", NULL
44141 };
44142
44143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
44144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44145 if (!SWIG_IsOK(res1)) {
44146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44147 }
44148 arg1 = reinterpret_cast< wxMenu * >(argp1);
44149 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44150 if (!SWIG_IsOK(res2)) {
44151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44152 }
44153 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44154 {
44155 PyThreadState* __tstate = wxPyBeginAllowThreads();
44156 (arg1)->SetEventHandler(arg2);
44157 wxPyEndAllowThreads(__tstate);
44158 if (PyErr_Occurred()) SWIG_fail;
44159 }
44160 resultobj = SWIG_Py_Void();
44161 return resultobj;
44162 fail:
44163 return NULL;
44164 }
44165
44166
44167 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44168 PyObject *resultobj = 0;
44169 wxMenu *arg1 = (wxMenu *) 0 ;
44170 wxEvtHandler *result = 0 ;
44171 void *argp1 = 0 ;
44172 int res1 = 0 ;
44173 PyObject *swig_obj[1] ;
44174
44175 if (!args) SWIG_fail;
44176 swig_obj[0] = args;
44177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44178 if (!SWIG_IsOK(res1)) {
44179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44180 }
44181 arg1 = reinterpret_cast< wxMenu * >(argp1);
44182 {
44183 PyThreadState* __tstate = wxPyBeginAllowThreads();
44184 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44185 wxPyEndAllowThreads(__tstate);
44186 if (PyErr_Occurred()) SWIG_fail;
44187 }
44188 {
44189 resultobj = wxPyMake_wxObject(result, 0);
44190 }
44191 return resultobj;
44192 fail:
44193 return NULL;
44194 }
44195
44196
44197 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44198 PyObject *resultobj = 0;
44199 wxMenu *arg1 = (wxMenu *) 0 ;
44200 wxWindow *arg2 = (wxWindow *) 0 ;
44201 void *argp1 = 0 ;
44202 int res1 = 0 ;
44203 void *argp2 = 0 ;
44204 int res2 = 0 ;
44205 PyObject * obj0 = 0 ;
44206 PyObject * obj1 = 0 ;
44207 char * kwnames[] = {
44208 (char *) "self",(char *) "win", NULL
44209 };
44210
44211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44213 if (!SWIG_IsOK(res1)) {
44214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44215 }
44216 arg1 = reinterpret_cast< wxMenu * >(argp1);
44217 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44218 if (!SWIG_IsOK(res2)) {
44219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44220 }
44221 arg2 = reinterpret_cast< wxWindow * >(argp2);
44222 {
44223 PyThreadState* __tstate = wxPyBeginAllowThreads();
44224 (arg1)->SetInvokingWindow(arg2);
44225 wxPyEndAllowThreads(__tstate);
44226 if (PyErr_Occurred()) SWIG_fail;
44227 }
44228 resultobj = SWIG_Py_Void();
44229 return resultobj;
44230 fail:
44231 return NULL;
44232 }
44233
44234
44235 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44236 PyObject *resultobj = 0;
44237 wxMenu *arg1 = (wxMenu *) 0 ;
44238 wxWindow *result = 0 ;
44239 void *argp1 = 0 ;
44240 int res1 = 0 ;
44241 PyObject *swig_obj[1] ;
44242
44243 if (!args) SWIG_fail;
44244 swig_obj[0] = args;
44245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44246 if (!SWIG_IsOK(res1)) {
44247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44248 }
44249 arg1 = reinterpret_cast< wxMenu * >(argp1);
44250 {
44251 PyThreadState* __tstate = wxPyBeginAllowThreads();
44252 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44253 wxPyEndAllowThreads(__tstate);
44254 if (PyErr_Occurred()) SWIG_fail;
44255 }
44256 {
44257 resultobj = wxPyMake_wxObject(result, 0);
44258 }
44259 return resultobj;
44260 fail:
44261 return NULL;
44262 }
44263
44264
44265 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44266 PyObject *resultobj = 0;
44267 wxMenu *arg1 = (wxMenu *) 0 ;
44268 long result;
44269 void *argp1 = 0 ;
44270 int res1 = 0 ;
44271 PyObject *swig_obj[1] ;
44272
44273 if (!args) SWIG_fail;
44274 swig_obj[0] = args;
44275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44276 if (!SWIG_IsOK(res1)) {
44277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44278 }
44279 arg1 = reinterpret_cast< wxMenu * >(argp1);
44280 {
44281 PyThreadState* __tstate = wxPyBeginAllowThreads();
44282 result = (long)((wxMenu const *)arg1)->GetStyle();
44283 wxPyEndAllowThreads(__tstate);
44284 if (PyErr_Occurred()) SWIG_fail;
44285 }
44286 resultobj = SWIG_From_long(static_cast< long >(result));
44287 return resultobj;
44288 fail:
44289 return NULL;
44290 }
44291
44292
44293 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44294 PyObject *resultobj = 0;
44295 wxMenu *arg1 = (wxMenu *) 0 ;
44296 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44297 void *argp1 = 0 ;
44298 int res1 = 0 ;
44299 void *argp2 = 0 ;
44300 int res2 = 0 ;
44301 PyObject * obj0 = 0 ;
44302 PyObject * obj1 = 0 ;
44303 char * kwnames[] = {
44304 (char *) "self",(char *) "source", NULL
44305 };
44306
44307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44309 if (!SWIG_IsOK(res1)) {
44310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44311 }
44312 arg1 = reinterpret_cast< wxMenu * >(argp1);
44313 if (obj1) {
44314 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44315 if (!SWIG_IsOK(res2)) {
44316 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44317 }
44318 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44319 }
44320 {
44321 PyThreadState* __tstate = wxPyBeginAllowThreads();
44322 (arg1)->UpdateUI(arg2);
44323 wxPyEndAllowThreads(__tstate);
44324 if (PyErr_Occurred()) SWIG_fail;
44325 }
44326 resultobj = SWIG_Py_Void();
44327 return resultobj;
44328 fail:
44329 return NULL;
44330 }
44331
44332
44333 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44334 PyObject *resultobj = 0;
44335 wxMenu *arg1 = (wxMenu *) 0 ;
44336 wxMenuBar *result = 0 ;
44337 void *argp1 = 0 ;
44338 int res1 = 0 ;
44339 PyObject *swig_obj[1] ;
44340
44341 if (!args) SWIG_fail;
44342 swig_obj[0] = args;
44343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44344 if (!SWIG_IsOK(res1)) {
44345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44346 }
44347 arg1 = reinterpret_cast< wxMenu * >(argp1);
44348 {
44349 PyThreadState* __tstate = wxPyBeginAllowThreads();
44350 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44351 wxPyEndAllowThreads(__tstate);
44352 if (PyErr_Occurred()) SWIG_fail;
44353 }
44354 {
44355 resultobj = wxPyMake_wxObject(result, (bool)0);
44356 }
44357 return resultobj;
44358 fail:
44359 return NULL;
44360 }
44361
44362
44363 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44364 PyObject *resultobj = 0;
44365 wxMenu *arg1 = (wxMenu *) 0 ;
44366 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44367 void *argp1 = 0 ;
44368 int res1 = 0 ;
44369 void *argp2 = 0 ;
44370 int res2 = 0 ;
44371 PyObject * obj0 = 0 ;
44372 PyObject * obj1 = 0 ;
44373 char * kwnames[] = {
44374 (char *) "self",(char *) "menubar", NULL
44375 };
44376
44377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44379 if (!SWIG_IsOK(res1)) {
44380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44381 }
44382 arg1 = reinterpret_cast< wxMenu * >(argp1);
44383 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44384 if (!SWIG_IsOK(res2)) {
44385 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44386 }
44387 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44388 {
44389 PyThreadState* __tstate = wxPyBeginAllowThreads();
44390 (arg1)->Attach(arg2);
44391 wxPyEndAllowThreads(__tstate);
44392 if (PyErr_Occurred()) SWIG_fail;
44393 }
44394 resultobj = SWIG_Py_Void();
44395 return resultobj;
44396 fail:
44397 return NULL;
44398 }
44399
44400
44401 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44402 PyObject *resultobj = 0;
44403 wxMenu *arg1 = (wxMenu *) 0 ;
44404 void *argp1 = 0 ;
44405 int res1 = 0 ;
44406 PyObject *swig_obj[1] ;
44407
44408 if (!args) SWIG_fail;
44409 swig_obj[0] = args;
44410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44411 if (!SWIG_IsOK(res1)) {
44412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44413 }
44414 arg1 = reinterpret_cast< wxMenu * >(argp1);
44415 {
44416 PyThreadState* __tstate = wxPyBeginAllowThreads();
44417 (arg1)->Detach();
44418 wxPyEndAllowThreads(__tstate);
44419 if (PyErr_Occurred()) SWIG_fail;
44420 }
44421 resultobj = SWIG_Py_Void();
44422 return resultobj;
44423 fail:
44424 return NULL;
44425 }
44426
44427
44428 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44429 PyObject *resultobj = 0;
44430 wxMenu *arg1 = (wxMenu *) 0 ;
44431 bool result;
44432 void *argp1 = 0 ;
44433 int res1 = 0 ;
44434 PyObject *swig_obj[1] ;
44435
44436 if (!args) SWIG_fail;
44437 swig_obj[0] = args;
44438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44439 if (!SWIG_IsOK(res1)) {
44440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44441 }
44442 arg1 = reinterpret_cast< wxMenu * >(argp1);
44443 {
44444 PyThreadState* __tstate = wxPyBeginAllowThreads();
44445 result = (bool)((wxMenu const *)arg1)->IsAttached();
44446 wxPyEndAllowThreads(__tstate);
44447 if (PyErr_Occurred()) SWIG_fail;
44448 }
44449 {
44450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44451 }
44452 return resultobj;
44453 fail:
44454 return NULL;
44455 }
44456
44457
44458 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44459 PyObject *resultobj = 0;
44460 wxMenu *arg1 = (wxMenu *) 0 ;
44461 wxMenu *arg2 = (wxMenu *) 0 ;
44462 void *argp1 = 0 ;
44463 int res1 = 0 ;
44464 void *argp2 = 0 ;
44465 int res2 = 0 ;
44466 PyObject * obj0 = 0 ;
44467 PyObject * obj1 = 0 ;
44468 char * kwnames[] = {
44469 (char *) "self",(char *) "parent", NULL
44470 };
44471
44472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44474 if (!SWIG_IsOK(res1)) {
44475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44476 }
44477 arg1 = reinterpret_cast< wxMenu * >(argp1);
44478 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44479 if (!SWIG_IsOK(res2)) {
44480 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44481 }
44482 arg2 = reinterpret_cast< wxMenu * >(argp2);
44483 {
44484 PyThreadState* __tstate = wxPyBeginAllowThreads();
44485 (arg1)->SetParent(arg2);
44486 wxPyEndAllowThreads(__tstate);
44487 if (PyErr_Occurred()) SWIG_fail;
44488 }
44489 resultobj = SWIG_Py_Void();
44490 return resultobj;
44491 fail:
44492 return NULL;
44493 }
44494
44495
44496 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44497 PyObject *resultobj = 0;
44498 wxMenu *arg1 = (wxMenu *) 0 ;
44499 wxMenu *result = 0 ;
44500 void *argp1 = 0 ;
44501 int res1 = 0 ;
44502 PyObject *swig_obj[1] ;
44503
44504 if (!args) SWIG_fail;
44505 swig_obj[0] = args;
44506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44507 if (!SWIG_IsOK(res1)) {
44508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44509 }
44510 arg1 = reinterpret_cast< wxMenu * >(argp1);
44511 {
44512 PyThreadState* __tstate = wxPyBeginAllowThreads();
44513 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44514 wxPyEndAllowThreads(__tstate);
44515 if (PyErr_Occurred()) SWIG_fail;
44516 }
44517 {
44518 resultobj = wxPyMake_wxObject(result, 0);
44519 }
44520 return resultobj;
44521 fail:
44522 return NULL;
44523 }
44524
44525
44526 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44527 PyObject *obj;
44528 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44529 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44530 return SWIG_Py_Void();
44531 }
44532
44533 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44534 return SWIG_Python_InitShadowInstance(args);
44535 }
44536
44537 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44538 PyObject *resultobj = 0;
44539 long arg1 = (long) 0 ;
44540 wxMenuBar *result = 0 ;
44541 long val1 ;
44542 int ecode1 = 0 ;
44543 PyObject * obj0 = 0 ;
44544 char * kwnames[] = {
44545 (char *) "style", NULL
44546 };
44547
44548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44549 if (obj0) {
44550 ecode1 = SWIG_AsVal_long(obj0, &val1);
44551 if (!SWIG_IsOK(ecode1)) {
44552 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44553 }
44554 arg1 = static_cast< long >(val1);
44555 }
44556 {
44557 if (!wxPyCheckForApp()) SWIG_fail;
44558 PyThreadState* __tstate = wxPyBeginAllowThreads();
44559 result = (wxMenuBar *)new wxMenuBar(arg1);
44560 wxPyEndAllowThreads(__tstate);
44561 if (PyErr_Occurred()) SWIG_fail;
44562 }
44563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44564 return resultobj;
44565 fail:
44566 return NULL;
44567 }
44568
44569
44570 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44571 PyObject *resultobj = 0;
44572 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44573 wxMenu *arg2 = (wxMenu *) 0 ;
44574 wxString *arg3 = 0 ;
44575 bool result;
44576 void *argp1 = 0 ;
44577 int res1 = 0 ;
44578 void *argp2 = 0 ;
44579 int res2 = 0 ;
44580 bool temp3 = false ;
44581 PyObject * obj0 = 0 ;
44582 PyObject * obj1 = 0 ;
44583 PyObject * obj2 = 0 ;
44584 char * kwnames[] = {
44585 (char *) "self",(char *) "menu",(char *) "title", NULL
44586 };
44587
44588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44590 if (!SWIG_IsOK(res1)) {
44591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44592 }
44593 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44594 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44595 if (!SWIG_IsOK(res2)) {
44596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44597 }
44598 arg2 = reinterpret_cast< wxMenu * >(argp2);
44599 {
44600 arg3 = wxString_in_helper(obj2);
44601 if (arg3 == NULL) SWIG_fail;
44602 temp3 = true;
44603 }
44604 {
44605 PyThreadState* __tstate = wxPyBeginAllowThreads();
44606 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44607 wxPyEndAllowThreads(__tstate);
44608 if (PyErr_Occurred()) SWIG_fail;
44609 }
44610 {
44611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44612 }
44613 {
44614 if (temp3)
44615 delete arg3;
44616 }
44617 return resultobj;
44618 fail:
44619 {
44620 if (temp3)
44621 delete arg3;
44622 }
44623 return NULL;
44624 }
44625
44626
44627 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44628 PyObject *resultobj = 0;
44629 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44630 size_t arg2 ;
44631 wxMenu *arg3 = (wxMenu *) 0 ;
44632 wxString *arg4 = 0 ;
44633 bool result;
44634 void *argp1 = 0 ;
44635 int res1 = 0 ;
44636 size_t val2 ;
44637 int ecode2 = 0 ;
44638 void *argp3 = 0 ;
44639 int res3 = 0 ;
44640 bool temp4 = false ;
44641 PyObject * obj0 = 0 ;
44642 PyObject * obj1 = 0 ;
44643 PyObject * obj2 = 0 ;
44644 PyObject * obj3 = 0 ;
44645 char * kwnames[] = {
44646 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44647 };
44648
44649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44651 if (!SWIG_IsOK(res1)) {
44652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44653 }
44654 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44655 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44656 if (!SWIG_IsOK(ecode2)) {
44657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44658 }
44659 arg2 = static_cast< size_t >(val2);
44660 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44661 if (!SWIG_IsOK(res3)) {
44662 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44663 }
44664 arg3 = reinterpret_cast< wxMenu * >(argp3);
44665 {
44666 arg4 = wxString_in_helper(obj3);
44667 if (arg4 == NULL) SWIG_fail;
44668 temp4 = true;
44669 }
44670 {
44671 PyThreadState* __tstate = wxPyBeginAllowThreads();
44672 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44673 wxPyEndAllowThreads(__tstate);
44674 if (PyErr_Occurred()) SWIG_fail;
44675 }
44676 {
44677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44678 }
44679 {
44680 if (temp4)
44681 delete arg4;
44682 }
44683 return resultobj;
44684 fail:
44685 {
44686 if (temp4)
44687 delete arg4;
44688 }
44689 return NULL;
44690 }
44691
44692
44693 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44694 PyObject *resultobj = 0;
44695 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44696 size_t result;
44697 void *argp1 = 0 ;
44698 int res1 = 0 ;
44699 PyObject *swig_obj[1] ;
44700
44701 if (!args) SWIG_fail;
44702 swig_obj[0] = args;
44703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44704 if (!SWIG_IsOK(res1)) {
44705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44706 }
44707 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44708 {
44709 PyThreadState* __tstate = wxPyBeginAllowThreads();
44710 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44711 wxPyEndAllowThreads(__tstate);
44712 if (PyErr_Occurred()) SWIG_fail;
44713 }
44714 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44715 return resultobj;
44716 fail:
44717 return NULL;
44718 }
44719
44720
44721 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44722 PyObject *resultobj = 0;
44723 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44724 size_t arg2 ;
44725 wxMenu *result = 0 ;
44726 void *argp1 = 0 ;
44727 int res1 = 0 ;
44728 size_t val2 ;
44729 int ecode2 = 0 ;
44730 PyObject * obj0 = 0 ;
44731 PyObject * obj1 = 0 ;
44732 char * kwnames[] = {
44733 (char *) "self",(char *) "pos", NULL
44734 };
44735
44736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44738 if (!SWIG_IsOK(res1)) {
44739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44740 }
44741 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44742 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44743 if (!SWIG_IsOK(ecode2)) {
44744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44745 }
44746 arg2 = static_cast< size_t >(val2);
44747 {
44748 PyThreadState* __tstate = wxPyBeginAllowThreads();
44749 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44750 wxPyEndAllowThreads(__tstate);
44751 if (PyErr_Occurred()) SWIG_fail;
44752 }
44753 {
44754 resultobj = wxPyMake_wxObject(result, 0);
44755 }
44756 return resultobj;
44757 fail:
44758 return NULL;
44759 }
44760
44761
44762 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44763 PyObject *resultobj = 0;
44764 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44765 size_t arg2 ;
44766 wxMenu *arg3 = (wxMenu *) 0 ;
44767 wxString *arg4 = 0 ;
44768 wxMenu *result = 0 ;
44769 void *argp1 = 0 ;
44770 int res1 = 0 ;
44771 size_t val2 ;
44772 int ecode2 = 0 ;
44773 void *argp3 = 0 ;
44774 int res3 = 0 ;
44775 bool temp4 = false ;
44776 PyObject * obj0 = 0 ;
44777 PyObject * obj1 = 0 ;
44778 PyObject * obj2 = 0 ;
44779 PyObject * obj3 = 0 ;
44780 char * kwnames[] = {
44781 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44782 };
44783
44784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44786 if (!SWIG_IsOK(res1)) {
44787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44788 }
44789 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44790 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44791 if (!SWIG_IsOK(ecode2)) {
44792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44793 }
44794 arg2 = static_cast< size_t >(val2);
44795 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44796 if (!SWIG_IsOK(res3)) {
44797 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44798 }
44799 arg3 = reinterpret_cast< wxMenu * >(argp3);
44800 {
44801 arg4 = wxString_in_helper(obj3);
44802 if (arg4 == NULL) SWIG_fail;
44803 temp4 = true;
44804 }
44805 {
44806 PyThreadState* __tstate = wxPyBeginAllowThreads();
44807 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44808 wxPyEndAllowThreads(__tstate);
44809 if (PyErr_Occurred()) SWIG_fail;
44810 }
44811 {
44812 resultobj = wxPyMake_wxObject(result, 0);
44813 }
44814 {
44815 if (temp4)
44816 delete arg4;
44817 }
44818 return resultobj;
44819 fail:
44820 {
44821 if (temp4)
44822 delete arg4;
44823 }
44824 return NULL;
44825 }
44826
44827
44828 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44829 PyObject *resultobj = 0;
44830 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44831 size_t arg2 ;
44832 wxMenu *result = 0 ;
44833 void *argp1 = 0 ;
44834 int res1 = 0 ;
44835 size_t val2 ;
44836 int ecode2 = 0 ;
44837 PyObject * obj0 = 0 ;
44838 PyObject * obj1 = 0 ;
44839 char * kwnames[] = {
44840 (char *) "self",(char *) "pos", NULL
44841 };
44842
44843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44845 if (!SWIG_IsOK(res1)) {
44846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44847 }
44848 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44849 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44850 if (!SWIG_IsOK(ecode2)) {
44851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
44852 }
44853 arg2 = static_cast< size_t >(val2);
44854 {
44855 PyThreadState* __tstate = wxPyBeginAllowThreads();
44856 result = (wxMenu *)(arg1)->Remove(arg2);
44857 wxPyEndAllowThreads(__tstate);
44858 if (PyErr_Occurred()) SWIG_fail;
44859 }
44860 {
44861 resultobj = wxPyMake_wxObject(result, 0);
44862 }
44863 return resultobj;
44864 fail:
44865 return NULL;
44866 }
44867
44868
44869 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44870 PyObject *resultobj = 0;
44871 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44872 size_t arg2 ;
44873 bool arg3 ;
44874 void *argp1 = 0 ;
44875 int res1 = 0 ;
44876 size_t val2 ;
44877 int ecode2 = 0 ;
44878 bool val3 ;
44879 int ecode3 = 0 ;
44880 PyObject * obj0 = 0 ;
44881 PyObject * obj1 = 0 ;
44882 PyObject * obj2 = 0 ;
44883 char * kwnames[] = {
44884 (char *) "self",(char *) "pos",(char *) "enable", NULL
44885 };
44886
44887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44889 if (!SWIG_IsOK(res1)) {
44890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44891 }
44892 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44893 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44894 if (!SWIG_IsOK(ecode2)) {
44895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
44896 }
44897 arg2 = static_cast< size_t >(val2);
44898 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44899 if (!SWIG_IsOK(ecode3)) {
44900 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
44901 }
44902 arg3 = static_cast< bool >(val3);
44903 {
44904 PyThreadState* __tstate = wxPyBeginAllowThreads();
44905 (arg1)->EnableTop(arg2,arg3);
44906 wxPyEndAllowThreads(__tstate);
44907 if (PyErr_Occurred()) SWIG_fail;
44908 }
44909 resultobj = SWIG_Py_Void();
44910 return resultobj;
44911 fail:
44912 return NULL;
44913 }
44914
44915
44916 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44917 PyObject *resultobj = 0;
44918 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44919 size_t arg2 ;
44920 bool result;
44921 void *argp1 = 0 ;
44922 int res1 = 0 ;
44923 size_t val2 ;
44924 int ecode2 = 0 ;
44925 PyObject * obj0 = 0 ;
44926 PyObject * obj1 = 0 ;
44927 char * kwnames[] = {
44928 (char *) "self",(char *) "pos", NULL
44929 };
44930
44931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
44932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44933 if (!SWIG_IsOK(res1)) {
44934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44935 }
44936 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44937 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44938 if (!SWIG_IsOK(ecode2)) {
44939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
44940 }
44941 arg2 = static_cast< size_t >(val2);
44942 {
44943 PyThreadState* __tstate = wxPyBeginAllowThreads();
44944 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
44945 wxPyEndAllowThreads(__tstate);
44946 if (PyErr_Occurred()) SWIG_fail;
44947 }
44948 {
44949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44950 }
44951 return resultobj;
44952 fail:
44953 return NULL;
44954 }
44955
44956
44957 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44958 PyObject *resultobj = 0;
44959 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44960 size_t arg2 ;
44961 wxString *arg3 = 0 ;
44962 void *argp1 = 0 ;
44963 int res1 = 0 ;
44964 size_t val2 ;
44965 int ecode2 = 0 ;
44966 bool temp3 = false ;
44967 PyObject * obj0 = 0 ;
44968 PyObject * obj1 = 0 ;
44969 PyObject * obj2 = 0 ;
44970 char * kwnames[] = {
44971 (char *) "self",(char *) "pos",(char *) "label", NULL
44972 };
44973
44974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44976 if (!SWIG_IsOK(res1)) {
44977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44978 }
44979 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44980 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44981 if (!SWIG_IsOK(ecode2)) {
44982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44983 }
44984 arg2 = static_cast< size_t >(val2);
44985 {
44986 arg3 = wxString_in_helper(obj2);
44987 if (arg3 == NULL) SWIG_fail;
44988 temp3 = true;
44989 }
44990 {
44991 PyThreadState* __tstate = wxPyBeginAllowThreads();
44992 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
44993 wxPyEndAllowThreads(__tstate);
44994 if (PyErr_Occurred()) SWIG_fail;
44995 }
44996 resultobj = SWIG_Py_Void();
44997 {
44998 if (temp3)
44999 delete arg3;
45000 }
45001 return resultobj;
45002 fail:
45003 {
45004 if (temp3)
45005 delete arg3;
45006 }
45007 return NULL;
45008 }
45009
45010
45011 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45012 PyObject *resultobj = 0;
45013 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45014 size_t arg2 ;
45015 wxString result;
45016 void *argp1 = 0 ;
45017 int res1 = 0 ;
45018 size_t val2 ;
45019 int ecode2 = 0 ;
45020 PyObject * obj0 = 0 ;
45021 PyObject * obj1 = 0 ;
45022 char * kwnames[] = {
45023 (char *) "self",(char *) "pos", NULL
45024 };
45025
45026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
45027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45028 if (!SWIG_IsOK(res1)) {
45029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45030 }
45031 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45032 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45033 if (!SWIG_IsOK(ecode2)) {
45034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45035 }
45036 arg2 = static_cast< size_t >(val2);
45037 {
45038 PyThreadState* __tstate = wxPyBeginAllowThreads();
45039 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
45040 wxPyEndAllowThreads(__tstate);
45041 if (PyErr_Occurred()) SWIG_fail;
45042 }
45043 {
45044 #if wxUSE_UNICODE
45045 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45046 #else
45047 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45048 #endif
45049 }
45050 return resultobj;
45051 fail:
45052 return NULL;
45053 }
45054
45055
45056 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45057 PyObject *resultobj = 0;
45058 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45059 wxString *arg2 = 0 ;
45060 wxString *arg3 = 0 ;
45061 int result;
45062 void *argp1 = 0 ;
45063 int res1 = 0 ;
45064 bool temp2 = false ;
45065 bool temp3 = false ;
45066 PyObject * obj0 = 0 ;
45067 PyObject * obj1 = 0 ;
45068 PyObject * obj2 = 0 ;
45069 char * kwnames[] = {
45070 (char *) "self",(char *) "menu",(char *) "item", NULL
45071 };
45072
45073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45075 if (!SWIG_IsOK(res1)) {
45076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45077 }
45078 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45079 {
45080 arg2 = wxString_in_helper(obj1);
45081 if (arg2 == NULL) SWIG_fail;
45082 temp2 = true;
45083 }
45084 {
45085 arg3 = wxString_in_helper(obj2);
45086 if (arg3 == NULL) SWIG_fail;
45087 temp3 = true;
45088 }
45089 {
45090 PyThreadState* __tstate = wxPyBeginAllowThreads();
45091 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
45092 wxPyEndAllowThreads(__tstate);
45093 if (PyErr_Occurred()) SWIG_fail;
45094 }
45095 resultobj = SWIG_From_int(static_cast< int >(result));
45096 {
45097 if (temp2)
45098 delete arg2;
45099 }
45100 {
45101 if (temp3)
45102 delete arg3;
45103 }
45104 return resultobj;
45105 fail:
45106 {
45107 if (temp2)
45108 delete arg2;
45109 }
45110 {
45111 if (temp3)
45112 delete arg3;
45113 }
45114 return NULL;
45115 }
45116
45117
45118 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45119 PyObject *resultobj = 0;
45120 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45121 int arg2 ;
45122 wxMenuItem *result = 0 ;
45123 void *argp1 = 0 ;
45124 int res1 = 0 ;
45125 int val2 ;
45126 int ecode2 = 0 ;
45127 PyObject * obj0 = 0 ;
45128 PyObject * obj1 = 0 ;
45129 char * kwnames[] = {
45130 (char *) "self",(char *) "id", NULL
45131 };
45132
45133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
45134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45135 if (!SWIG_IsOK(res1)) {
45136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45137 }
45138 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45139 ecode2 = SWIG_AsVal_int(obj1, &val2);
45140 if (!SWIG_IsOK(ecode2)) {
45141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
45142 }
45143 arg2 = static_cast< int >(val2);
45144 {
45145 PyThreadState* __tstate = wxPyBeginAllowThreads();
45146 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45147 wxPyEndAllowThreads(__tstate);
45148 if (PyErr_Occurred()) SWIG_fail;
45149 }
45150 {
45151 resultobj = wxPyMake_wxObject(result, (bool)0);
45152 }
45153 return resultobj;
45154 fail:
45155 return NULL;
45156 }
45157
45158
45159 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45160 PyObject *resultobj = 0;
45161 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45162 wxString *arg2 = 0 ;
45163 int result;
45164 void *argp1 = 0 ;
45165 int res1 = 0 ;
45166 bool temp2 = false ;
45167 PyObject * obj0 = 0 ;
45168 PyObject * obj1 = 0 ;
45169 char * kwnames[] = {
45170 (char *) "self",(char *) "title", NULL
45171 };
45172
45173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45175 if (!SWIG_IsOK(res1)) {
45176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45177 }
45178 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45179 {
45180 arg2 = wxString_in_helper(obj1);
45181 if (arg2 == NULL) SWIG_fail;
45182 temp2 = true;
45183 }
45184 {
45185 PyThreadState* __tstate = wxPyBeginAllowThreads();
45186 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45187 wxPyEndAllowThreads(__tstate);
45188 if (PyErr_Occurred()) SWIG_fail;
45189 }
45190 resultobj = SWIG_From_int(static_cast< int >(result));
45191 {
45192 if (temp2)
45193 delete arg2;
45194 }
45195 return resultobj;
45196 fail:
45197 {
45198 if (temp2)
45199 delete arg2;
45200 }
45201 return NULL;
45202 }
45203
45204
45205 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45206 PyObject *resultobj = 0;
45207 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45208 int arg2 ;
45209 bool arg3 ;
45210 void *argp1 = 0 ;
45211 int res1 = 0 ;
45212 int val2 ;
45213 int ecode2 = 0 ;
45214 bool val3 ;
45215 int ecode3 = 0 ;
45216 PyObject * obj0 = 0 ;
45217 PyObject * obj1 = 0 ;
45218 PyObject * obj2 = 0 ;
45219 char * kwnames[] = {
45220 (char *) "self",(char *) "id",(char *) "enable", NULL
45221 };
45222
45223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45225 if (!SWIG_IsOK(res1)) {
45226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45227 }
45228 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45229 ecode2 = SWIG_AsVal_int(obj1, &val2);
45230 if (!SWIG_IsOK(ecode2)) {
45231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45232 }
45233 arg2 = static_cast< int >(val2);
45234 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45235 if (!SWIG_IsOK(ecode3)) {
45236 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45237 }
45238 arg3 = static_cast< bool >(val3);
45239 {
45240 PyThreadState* __tstate = wxPyBeginAllowThreads();
45241 (arg1)->Enable(arg2,arg3);
45242 wxPyEndAllowThreads(__tstate);
45243 if (PyErr_Occurred()) SWIG_fail;
45244 }
45245 resultobj = SWIG_Py_Void();
45246 return resultobj;
45247 fail:
45248 return NULL;
45249 }
45250
45251
45252 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45253 PyObject *resultobj = 0;
45254 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45255 int arg2 ;
45256 bool arg3 ;
45257 void *argp1 = 0 ;
45258 int res1 = 0 ;
45259 int val2 ;
45260 int ecode2 = 0 ;
45261 bool val3 ;
45262 int ecode3 = 0 ;
45263 PyObject * obj0 = 0 ;
45264 PyObject * obj1 = 0 ;
45265 PyObject * obj2 = 0 ;
45266 char * kwnames[] = {
45267 (char *) "self",(char *) "id",(char *) "check", NULL
45268 };
45269
45270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45272 if (!SWIG_IsOK(res1)) {
45273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45274 }
45275 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45276 ecode2 = SWIG_AsVal_int(obj1, &val2);
45277 if (!SWIG_IsOK(ecode2)) {
45278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45279 }
45280 arg2 = static_cast< int >(val2);
45281 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45282 if (!SWIG_IsOK(ecode3)) {
45283 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45284 }
45285 arg3 = static_cast< bool >(val3);
45286 {
45287 PyThreadState* __tstate = wxPyBeginAllowThreads();
45288 (arg1)->Check(arg2,arg3);
45289 wxPyEndAllowThreads(__tstate);
45290 if (PyErr_Occurred()) SWIG_fail;
45291 }
45292 resultobj = SWIG_Py_Void();
45293 return resultobj;
45294 fail:
45295 return NULL;
45296 }
45297
45298
45299 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45300 PyObject *resultobj = 0;
45301 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45302 int arg2 ;
45303 bool result;
45304 void *argp1 = 0 ;
45305 int res1 = 0 ;
45306 int val2 ;
45307 int ecode2 = 0 ;
45308 PyObject * obj0 = 0 ;
45309 PyObject * obj1 = 0 ;
45310 char * kwnames[] = {
45311 (char *) "self",(char *) "id", NULL
45312 };
45313
45314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45316 if (!SWIG_IsOK(res1)) {
45317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45318 }
45319 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45320 ecode2 = SWIG_AsVal_int(obj1, &val2);
45321 if (!SWIG_IsOK(ecode2)) {
45322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45323 }
45324 arg2 = static_cast< int >(val2);
45325 {
45326 PyThreadState* __tstate = wxPyBeginAllowThreads();
45327 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45328 wxPyEndAllowThreads(__tstate);
45329 if (PyErr_Occurred()) SWIG_fail;
45330 }
45331 {
45332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45333 }
45334 return resultobj;
45335 fail:
45336 return NULL;
45337 }
45338
45339
45340 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45341 PyObject *resultobj = 0;
45342 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45343 int arg2 ;
45344 bool result;
45345 void *argp1 = 0 ;
45346 int res1 = 0 ;
45347 int val2 ;
45348 int ecode2 = 0 ;
45349 PyObject * obj0 = 0 ;
45350 PyObject * obj1 = 0 ;
45351 char * kwnames[] = {
45352 (char *) "self",(char *) "id", NULL
45353 };
45354
45355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45357 if (!SWIG_IsOK(res1)) {
45358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45359 }
45360 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45361 ecode2 = SWIG_AsVal_int(obj1, &val2);
45362 if (!SWIG_IsOK(ecode2)) {
45363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45364 }
45365 arg2 = static_cast< int >(val2);
45366 {
45367 PyThreadState* __tstate = wxPyBeginAllowThreads();
45368 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45369 wxPyEndAllowThreads(__tstate);
45370 if (PyErr_Occurred()) SWIG_fail;
45371 }
45372 {
45373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45374 }
45375 return resultobj;
45376 fail:
45377 return NULL;
45378 }
45379
45380
45381 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45382 PyObject *resultobj = 0;
45383 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45384 int arg2 ;
45385 wxString *arg3 = 0 ;
45386 void *argp1 = 0 ;
45387 int res1 = 0 ;
45388 int val2 ;
45389 int ecode2 = 0 ;
45390 bool temp3 = false ;
45391 PyObject * obj0 = 0 ;
45392 PyObject * obj1 = 0 ;
45393 PyObject * obj2 = 0 ;
45394 char * kwnames[] = {
45395 (char *) "self",(char *) "id",(char *) "label", NULL
45396 };
45397
45398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45400 if (!SWIG_IsOK(res1)) {
45401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45402 }
45403 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45404 ecode2 = SWIG_AsVal_int(obj1, &val2);
45405 if (!SWIG_IsOK(ecode2)) {
45406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45407 }
45408 arg2 = static_cast< int >(val2);
45409 {
45410 arg3 = wxString_in_helper(obj2);
45411 if (arg3 == NULL) SWIG_fail;
45412 temp3 = true;
45413 }
45414 {
45415 PyThreadState* __tstate = wxPyBeginAllowThreads();
45416 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45417 wxPyEndAllowThreads(__tstate);
45418 if (PyErr_Occurred()) SWIG_fail;
45419 }
45420 resultobj = SWIG_Py_Void();
45421 {
45422 if (temp3)
45423 delete arg3;
45424 }
45425 return resultobj;
45426 fail:
45427 {
45428 if (temp3)
45429 delete arg3;
45430 }
45431 return NULL;
45432 }
45433
45434
45435 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45436 PyObject *resultobj = 0;
45437 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45438 int arg2 ;
45439 wxString result;
45440 void *argp1 = 0 ;
45441 int res1 = 0 ;
45442 int val2 ;
45443 int ecode2 = 0 ;
45444 PyObject * obj0 = 0 ;
45445 PyObject * obj1 = 0 ;
45446 char * kwnames[] = {
45447 (char *) "self",(char *) "id", NULL
45448 };
45449
45450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45452 if (!SWIG_IsOK(res1)) {
45453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45454 }
45455 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45456 ecode2 = SWIG_AsVal_int(obj1, &val2);
45457 if (!SWIG_IsOK(ecode2)) {
45458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45459 }
45460 arg2 = static_cast< int >(val2);
45461 {
45462 PyThreadState* __tstate = wxPyBeginAllowThreads();
45463 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45464 wxPyEndAllowThreads(__tstate);
45465 if (PyErr_Occurred()) SWIG_fail;
45466 }
45467 {
45468 #if wxUSE_UNICODE
45469 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45470 #else
45471 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45472 #endif
45473 }
45474 return resultobj;
45475 fail:
45476 return NULL;
45477 }
45478
45479
45480 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45481 PyObject *resultobj = 0;
45482 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45483 int arg2 ;
45484 wxString *arg3 = 0 ;
45485 void *argp1 = 0 ;
45486 int res1 = 0 ;
45487 int val2 ;
45488 int ecode2 = 0 ;
45489 bool temp3 = false ;
45490 PyObject * obj0 = 0 ;
45491 PyObject * obj1 = 0 ;
45492 PyObject * obj2 = 0 ;
45493 char * kwnames[] = {
45494 (char *) "self",(char *) "id",(char *) "helpString", NULL
45495 };
45496
45497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45499 if (!SWIG_IsOK(res1)) {
45500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45501 }
45502 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45503 ecode2 = SWIG_AsVal_int(obj1, &val2);
45504 if (!SWIG_IsOK(ecode2)) {
45505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45506 }
45507 arg2 = static_cast< int >(val2);
45508 {
45509 arg3 = wxString_in_helper(obj2);
45510 if (arg3 == NULL) SWIG_fail;
45511 temp3 = true;
45512 }
45513 {
45514 PyThreadState* __tstate = wxPyBeginAllowThreads();
45515 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45516 wxPyEndAllowThreads(__tstate);
45517 if (PyErr_Occurred()) SWIG_fail;
45518 }
45519 resultobj = SWIG_Py_Void();
45520 {
45521 if (temp3)
45522 delete arg3;
45523 }
45524 return resultobj;
45525 fail:
45526 {
45527 if (temp3)
45528 delete arg3;
45529 }
45530 return NULL;
45531 }
45532
45533
45534 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45535 PyObject *resultobj = 0;
45536 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45537 int arg2 ;
45538 wxString result;
45539 void *argp1 = 0 ;
45540 int res1 = 0 ;
45541 int val2 ;
45542 int ecode2 = 0 ;
45543 PyObject * obj0 = 0 ;
45544 PyObject * obj1 = 0 ;
45545 char * kwnames[] = {
45546 (char *) "self",(char *) "id", NULL
45547 };
45548
45549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45551 if (!SWIG_IsOK(res1)) {
45552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45553 }
45554 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45555 ecode2 = SWIG_AsVal_int(obj1, &val2);
45556 if (!SWIG_IsOK(ecode2)) {
45557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45558 }
45559 arg2 = static_cast< int >(val2);
45560 {
45561 PyThreadState* __tstate = wxPyBeginAllowThreads();
45562 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45563 wxPyEndAllowThreads(__tstate);
45564 if (PyErr_Occurred()) SWIG_fail;
45565 }
45566 {
45567 #if wxUSE_UNICODE
45568 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45569 #else
45570 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45571 #endif
45572 }
45573 return resultobj;
45574 fail:
45575 return NULL;
45576 }
45577
45578
45579 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45580 PyObject *resultobj = 0;
45581 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45582 wxFrame *result = 0 ;
45583 void *argp1 = 0 ;
45584 int res1 = 0 ;
45585 PyObject *swig_obj[1] ;
45586
45587 if (!args) SWIG_fail;
45588 swig_obj[0] = args;
45589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45590 if (!SWIG_IsOK(res1)) {
45591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45592 }
45593 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45594 {
45595 PyThreadState* __tstate = wxPyBeginAllowThreads();
45596 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45597 wxPyEndAllowThreads(__tstate);
45598 if (PyErr_Occurred()) SWIG_fail;
45599 }
45600 {
45601 resultobj = wxPyMake_wxObject(result, (bool)0);
45602 }
45603 return resultobj;
45604 fail:
45605 return NULL;
45606 }
45607
45608
45609 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45610 PyObject *resultobj = 0;
45611 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45612 bool result;
45613 void *argp1 = 0 ;
45614 int res1 = 0 ;
45615 PyObject *swig_obj[1] ;
45616
45617 if (!args) SWIG_fail;
45618 swig_obj[0] = args;
45619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45620 if (!SWIG_IsOK(res1)) {
45621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45622 }
45623 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45624 {
45625 PyThreadState* __tstate = wxPyBeginAllowThreads();
45626 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45627 wxPyEndAllowThreads(__tstate);
45628 if (PyErr_Occurred()) SWIG_fail;
45629 }
45630 {
45631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45632 }
45633 return resultobj;
45634 fail:
45635 return NULL;
45636 }
45637
45638
45639 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45640 PyObject *resultobj = 0;
45641 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45642 wxFrame *arg2 = (wxFrame *) 0 ;
45643 void *argp1 = 0 ;
45644 int res1 = 0 ;
45645 void *argp2 = 0 ;
45646 int res2 = 0 ;
45647 PyObject * obj0 = 0 ;
45648 PyObject * obj1 = 0 ;
45649 char * kwnames[] = {
45650 (char *) "self",(char *) "frame", NULL
45651 };
45652
45653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45655 if (!SWIG_IsOK(res1)) {
45656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45657 }
45658 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45659 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45660 if (!SWIG_IsOK(res2)) {
45661 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45662 }
45663 arg2 = reinterpret_cast< wxFrame * >(argp2);
45664 {
45665 PyThreadState* __tstate = wxPyBeginAllowThreads();
45666 (arg1)->Attach(arg2);
45667 wxPyEndAllowThreads(__tstate);
45668 if (PyErr_Occurred()) SWIG_fail;
45669 }
45670 resultobj = SWIG_Py_Void();
45671 return resultobj;
45672 fail:
45673 return NULL;
45674 }
45675
45676
45677 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45678 PyObject *resultobj = 0;
45679 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45680 void *argp1 = 0 ;
45681 int res1 = 0 ;
45682 PyObject *swig_obj[1] ;
45683
45684 if (!args) SWIG_fail;
45685 swig_obj[0] = args;
45686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45687 if (!SWIG_IsOK(res1)) {
45688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45689 }
45690 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45691 {
45692 PyThreadState* __tstate = wxPyBeginAllowThreads();
45693 (arg1)->Detach();
45694 wxPyEndAllowThreads(__tstate);
45695 if (PyErr_Occurred()) SWIG_fail;
45696 }
45697 resultobj = SWIG_Py_Void();
45698 return resultobj;
45699 fail:
45700 return NULL;
45701 }
45702
45703
45704 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45705 PyObject *resultobj = 0;
45706 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45707 void *argp1 = 0 ;
45708 int res1 = 0 ;
45709 PyObject *swig_obj[1] ;
45710
45711 if (!args) SWIG_fail;
45712 swig_obj[0] = args;
45713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45714 if (!SWIG_IsOK(res1)) {
45715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45716 }
45717 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45718 {
45719 PyThreadState* __tstate = wxPyBeginAllowThreads();
45720 (arg1)->UpdateMenus();
45721 wxPyEndAllowThreads(__tstate);
45722 if (PyErr_Occurred()) SWIG_fail;
45723 }
45724 resultobj = SWIG_Py_Void();
45725 return resultobj;
45726 fail:
45727 return NULL;
45728 }
45729
45730
45731 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45732 PyObject *resultobj = 0;
45733 bool arg1 ;
45734 bool val1 ;
45735 int ecode1 = 0 ;
45736 PyObject * obj0 = 0 ;
45737 char * kwnames[] = {
45738 (char *) "enable", NULL
45739 };
45740
45741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45742 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45743 if (!SWIG_IsOK(ecode1)) {
45744 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45745 }
45746 arg1 = static_cast< bool >(val1);
45747 {
45748 PyThreadState* __tstate = wxPyBeginAllowThreads();
45749 wxMenuBar_SetAutoWindowMenu(arg1);
45750 wxPyEndAllowThreads(__tstate);
45751 if (PyErr_Occurred()) SWIG_fail;
45752 }
45753 resultobj = SWIG_Py_Void();
45754 return resultobj;
45755 fail:
45756 return NULL;
45757 }
45758
45759
45760 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45761 PyObject *resultobj = 0;
45762 bool result;
45763
45764 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45765 {
45766 PyThreadState* __tstate = wxPyBeginAllowThreads();
45767 result = (bool)wxMenuBar_GetAutoWindowMenu();
45768 wxPyEndAllowThreads(__tstate);
45769 if (PyErr_Occurred()) SWIG_fail;
45770 }
45771 {
45772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45773 }
45774 return resultobj;
45775 fail:
45776 return NULL;
45777 }
45778
45779
45780 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45781 PyObject *obj;
45782 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45783 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45784 return SWIG_Py_Void();
45785 }
45786
45787 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45788 return SWIG_Python_InitShadowInstance(args);
45789 }
45790
45791 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45792 PyObject *resultobj = 0;
45793 wxMenu *arg1 = (wxMenu *) NULL ;
45794 int arg2 = (int) wxID_SEPARATOR ;
45795 wxString const &arg3_defvalue = wxPyEmptyString ;
45796 wxString *arg3 = (wxString *) &arg3_defvalue ;
45797 wxString const &arg4_defvalue = wxPyEmptyString ;
45798 wxString *arg4 = (wxString *) &arg4_defvalue ;
45799 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45800 wxMenu *arg6 = (wxMenu *) NULL ;
45801 wxMenuItem *result = 0 ;
45802 void *argp1 = 0 ;
45803 int res1 = 0 ;
45804 int val2 ;
45805 int ecode2 = 0 ;
45806 bool temp3 = false ;
45807 bool temp4 = false ;
45808 int val5 ;
45809 int ecode5 = 0 ;
45810 void *argp6 = 0 ;
45811 int res6 = 0 ;
45812 PyObject * obj0 = 0 ;
45813 PyObject * obj1 = 0 ;
45814 PyObject * obj2 = 0 ;
45815 PyObject * obj3 = 0 ;
45816 PyObject * obj4 = 0 ;
45817 PyObject * obj5 = 0 ;
45818 char * kwnames[] = {
45819 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45820 };
45821
45822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45823 if (obj0) {
45824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45825 if (!SWIG_IsOK(res1)) {
45826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
45827 }
45828 arg1 = reinterpret_cast< wxMenu * >(argp1);
45829 }
45830 if (obj1) {
45831 ecode2 = SWIG_AsVal_int(obj1, &val2);
45832 if (!SWIG_IsOK(ecode2)) {
45833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45834 }
45835 arg2 = static_cast< int >(val2);
45836 }
45837 if (obj2) {
45838 {
45839 arg3 = wxString_in_helper(obj2);
45840 if (arg3 == NULL) SWIG_fail;
45841 temp3 = true;
45842 }
45843 }
45844 if (obj3) {
45845 {
45846 arg4 = wxString_in_helper(obj3);
45847 if (arg4 == NULL) SWIG_fail;
45848 temp4 = true;
45849 }
45850 }
45851 if (obj4) {
45852 ecode5 = SWIG_AsVal_int(obj4, &val5);
45853 if (!SWIG_IsOK(ecode5)) {
45854 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
45855 }
45856 arg5 = static_cast< wxItemKind >(val5);
45857 }
45858 if (obj5) {
45859 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
45860 if (!SWIG_IsOK(res6)) {
45861 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
45862 }
45863 arg6 = reinterpret_cast< wxMenu * >(argp6);
45864 }
45865 {
45866 PyThreadState* __tstate = wxPyBeginAllowThreads();
45867 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
45868 wxPyEndAllowThreads(__tstate);
45869 if (PyErr_Occurred()) SWIG_fail;
45870 }
45871 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
45872 {
45873 if (temp3)
45874 delete arg3;
45875 }
45876 {
45877 if (temp4)
45878 delete arg4;
45879 }
45880 return resultobj;
45881 fail:
45882 {
45883 if (temp3)
45884 delete arg3;
45885 }
45886 {
45887 if (temp4)
45888 delete arg4;
45889 }
45890 return NULL;
45891 }
45892
45893
45894 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45895 PyObject *resultobj = 0;
45896 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45897 void *argp1 = 0 ;
45898 int res1 = 0 ;
45899 PyObject *swig_obj[1] ;
45900
45901 if (!args) SWIG_fail;
45902 swig_obj[0] = args;
45903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
45904 if (!SWIG_IsOK(res1)) {
45905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45906 }
45907 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45908 {
45909 PyThreadState* __tstate = wxPyBeginAllowThreads();
45910 delete arg1;
45911
45912 wxPyEndAllowThreads(__tstate);
45913 if (PyErr_Occurred()) SWIG_fail;
45914 }
45915 resultobj = SWIG_Py_Void();
45916 return resultobj;
45917 fail:
45918 return NULL;
45919 }
45920
45921
45922 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45923 PyObject *resultobj = 0;
45924 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45925 wxMenu *result = 0 ;
45926 void *argp1 = 0 ;
45927 int res1 = 0 ;
45928 PyObject *swig_obj[1] ;
45929
45930 if (!args) SWIG_fail;
45931 swig_obj[0] = args;
45932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45933 if (!SWIG_IsOK(res1)) {
45934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45935 }
45936 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45937 {
45938 PyThreadState* __tstate = wxPyBeginAllowThreads();
45939 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
45940 wxPyEndAllowThreads(__tstate);
45941 if (PyErr_Occurred()) SWIG_fail;
45942 }
45943 {
45944 resultobj = wxPyMake_wxObject(result, 0);
45945 }
45946 return resultobj;
45947 fail:
45948 return NULL;
45949 }
45950
45951
45952 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45953 PyObject *resultobj = 0;
45954 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45955 wxMenu *arg2 = (wxMenu *) 0 ;
45956 void *argp1 = 0 ;
45957 int res1 = 0 ;
45958 void *argp2 = 0 ;
45959 int res2 = 0 ;
45960 PyObject * obj0 = 0 ;
45961 PyObject * obj1 = 0 ;
45962 char * kwnames[] = {
45963 (char *) "self",(char *) "menu", NULL
45964 };
45965
45966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45968 if (!SWIG_IsOK(res1)) {
45969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45970 }
45971 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45972 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45973 if (!SWIG_IsOK(res2)) {
45974 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
45975 }
45976 arg2 = reinterpret_cast< wxMenu * >(argp2);
45977 {
45978 PyThreadState* __tstate = wxPyBeginAllowThreads();
45979 (arg1)->SetMenu(arg2);
45980 wxPyEndAllowThreads(__tstate);
45981 if (PyErr_Occurred()) SWIG_fail;
45982 }
45983 resultobj = SWIG_Py_Void();
45984 return resultobj;
45985 fail:
45986 return NULL;
45987 }
45988
45989
45990 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45991 PyObject *resultobj = 0;
45992 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45993 int arg2 ;
45994 void *argp1 = 0 ;
45995 int res1 = 0 ;
45996 int val2 ;
45997 int ecode2 = 0 ;
45998 PyObject * obj0 = 0 ;
45999 PyObject * obj1 = 0 ;
46000 char * kwnames[] = {
46001 (char *) "self",(char *) "id", NULL
46002 };
46003
46004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
46005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46006 if (!SWIG_IsOK(res1)) {
46007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46008 }
46009 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46010 ecode2 = SWIG_AsVal_int(obj1, &val2);
46011 if (!SWIG_IsOK(ecode2)) {
46012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
46013 }
46014 arg2 = static_cast< int >(val2);
46015 {
46016 PyThreadState* __tstate = wxPyBeginAllowThreads();
46017 (arg1)->SetId(arg2);
46018 wxPyEndAllowThreads(__tstate);
46019 if (PyErr_Occurred()) SWIG_fail;
46020 }
46021 resultobj = SWIG_Py_Void();
46022 return resultobj;
46023 fail:
46024 return NULL;
46025 }
46026
46027
46028 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46029 PyObject *resultobj = 0;
46030 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46031 int result;
46032 void *argp1 = 0 ;
46033 int res1 = 0 ;
46034 PyObject *swig_obj[1] ;
46035
46036 if (!args) SWIG_fail;
46037 swig_obj[0] = args;
46038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46039 if (!SWIG_IsOK(res1)) {
46040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46041 }
46042 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46043 {
46044 PyThreadState* __tstate = wxPyBeginAllowThreads();
46045 result = (int)((wxMenuItem const *)arg1)->GetId();
46046 wxPyEndAllowThreads(__tstate);
46047 if (PyErr_Occurred()) SWIG_fail;
46048 }
46049 resultobj = SWIG_From_int(static_cast< int >(result));
46050 return resultobj;
46051 fail:
46052 return NULL;
46053 }
46054
46055
46056 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46057 PyObject *resultobj = 0;
46058 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46059 bool result;
46060 void *argp1 = 0 ;
46061 int res1 = 0 ;
46062 PyObject *swig_obj[1] ;
46063
46064 if (!args) SWIG_fail;
46065 swig_obj[0] = args;
46066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46067 if (!SWIG_IsOK(res1)) {
46068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46069 }
46070 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46071 {
46072 PyThreadState* __tstate = wxPyBeginAllowThreads();
46073 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
46074 wxPyEndAllowThreads(__tstate);
46075 if (PyErr_Occurred()) SWIG_fail;
46076 }
46077 {
46078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46079 }
46080 return resultobj;
46081 fail:
46082 return NULL;
46083 }
46084
46085
46086 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46087 PyObject *resultobj = 0;
46088 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46089 wxString *arg2 = 0 ;
46090 void *argp1 = 0 ;
46091 int res1 = 0 ;
46092 bool temp2 = false ;
46093 PyObject * obj0 = 0 ;
46094 PyObject * obj1 = 0 ;
46095 char * kwnames[] = {
46096 (char *) "self",(char *) "str", NULL
46097 };
46098
46099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
46100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46101 if (!SWIG_IsOK(res1)) {
46102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46103 }
46104 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46105 {
46106 arg2 = wxString_in_helper(obj1);
46107 if (arg2 == NULL) SWIG_fail;
46108 temp2 = true;
46109 }
46110 {
46111 PyThreadState* __tstate = wxPyBeginAllowThreads();
46112 (arg1)->SetText((wxString const &)*arg2);
46113 wxPyEndAllowThreads(__tstate);
46114 if (PyErr_Occurred()) SWIG_fail;
46115 }
46116 resultobj = SWIG_Py_Void();
46117 {
46118 if (temp2)
46119 delete arg2;
46120 }
46121 return resultobj;
46122 fail:
46123 {
46124 if (temp2)
46125 delete arg2;
46126 }
46127 return NULL;
46128 }
46129
46130
46131 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46132 PyObject *resultobj = 0;
46133 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46134 wxString result;
46135 void *argp1 = 0 ;
46136 int res1 = 0 ;
46137 PyObject *swig_obj[1] ;
46138
46139 if (!args) SWIG_fail;
46140 swig_obj[0] = args;
46141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46142 if (!SWIG_IsOK(res1)) {
46143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46144 }
46145 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46146 {
46147 PyThreadState* __tstate = wxPyBeginAllowThreads();
46148 result = ((wxMenuItem const *)arg1)->GetLabel();
46149 wxPyEndAllowThreads(__tstate);
46150 if (PyErr_Occurred()) SWIG_fail;
46151 }
46152 {
46153 #if wxUSE_UNICODE
46154 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46155 #else
46156 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46157 #endif
46158 }
46159 return resultobj;
46160 fail:
46161 return NULL;
46162 }
46163
46164
46165 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46166 PyObject *resultobj = 0;
46167 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46168 wxString *result = 0 ;
46169 void *argp1 = 0 ;
46170 int res1 = 0 ;
46171 PyObject *swig_obj[1] ;
46172
46173 if (!args) SWIG_fail;
46174 swig_obj[0] = args;
46175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46176 if (!SWIG_IsOK(res1)) {
46177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46178 }
46179 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46180 {
46181 PyThreadState* __tstate = wxPyBeginAllowThreads();
46182 {
46183 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46184 result = (wxString *) &_result_ref;
46185 }
46186 wxPyEndAllowThreads(__tstate);
46187 if (PyErr_Occurred()) SWIG_fail;
46188 }
46189 {
46190 #if wxUSE_UNICODE
46191 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46192 #else
46193 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46194 #endif
46195 }
46196 return resultobj;
46197 fail:
46198 return NULL;
46199 }
46200
46201
46202 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46203 PyObject *resultobj = 0;
46204 wxString *arg1 = 0 ;
46205 wxString result;
46206 bool temp1 = false ;
46207 PyObject * obj0 = 0 ;
46208 char * kwnames[] = {
46209 (char *) "text", NULL
46210 };
46211
46212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46213 {
46214 arg1 = wxString_in_helper(obj0);
46215 if (arg1 == NULL) SWIG_fail;
46216 temp1 = true;
46217 }
46218 {
46219 PyThreadState* __tstate = wxPyBeginAllowThreads();
46220 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46221 wxPyEndAllowThreads(__tstate);
46222 if (PyErr_Occurred()) SWIG_fail;
46223 }
46224 {
46225 #if wxUSE_UNICODE
46226 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46227 #else
46228 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46229 #endif
46230 }
46231 {
46232 if (temp1)
46233 delete arg1;
46234 }
46235 return resultobj;
46236 fail:
46237 {
46238 if (temp1)
46239 delete arg1;
46240 }
46241 return NULL;
46242 }
46243
46244
46245 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46246 PyObject *resultobj = 0;
46247 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46248 wxItemKind result;
46249 void *argp1 = 0 ;
46250 int res1 = 0 ;
46251 PyObject *swig_obj[1] ;
46252
46253 if (!args) SWIG_fail;
46254 swig_obj[0] = args;
46255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46256 if (!SWIG_IsOK(res1)) {
46257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46258 }
46259 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46260 {
46261 PyThreadState* __tstate = wxPyBeginAllowThreads();
46262 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46263 wxPyEndAllowThreads(__tstate);
46264 if (PyErr_Occurred()) SWIG_fail;
46265 }
46266 resultobj = SWIG_From_int(static_cast< int >(result));
46267 return resultobj;
46268 fail:
46269 return NULL;
46270 }
46271
46272
46273 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46274 PyObject *resultobj = 0;
46275 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46276 wxItemKind arg2 ;
46277 void *argp1 = 0 ;
46278 int res1 = 0 ;
46279 int val2 ;
46280 int ecode2 = 0 ;
46281 PyObject * obj0 = 0 ;
46282 PyObject * obj1 = 0 ;
46283 char * kwnames[] = {
46284 (char *) "self",(char *) "kind", NULL
46285 };
46286
46287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46289 if (!SWIG_IsOK(res1)) {
46290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46291 }
46292 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46293 ecode2 = SWIG_AsVal_int(obj1, &val2);
46294 if (!SWIG_IsOK(ecode2)) {
46295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46296 }
46297 arg2 = static_cast< wxItemKind >(val2);
46298 {
46299 PyThreadState* __tstate = wxPyBeginAllowThreads();
46300 (arg1)->SetKind(arg2);
46301 wxPyEndAllowThreads(__tstate);
46302 if (PyErr_Occurred()) SWIG_fail;
46303 }
46304 resultobj = SWIG_Py_Void();
46305 return resultobj;
46306 fail:
46307 return NULL;
46308 }
46309
46310
46311 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46312 PyObject *resultobj = 0;
46313 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46314 bool arg2 ;
46315 void *argp1 = 0 ;
46316 int res1 = 0 ;
46317 bool val2 ;
46318 int ecode2 = 0 ;
46319 PyObject * obj0 = 0 ;
46320 PyObject * obj1 = 0 ;
46321 char * kwnames[] = {
46322 (char *) "self",(char *) "checkable", NULL
46323 };
46324
46325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46327 if (!SWIG_IsOK(res1)) {
46328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46329 }
46330 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46331 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46332 if (!SWIG_IsOK(ecode2)) {
46333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46334 }
46335 arg2 = static_cast< bool >(val2);
46336 {
46337 PyThreadState* __tstate = wxPyBeginAllowThreads();
46338 (arg1)->SetCheckable(arg2);
46339 wxPyEndAllowThreads(__tstate);
46340 if (PyErr_Occurred()) SWIG_fail;
46341 }
46342 resultobj = SWIG_Py_Void();
46343 return resultobj;
46344 fail:
46345 return NULL;
46346 }
46347
46348
46349 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46350 PyObject *resultobj = 0;
46351 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46352 bool result;
46353 void *argp1 = 0 ;
46354 int res1 = 0 ;
46355 PyObject *swig_obj[1] ;
46356
46357 if (!args) SWIG_fail;
46358 swig_obj[0] = args;
46359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46360 if (!SWIG_IsOK(res1)) {
46361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46362 }
46363 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46364 {
46365 PyThreadState* __tstate = wxPyBeginAllowThreads();
46366 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46367 wxPyEndAllowThreads(__tstate);
46368 if (PyErr_Occurred()) SWIG_fail;
46369 }
46370 {
46371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46372 }
46373 return resultobj;
46374 fail:
46375 return NULL;
46376 }
46377
46378
46379 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46380 PyObject *resultobj = 0;
46381 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46382 bool result;
46383 void *argp1 = 0 ;
46384 int res1 = 0 ;
46385 PyObject *swig_obj[1] ;
46386
46387 if (!args) SWIG_fail;
46388 swig_obj[0] = args;
46389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46390 if (!SWIG_IsOK(res1)) {
46391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46392 }
46393 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46394 {
46395 PyThreadState* __tstate = wxPyBeginAllowThreads();
46396 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46397 wxPyEndAllowThreads(__tstate);
46398 if (PyErr_Occurred()) SWIG_fail;
46399 }
46400 {
46401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46402 }
46403 return resultobj;
46404 fail:
46405 return NULL;
46406 }
46407
46408
46409 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46410 PyObject *resultobj = 0;
46411 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46412 wxMenu *arg2 = (wxMenu *) 0 ;
46413 void *argp1 = 0 ;
46414 int res1 = 0 ;
46415 void *argp2 = 0 ;
46416 int res2 = 0 ;
46417 PyObject * obj0 = 0 ;
46418 PyObject * obj1 = 0 ;
46419 char * kwnames[] = {
46420 (char *) "self",(char *) "menu", NULL
46421 };
46422
46423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46425 if (!SWIG_IsOK(res1)) {
46426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46427 }
46428 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46429 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46430 if (!SWIG_IsOK(res2)) {
46431 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46432 }
46433 arg2 = reinterpret_cast< wxMenu * >(argp2);
46434 {
46435 PyThreadState* __tstate = wxPyBeginAllowThreads();
46436 (arg1)->SetSubMenu(arg2);
46437 wxPyEndAllowThreads(__tstate);
46438 if (PyErr_Occurred()) SWIG_fail;
46439 }
46440 resultobj = SWIG_Py_Void();
46441 return resultobj;
46442 fail:
46443 return NULL;
46444 }
46445
46446
46447 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46448 PyObject *resultobj = 0;
46449 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46450 wxMenu *result = 0 ;
46451 void *argp1 = 0 ;
46452 int res1 = 0 ;
46453 PyObject *swig_obj[1] ;
46454
46455 if (!args) SWIG_fail;
46456 swig_obj[0] = args;
46457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46458 if (!SWIG_IsOK(res1)) {
46459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46460 }
46461 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46462 {
46463 PyThreadState* __tstate = wxPyBeginAllowThreads();
46464 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46465 wxPyEndAllowThreads(__tstate);
46466 if (PyErr_Occurred()) SWIG_fail;
46467 }
46468 {
46469 resultobj = wxPyMake_wxObject(result, 0);
46470 }
46471 return resultobj;
46472 fail:
46473 return NULL;
46474 }
46475
46476
46477 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46478 PyObject *resultobj = 0;
46479 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46480 bool arg2 = (bool) true ;
46481 void *argp1 = 0 ;
46482 int res1 = 0 ;
46483 bool val2 ;
46484 int ecode2 = 0 ;
46485 PyObject * obj0 = 0 ;
46486 PyObject * obj1 = 0 ;
46487 char * kwnames[] = {
46488 (char *) "self",(char *) "enable", NULL
46489 };
46490
46491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46493 if (!SWIG_IsOK(res1)) {
46494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46495 }
46496 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46497 if (obj1) {
46498 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46499 if (!SWIG_IsOK(ecode2)) {
46500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46501 }
46502 arg2 = static_cast< bool >(val2);
46503 }
46504 {
46505 PyThreadState* __tstate = wxPyBeginAllowThreads();
46506 (arg1)->Enable(arg2);
46507 wxPyEndAllowThreads(__tstate);
46508 if (PyErr_Occurred()) SWIG_fail;
46509 }
46510 resultobj = SWIG_Py_Void();
46511 return resultobj;
46512 fail:
46513 return NULL;
46514 }
46515
46516
46517 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46518 PyObject *resultobj = 0;
46519 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46520 bool result;
46521 void *argp1 = 0 ;
46522 int res1 = 0 ;
46523 PyObject *swig_obj[1] ;
46524
46525 if (!args) SWIG_fail;
46526 swig_obj[0] = args;
46527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46528 if (!SWIG_IsOK(res1)) {
46529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46530 }
46531 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46532 {
46533 PyThreadState* __tstate = wxPyBeginAllowThreads();
46534 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46535 wxPyEndAllowThreads(__tstate);
46536 if (PyErr_Occurred()) SWIG_fail;
46537 }
46538 {
46539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46540 }
46541 return resultobj;
46542 fail:
46543 return NULL;
46544 }
46545
46546
46547 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46548 PyObject *resultobj = 0;
46549 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46550 bool arg2 = (bool) true ;
46551 void *argp1 = 0 ;
46552 int res1 = 0 ;
46553 bool val2 ;
46554 int ecode2 = 0 ;
46555 PyObject * obj0 = 0 ;
46556 PyObject * obj1 = 0 ;
46557 char * kwnames[] = {
46558 (char *) "self",(char *) "check", NULL
46559 };
46560
46561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46563 if (!SWIG_IsOK(res1)) {
46564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46565 }
46566 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46567 if (obj1) {
46568 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46569 if (!SWIG_IsOK(ecode2)) {
46570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46571 }
46572 arg2 = static_cast< bool >(val2);
46573 }
46574 {
46575 PyThreadState* __tstate = wxPyBeginAllowThreads();
46576 (arg1)->Check(arg2);
46577 wxPyEndAllowThreads(__tstate);
46578 if (PyErr_Occurred()) SWIG_fail;
46579 }
46580 resultobj = SWIG_Py_Void();
46581 return resultobj;
46582 fail:
46583 return NULL;
46584 }
46585
46586
46587 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46588 PyObject *resultobj = 0;
46589 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46590 bool result;
46591 void *argp1 = 0 ;
46592 int res1 = 0 ;
46593 PyObject *swig_obj[1] ;
46594
46595 if (!args) SWIG_fail;
46596 swig_obj[0] = args;
46597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46598 if (!SWIG_IsOK(res1)) {
46599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46600 }
46601 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46602 {
46603 PyThreadState* __tstate = wxPyBeginAllowThreads();
46604 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46605 wxPyEndAllowThreads(__tstate);
46606 if (PyErr_Occurred()) SWIG_fail;
46607 }
46608 {
46609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46610 }
46611 return resultobj;
46612 fail:
46613 return NULL;
46614 }
46615
46616
46617 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46618 PyObject *resultobj = 0;
46619 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46620 void *argp1 = 0 ;
46621 int res1 = 0 ;
46622 PyObject *swig_obj[1] ;
46623
46624 if (!args) SWIG_fail;
46625 swig_obj[0] = args;
46626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46627 if (!SWIG_IsOK(res1)) {
46628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46629 }
46630 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46631 {
46632 PyThreadState* __tstate = wxPyBeginAllowThreads();
46633 (arg1)->Toggle();
46634 wxPyEndAllowThreads(__tstate);
46635 if (PyErr_Occurred()) SWIG_fail;
46636 }
46637 resultobj = SWIG_Py_Void();
46638 return resultobj;
46639 fail:
46640 return NULL;
46641 }
46642
46643
46644 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46645 PyObject *resultobj = 0;
46646 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46647 wxString *arg2 = 0 ;
46648 void *argp1 = 0 ;
46649 int res1 = 0 ;
46650 bool temp2 = false ;
46651 PyObject * obj0 = 0 ;
46652 PyObject * obj1 = 0 ;
46653 char * kwnames[] = {
46654 (char *) "self",(char *) "str", NULL
46655 };
46656
46657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46659 if (!SWIG_IsOK(res1)) {
46660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46661 }
46662 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46663 {
46664 arg2 = wxString_in_helper(obj1);
46665 if (arg2 == NULL) SWIG_fail;
46666 temp2 = true;
46667 }
46668 {
46669 PyThreadState* __tstate = wxPyBeginAllowThreads();
46670 (arg1)->SetHelp((wxString const &)*arg2);
46671 wxPyEndAllowThreads(__tstate);
46672 if (PyErr_Occurred()) SWIG_fail;
46673 }
46674 resultobj = SWIG_Py_Void();
46675 {
46676 if (temp2)
46677 delete arg2;
46678 }
46679 return resultobj;
46680 fail:
46681 {
46682 if (temp2)
46683 delete arg2;
46684 }
46685 return NULL;
46686 }
46687
46688
46689 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46690 PyObject *resultobj = 0;
46691 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46692 wxString *result = 0 ;
46693 void *argp1 = 0 ;
46694 int res1 = 0 ;
46695 PyObject *swig_obj[1] ;
46696
46697 if (!args) SWIG_fail;
46698 swig_obj[0] = args;
46699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46700 if (!SWIG_IsOK(res1)) {
46701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46702 }
46703 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46704 {
46705 PyThreadState* __tstate = wxPyBeginAllowThreads();
46706 {
46707 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46708 result = (wxString *) &_result_ref;
46709 }
46710 wxPyEndAllowThreads(__tstate);
46711 if (PyErr_Occurred()) SWIG_fail;
46712 }
46713 {
46714 #if wxUSE_UNICODE
46715 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46716 #else
46717 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46718 #endif
46719 }
46720 return resultobj;
46721 fail:
46722 return NULL;
46723 }
46724
46725
46726 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46727 PyObject *resultobj = 0;
46728 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46729 wxAcceleratorEntry *result = 0 ;
46730 void *argp1 = 0 ;
46731 int res1 = 0 ;
46732 PyObject *swig_obj[1] ;
46733
46734 if (!args) SWIG_fail;
46735 swig_obj[0] = args;
46736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46737 if (!SWIG_IsOK(res1)) {
46738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46739 }
46740 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46741 {
46742 PyThreadState* __tstate = wxPyBeginAllowThreads();
46743 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46744 wxPyEndAllowThreads(__tstate);
46745 if (PyErr_Occurred()) SWIG_fail;
46746 }
46747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46748 return resultobj;
46749 fail:
46750 return NULL;
46751 }
46752
46753
46754 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46755 PyObject *resultobj = 0;
46756 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46757 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46758 void *argp1 = 0 ;
46759 int res1 = 0 ;
46760 void *argp2 = 0 ;
46761 int res2 = 0 ;
46762 PyObject * obj0 = 0 ;
46763 PyObject * obj1 = 0 ;
46764 char * kwnames[] = {
46765 (char *) "self",(char *) "accel", NULL
46766 };
46767
46768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46770 if (!SWIG_IsOK(res1)) {
46771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46772 }
46773 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46774 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46775 if (!SWIG_IsOK(res2)) {
46776 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46777 }
46778 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46779 {
46780 PyThreadState* __tstate = wxPyBeginAllowThreads();
46781 (arg1)->SetAccel(arg2);
46782 wxPyEndAllowThreads(__tstate);
46783 if (PyErr_Occurred()) SWIG_fail;
46784 }
46785 resultobj = SWIG_Py_Void();
46786 return resultobj;
46787 fail:
46788 return NULL;
46789 }
46790
46791
46792 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46793 PyObject *resultobj = 0;
46794 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46795 wxBitmap *arg2 = 0 ;
46796 void *argp1 = 0 ;
46797 int res1 = 0 ;
46798 void *argp2 = 0 ;
46799 int res2 = 0 ;
46800 PyObject * obj0 = 0 ;
46801 PyObject * obj1 = 0 ;
46802 char * kwnames[] = {
46803 (char *) "self",(char *) "bitmap", NULL
46804 };
46805
46806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46808 if (!SWIG_IsOK(res1)) {
46809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46810 }
46811 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46812 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46813 if (!SWIG_IsOK(res2)) {
46814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46815 }
46816 if (!argp2) {
46817 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46818 }
46819 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46820 {
46821 PyThreadState* __tstate = wxPyBeginAllowThreads();
46822 (arg1)->SetBitmap((wxBitmap const &)*arg2);
46823 wxPyEndAllowThreads(__tstate);
46824 if (PyErr_Occurred()) SWIG_fail;
46825 }
46826 resultobj = SWIG_Py_Void();
46827 return resultobj;
46828 fail:
46829 return NULL;
46830 }
46831
46832
46833 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46834 PyObject *resultobj = 0;
46835 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46836 wxBitmap *result = 0 ;
46837 void *argp1 = 0 ;
46838 int res1 = 0 ;
46839 PyObject *swig_obj[1] ;
46840
46841 if (!args) SWIG_fail;
46842 swig_obj[0] = args;
46843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46844 if (!SWIG_IsOK(res1)) {
46845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46846 }
46847 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46848 {
46849 PyThreadState* __tstate = wxPyBeginAllowThreads();
46850 {
46851 wxBitmap const &_result_ref = (arg1)->GetBitmap();
46852 result = (wxBitmap *) &_result_ref;
46853 }
46854 wxPyEndAllowThreads(__tstate);
46855 if (PyErr_Occurred()) SWIG_fail;
46856 }
46857 {
46858 wxBitmap* resultptr = new wxBitmap(*result);
46859 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46860 }
46861 return resultobj;
46862 fail:
46863 return NULL;
46864 }
46865
46866
46867 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46868 PyObject *resultobj = 0;
46869 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46870 wxFont *arg2 = 0 ;
46871 void *argp1 = 0 ;
46872 int res1 = 0 ;
46873 void *argp2 = 0 ;
46874 int res2 = 0 ;
46875 PyObject * obj0 = 0 ;
46876 PyObject * obj1 = 0 ;
46877 char * kwnames[] = {
46878 (char *) "self",(char *) "font", NULL
46879 };
46880
46881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
46882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46883 if (!SWIG_IsOK(res1)) {
46884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46885 }
46886 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46887 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
46888 if (!SWIG_IsOK(res2)) {
46889 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46890 }
46891 if (!argp2) {
46892 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46893 }
46894 arg2 = reinterpret_cast< wxFont * >(argp2);
46895 {
46896 PyThreadState* __tstate = wxPyBeginAllowThreads();
46897 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
46898 wxPyEndAllowThreads(__tstate);
46899 if (PyErr_Occurred()) SWIG_fail;
46900 }
46901 resultobj = SWIG_Py_Void();
46902 return resultobj;
46903 fail:
46904 return NULL;
46905 }
46906
46907
46908 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46909 PyObject *resultobj = 0;
46910 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46911 wxFont result;
46912 void *argp1 = 0 ;
46913 int res1 = 0 ;
46914 PyObject *swig_obj[1] ;
46915
46916 if (!args) SWIG_fail;
46917 swig_obj[0] = args;
46918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46919 if (!SWIG_IsOK(res1)) {
46920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46921 }
46922 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46923 {
46924 PyThreadState* __tstate = wxPyBeginAllowThreads();
46925 result = wxMenuItem_GetFont(arg1);
46926 wxPyEndAllowThreads(__tstate);
46927 if (PyErr_Occurred()) SWIG_fail;
46928 }
46929 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
46930 return resultobj;
46931 fail:
46932 return NULL;
46933 }
46934
46935
46936 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46937 PyObject *resultobj = 0;
46938 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46939 wxColour *arg2 = 0 ;
46940 void *argp1 = 0 ;
46941 int res1 = 0 ;
46942 wxColour temp2 ;
46943 PyObject * obj0 = 0 ;
46944 PyObject * obj1 = 0 ;
46945 char * kwnames[] = {
46946 (char *) "self",(char *) "colText", NULL
46947 };
46948
46949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
46950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46951 if (!SWIG_IsOK(res1)) {
46952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46953 }
46954 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46955 {
46956 arg2 = &temp2;
46957 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46958 }
46959 {
46960 PyThreadState* __tstate = wxPyBeginAllowThreads();
46961 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
46962 wxPyEndAllowThreads(__tstate);
46963 if (PyErr_Occurred()) SWIG_fail;
46964 }
46965 resultobj = SWIG_Py_Void();
46966 return resultobj;
46967 fail:
46968 return NULL;
46969 }
46970
46971
46972 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46973 PyObject *resultobj = 0;
46974 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46975 wxColour result;
46976 void *argp1 = 0 ;
46977 int res1 = 0 ;
46978 PyObject *swig_obj[1] ;
46979
46980 if (!args) SWIG_fail;
46981 swig_obj[0] = args;
46982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46983 if (!SWIG_IsOK(res1)) {
46984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46985 }
46986 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46987 {
46988 PyThreadState* __tstate = wxPyBeginAllowThreads();
46989 result = wxMenuItem_GetTextColour(arg1);
46990 wxPyEndAllowThreads(__tstate);
46991 if (PyErr_Occurred()) SWIG_fail;
46992 }
46993 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46994 return resultobj;
46995 fail:
46996 return NULL;
46997 }
46998
46999
47000 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47001 PyObject *resultobj = 0;
47002 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47003 wxColour *arg2 = 0 ;
47004 void *argp1 = 0 ;
47005 int res1 = 0 ;
47006 wxColour temp2 ;
47007 PyObject * obj0 = 0 ;
47008 PyObject * obj1 = 0 ;
47009 char * kwnames[] = {
47010 (char *) "self",(char *) "colBack", NULL
47011 };
47012
47013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
47014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47015 if (!SWIG_IsOK(res1)) {
47016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47017 }
47018 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47019 {
47020 arg2 = &temp2;
47021 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47022 }
47023 {
47024 PyThreadState* __tstate = wxPyBeginAllowThreads();
47025 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
47026 wxPyEndAllowThreads(__tstate);
47027 if (PyErr_Occurred()) SWIG_fail;
47028 }
47029 resultobj = SWIG_Py_Void();
47030 return resultobj;
47031 fail:
47032 return NULL;
47033 }
47034
47035
47036 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47037 PyObject *resultobj = 0;
47038 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47039 wxColour result;
47040 void *argp1 = 0 ;
47041 int res1 = 0 ;
47042 PyObject *swig_obj[1] ;
47043
47044 if (!args) SWIG_fail;
47045 swig_obj[0] = args;
47046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47047 if (!SWIG_IsOK(res1)) {
47048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47049 }
47050 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47051 {
47052 PyThreadState* __tstate = wxPyBeginAllowThreads();
47053 result = wxMenuItem_GetBackgroundColour(arg1);
47054 wxPyEndAllowThreads(__tstate);
47055 if (PyErr_Occurred()) SWIG_fail;
47056 }
47057 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47058 return resultobj;
47059 fail:
47060 return NULL;
47061 }
47062
47063
47064 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47065 PyObject *resultobj = 0;
47066 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47067 wxBitmap *arg2 = 0 ;
47068 wxBitmap const &arg3_defvalue = wxNullBitmap ;
47069 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
47070 void *argp1 = 0 ;
47071 int res1 = 0 ;
47072 void *argp2 = 0 ;
47073 int res2 = 0 ;
47074 void *argp3 = 0 ;
47075 int res3 = 0 ;
47076 PyObject * obj0 = 0 ;
47077 PyObject * obj1 = 0 ;
47078 PyObject * obj2 = 0 ;
47079 char * kwnames[] = {
47080 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
47081 };
47082
47083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47085 if (!SWIG_IsOK(res1)) {
47086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47087 }
47088 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47089 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47090 if (!SWIG_IsOK(res2)) {
47091 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47092 }
47093 if (!argp2) {
47094 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47095 }
47096 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47097 if (obj2) {
47098 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
47099 if (!SWIG_IsOK(res3)) {
47100 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47101 }
47102 if (!argp3) {
47103 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47104 }
47105 arg3 = reinterpret_cast< wxBitmap * >(argp3);
47106 }
47107 {
47108 PyThreadState* __tstate = wxPyBeginAllowThreads();
47109 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
47110 wxPyEndAllowThreads(__tstate);
47111 if (PyErr_Occurred()) SWIG_fail;
47112 }
47113 resultobj = SWIG_Py_Void();
47114 return resultobj;
47115 fail:
47116 return NULL;
47117 }
47118
47119
47120 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47121 PyObject *resultobj = 0;
47122 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47123 wxBitmap *arg2 = 0 ;
47124 void *argp1 = 0 ;
47125 int res1 = 0 ;
47126 void *argp2 = 0 ;
47127 int res2 = 0 ;
47128 PyObject * obj0 = 0 ;
47129 PyObject * obj1 = 0 ;
47130 char * kwnames[] = {
47131 (char *) "self",(char *) "bmpDisabled", NULL
47132 };
47133
47134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47136 if (!SWIG_IsOK(res1)) {
47137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47138 }
47139 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47140 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47141 if (!SWIG_IsOK(res2)) {
47142 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47143 }
47144 if (!argp2) {
47145 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47146 }
47147 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47148 {
47149 PyThreadState* __tstate = wxPyBeginAllowThreads();
47150 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
47151 wxPyEndAllowThreads(__tstate);
47152 if (PyErr_Occurred()) SWIG_fail;
47153 }
47154 resultobj = SWIG_Py_Void();
47155 return resultobj;
47156 fail:
47157 return NULL;
47158 }
47159
47160
47161 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47162 PyObject *resultobj = 0;
47163 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47164 wxBitmap *result = 0 ;
47165 void *argp1 = 0 ;
47166 int res1 = 0 ;
47167 PyObject *swig_obj[1] ;
47168
47169 if (!args) SWIG_fail;
47170 swig_obj[0] = args;
47171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47172 if (!SWIG_IsOK(res1)) {
47173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47174 }
47175 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47176 {
47177 PyThreadState* __tstate = wxPyBeginAllowThreads();
47178 {
47179 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
47180 result = (wxBitmap *) &_result_ref;
47181 }
47182 wxPyEndAllowThreads(__tstate);
47183 if (PyErr_Occurred()) SWIG_fail;
47184 }
47185 {
47186 wxBitmap* resultptr = new wxBitmap(*result);
47187 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47188 }
47189 return resultobj;
47190 fail:
47191 return NULL;
47192 }
47193
47194
47195 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47196 PyObject *resultobj = 0;
47197 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47198 int arg2 ;
47199 void *argp1 = 0 ;
47200 int res1 = 0 ;
47201 int val2 ;
47202 int ecode2 = 0 ;
47203 PyObject * obj0 = 0 ;
47204 PyObject * obj1 = 0 ;
47205 char * kwnames[] = {
47206 (char *) "self",(char *) "nWidth", NULL
47207 };
47208
47209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47211 if (!SWIG_IsOK(res1)) {
47212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47213 }
47214 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47215 ecode2 = SWIG_AsVal_int(obj1, &val2);
47216 if (!SWIG_IsOK(ecode2)) {
47217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47218 }
47219 arg2 = static_cast< int >(val2);
47220 {
47221 PyThreadState* __tstate = wxPyBeginAllowThreads();
47222 wxMenuItem_SetMarginWidth(arg1,arg2);
47223 wxPyEndAllowThreads(__tstate);
47224 if (PyErr_Occurred()) SWIG_fail;
47225 }
47226 resultobj = SWIG_Py_Void();
47227 return resultobj;
47228 fail:
47229 return NULL;
47230 }
47231
47232
47233 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47234 PyObject *resultobj = 0;
47235 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47236 int result;
47237 void *argp1 = 0 ;
47238 int res1 = 0 ;
47239 PyObject *swig_obj[1] ;
47240
47241 if (!args) SWIG_fail;
47242 swig_obj[0] = args;
47243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47244 if (!SWIG_IsOK(res1)) {
47245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47246 }
47247 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47248 {
47249 PyThreadState* __tstate = wxPyBeginAllowThreads();
47250 result = (int)wxMenuItem_GetMarginWidth(arg1);
47251 wxPyEndAllowThreads(__tstate);
47252 if (PyErr_Occurred()) SWIG_fail;
47253 }
47254 resultobj = SWIG_From_int(static_cast< int >(result));
47255 return resultobj;
47256 fail:
47257 return NULL;
47258 }
47259
47260
47261 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47262 PyObject *resultobj = 0;
47263 int result;
47264
47265 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47266 {
47267 PyThreadState* __tstate = wxPyBeginAllowThreads();
47268 result = (int)wxMenuItem_GetDefaultMarginWidth();
47269 wxPyEndAllowThreads(__tstate);
47270 if (PyErr_Occurred()) SWIG_fail;
47271 }
47272 resultobj = SWIG_From_int(static_cast< int >(result));
47273 return resultobj;
47274 fail:
47275 return NULL;
47276 }
47277
47278
47279 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47280 PyObject *resultobj = 0;
47281 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47282 bool result;
47283 void *argp1 = 0 ;
47284 int res1 = 0 ;
47285 PyObject *swig_obj[1] ;
47286
47287 if (!args) SWIG_fail;
47288 swig_obj[0] = args;
47289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47290 if (!SWIG_IsOK(res1)) {
47291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47292 }
47293 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47294 {
47295 PyThreadState* __tstate = wxPyBeginAllowThreads();
47296 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
47297 wxPyEndAllowThreads(__tstate);
47298 if (PyErr_Occurred()) SWIG_fail;
47299 }
47300 {
47301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47302 }
47303 return resultobj;
47304 fail:
47305 return NULL;
47306 }
47307
47308
47309 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47310 PyObject *resultobj = 0;
47311 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47312 bool arg2 = (bool) true ;
47313 void *argp1 = 0 ;
47314 int res1 = 0 ;
47315 bool val2 ;
47316 int ecode2 = 0 ;
47317 PyObject * obj0 = 0 ;
47318 PyObject * obj1 = 0 ;
47319 char * kwnames[] = {
47320 (char *) "self",(char *) "ownerDrawn", NULL
47321 };
47322
47323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47325 if (!SWIG_IsOK(res1)) {
47326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47327 }
47328 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47329 if (obj1) {
47330 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47331 if (!SWIG_IsOK(ecode2)) {
47332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47333 }
47334 arg2 = static_cast< bool >(val2);
47335 }
47336 {
47337 PyThreadState* __tstate = wxPyBeginAllowThreads();
47338 wxMenuItem_SetOwnerDrawn(arg1,arg2);
47339 wxPyEndAllowThreads(__tstate);
47340 if (PyErr_Occurred()) SWIG_fail;
47341 }
47342 resultobj = SWIG_Py_Void();
47343 return resultobj;
47344 fail:
47345 return NULL;
47346 }
47347
47348
47349 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47350 PyObject *resultobj = 0;
47351 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47352 void *argp1 = 0 ;
47353 int res1 = 0 ;
47354 PyObject *swig_obj[1] ;
47355
47356 if (!args) SWIG_fail;
47357 swig_obj[0] = args;
47358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47359 if (!SWIG_IsOK(res1)) {
47360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47361 }
47362 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47363 {
47364 PyThreadState* __tstate = wxPyBeginAllowThreads();
47365 wxMenuItem_ResetOwnerDrawn(arg1);
47366 wxPyEndAllowThreads(__tstate);
47367 if (PyErr_Occurred()) SWIG_fail;
47368 }
47369 resultobj = SWIG_Py_Void();
47370 return resultobj;
47371 fail:
47372 return NULL;
47373 }
47374
47375
47376 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47377 PyObject *obj;
47378 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47379 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47380 return SWIG_Py_Void();
47381 }
47382
47383 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47384 return SWIG_Python_InitShadowInstance(args);
47385 }
47386
47387 SWIGINTERN int ControlNameStr_set(PyObject *) {
47388 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47389 return 1;
47390 }
47391
47392
47393 SWIGINTERN PyObject *ControlNameStr_get(void) {
47394 PyObject *pyobj = 0;
47395
47396 {
47397 #if wxUSE_UNICODE
47398 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47399 #else
47400 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47401 #endif
47402 }
47403 return pyobj;
47404 }
47405
47406
47407 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47408 PyObject *resultobj = 0;
47409 wxWindow *arg1 = (wxWindow *) 0 ;
47410 int arg2 = (int) -1 ;
47411 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47412 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47413 wxSize const &arg4_defvalue = wxDefaultSize ;
47414 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47415 long arg5 = (long) 0 ;
47416 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47417 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47418 wxString const &arg7_defvalue = wxPyControlNameStr ;
47419 wxString *arg7 = (wxString *) &arg7_defvalue ;
47420 wxControl *result = 0 ;
47421 void *argp1 = 0 ;
47422 int res1 = 0 ;
47423 int val2 ;
47424 int ecode2 = 0 ;
47425 wxPoint temp3 ;
47426 wxSize temp4 ;
47427 long val5 ;
47428 int ecode5 = 0 ;
47429 void *argp6 = 0 ;
47430 int res6 = 0 ;
47431 bool temp7 = false ;
47432 PyObject * obj0 = 0 ;
47433 PyObject * obj1 = 0 ;
47434 PyObject * obj2 = 0 ;
47435 PyObject * obj3 = 0 ;
47436 PyObject * obj4 = 0 ;
47437 PyObject * obj5 = 0 ;
47438 PyObject * obj6 = 0 ;
47439 char * kwnames[] = {
47440 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47441 };
47442
47443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47445 if (!SWIG_IsOK(res1)) {
47446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47447 }
47448 arg1 = reinterpret_cast< wxWindow * >(argp1);
47449 if (obj1) {
47450 ecode2 = SWIG_AsVal_int(obj1, &val2);
47451 if (!SWIG_IsOK(ecode2)) {
47452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47453 }
47454 arg2 = static_cast< int >(val2);
47455 }
47456 if (obj2) {
47457 {
47458 arg3 = &temp3;
47459 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47460 }
47461 }
47462 if (obj3) {
47463 {
47464 arg4 = &temp4;
47465 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47466 }
47467 }
47468 if (obj4) {
47469 ecode5 = SWIG_AsVal_long(obj4, &val5);
47470 if (!SWIG_IsOK(ecode5)) {
47471 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47472 }
47473 arg5 = static_cast< long >(val5);
47474 }
47475 if (obj5) {
47476 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47477 if (!SWIG_IsOK(res6)) {
47478 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47479 }
47480 if (!argp6) {
47481 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47482 }
47483 arg6 = reinterpret_cast< wxValidator * >(argp6);
47484 }
47485 if (obj6) {
47486 {
47487 arg7 = wxString_in_helper(obj6);
47488 if (arg7 == NULL) SWIG_fail;
47489 temp7 = true;
47490 }
47491 }
47492 {
47493 if (!wxPyCheckForApp()) SWIG_fail;
47494 PyThreadState* __tstate = wxPyBeginAllowThreads();
47495 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47496 wxPyEndAllowThreads(__tstate);
47497 if (PyErr_Occurred()) SWIG_fail;
47498 }
47499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47500 {
47501 if (temp7)
47502 delete arg7;
47503 }
47504 return resultobj;
47505 fail:
47506 {
47507 if (temp7)
47508 delete arg7;
47509 }
47510 return NULL;
47511 }
47512
47513
47514 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47515 PyObject *resultobj = 0;
47516 wxControl *result = 0 ;
47517
47518 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47519 {
47520 if (!wxPyCheckForApp()) SWIG_fail;
47521 PyThreadState* __tstate = wxPyBeginAllowThreads();
47522 result = (wxControl *)new wxControl();
47523 wxPyEndAllowThreads(__tstate);
47524 if (PyErr_Occurred()) SWIG_fail;
47525 }
47526 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47527 return resultobj;
47528 fail:
47529 return NULL;
47530 }
47531
47532
47533 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47534 PyObject *resultobj = 0;
47535 wxControl *arg1 = (wxControl *) 0 ;
47536 wxWindow *arg2 = (wxWindow *) 0 ;
47537 int arg3 = (int) -1 ;
47538 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47539 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47540 wxSize const &arg5_defvalue = wxDefaultSize ;
47541 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47542 long arg6 = (long) 0 ;
47543 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47544 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47545 wxString const &arg8_defvalue = wxPyControlNameStr ;
47546 wxString *arg8 = (wxString *) &arg8_defvalue ;
47547 bool result;
47548 void *argp1 = 0 ;
47549 int res1 = 0 ;
47550 void *argp2 = 0 ;
47551 int res2 = 0 ;
47552 int val3 ;
47553 int ecode3 = 0 ;
47554 wxPoint temp4 ;
47555 wxSize temp5 ;
47556 long val6 ;
47557 int ecode6 = 0 ;
47558 void *argp7 = 0 ;
47559 int res7 = 0 ;
47560 bool temp8 = false ;
47561 PyObject * obj0 = 0 ;
47562 PyObject * obj1 = 0 ;
47563 PyObject * obj2 = 0 ;
47564 PyObject * obj3 = 0 ;
47565 PyObject * obj4 = 0 ;
47566 PyObject * obj5 = 0 ;
47567 PyObject * obj6 = 0 ;
47568 PyObject * obj7 = 0 ;
47569 char * kwnames[] = {
47570 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47571 };
47572
47573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47575 if (!SWIG_IsOK(res1)) {
47576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47577 }
47578 arg1 = reinterpret_cast< wxControl * >(argp1);
47579 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47580 if (!SWIG_IsOK(res2)) {
47581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47582 }
47583 arg2 = reinterpret_cast< wxWindow * >(argp2);
47584 if (obj2) {
47585 ecode3 = SWIG_AsVal_int(obj2, &val3);
47586 if (!SWIG_IsOK(ecode3)) {
47587 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47588 }
47589 arg3 = static_cast< int >(val3);
47590 }
47591 if (obj3) {
47592 {
47593 arg4 = &temp4;
47594 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47595 }
47596 }
47597 if (obj4) {
47598 {
47599 arg5 = &temp5;
47600 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47601 }
47602 }
47603 if (obj5) {
47604 ecode6 = SWIG_AsVal_long(obj5, &val6);
47605 if (!SWIG_IsOK(ecode6)) {
47606 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47607 }
47608 arg6 = static_cast< long >(val6);
47609 }
47610 if (obj6) {
47611 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47612 if (!SWIG_IsOK(res7)) {
47613 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47614 }
47615 if (!argp7) {
47616 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47617 }
47618 arg7 = reinterpret_cast< wxValidator * >(argp7);
47619 }
47620 if (obj7) {
47621 {
47622 arg8 = wxString_in_helper(obj7);
47623 if (arg8 == NULL) SWIG_fail;
47624 temp8 = true;
47625 }
47626 }
47627 {
47628 PyThreadState* __tstate = wxPyBeginAllowThreads();
47629 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47630 wxPyEndAllowThreads(__tstate);
47631 if (PyErr_Occurred()) SWIG_fail;
47632 }
47633 {
47634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47635 }
47636 {
47637 if (temp8)
47638 delete arg8;
47639 }
47640 return resultobj;
47641 fail:
47642 {
47643 if (temp8)
47644 delete arg8;
47645 }
47646 return NULL;
47647 }
47648
47649
47650 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47651 PyObject *resultobj = 0;
47652 wxControl *arg1 = (wxControl *) 0 ;
47653 int result;
47654 void *argp1 = 0 ;
47655 int res1 = 0 ;
47656 PyObject *swig_obj[1] ;
47657
47658 if (!args) SWIG_fail;
47659 swig_obj[0] = args;
47660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47661 if (!SWIG_IsOK(res1)) {
47662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47663 }
47664 arg1 = reinterpret_cast< wxControl * >(argp1);
47665 {
47666 PyThreadState* __tstate = wxPyBeginAllowThreads();
47667 result = (int)((wxControl const *)arg1)->GetAlignment();
47668 wxPyEndAllowThreads(__tstate);
47669 if (PyErr_Occurred()) SWIG_fail;
47670 }
47671 resultobj = SWIG_From_int(static_cast< int >(result));
47672 return resultobj;
47673 fail:
47674 return NULL;
47675 }
47676
47677
47678 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47679 PyObject *resultobj = 0;
47680 wxControl *arg1 = (wxControl *) 0 ;
47681 wxString result;
47682 void *argp1 = 0 ;
47683 int res1 = 0 ;
47684 PyObject *swig_obj[1] ;
47685
47686 if (!args) SWIG_fail;
47687 swig_obj[0] = args;
47688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47689 if (!SWIG_IsOK(res1)) {
47690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47691 }
47692 arg1 = reinterpret_cast< wxControl * >(argp1);
47693 {
47694 PyThreadState* __tstate = wxPyBeginAllowThreads();
47695 result = ((wxControl const *)arg1)->GetLabelText();
47696 wxPyEndAllowThreads(__tstate);
47697 if (PyErr_Occurred()) SWIG_fail;
47698 }
47699 {
47700 #if wxUSE_UNICODE
47701 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47702 #else
47703 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47704 #endif
47705 }
47706 return resultobj;
47707 fail:
47708 return NULL;
47709 }
47710
47711
47712 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47713 PyObject *resultobj = 0;
47714 wxControl *arg1 = (wxControl *) 0 ;
47715 wxCommandEvent *arg2 = 0 ;
47716 void *argp1 = 0 ;
47717 int res1 = 0 ;
47718 void *argp2 = 0 ;
47719 int res2 = 0 ;
47720 PyObject * obj0 = 0 ;
47721 PyObject * obj1 = 0 ;
47722 char * kwnames[] = {
47723 (char *) "self",(char *) "event", NULL
47724 };
47725
47726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47728 if (!SWIG_IsOK(res1)) {
47729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47730 }
47731 arg1 = reinterpret_cast< wxControl * >(argp1);
47732 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47733 if (!SWIG_IsOK(res2)) {
47734 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47735 }
47736 if (!argp2) {
47737 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47738 }
47739 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47740 {
47741 PyThreadState* __tstate = wxPyBeginAllowThreads();
47742 (arg1)->Command(*arg2);
47743 wxPyEndAllowThreads(__tstate);
47744 if (PyErr_Occurred()) SWIG_fail;
47745 }
47746 resultobj = SWIG_Py_Void();
47747 return resultobj;
47748 fail:
47749 return NULL;
47750 }
47751
47752
47753 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47754 PyObject *resultobj = 0;
47755 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47756 SwigValueWrapper<wxVisualAttributes > result;
47757 int val1 ;
47758 int ecode1 = 0 ;
47759 PyObject * obj0 = 0 ;
47760 char * kwnames[] = {
47761 (char *) "variant", NULL
47762 };
47763
47764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47765 if (obj0) {
47766 ecode1 = SWIG_AsVal_int(obj0, &val1);
47767 if (!SWIG_IsOK(ecode1)) {
47768 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47769 }
47770 arg1 = static_cast< wxWindowVariant >(val1);
47771 }
47772 {
47773 if (!wxPyCheckForApp()) SWIG_fail;
47774 PyThreadState* __tstate = wxPyBeginAllowThreads();
47775 result = wxControl::GetClassDefaultAttributes(arg1);
47776 wxPyEndAllowThreads(__tstate);
47777 if (PyErr_Occurred()) SWIG_fail;
47778 }
47779 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47780 return resultobj;
47781 fail:
47782 return NULL;
47783 }
47784
47785
47786 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47787 PyObject *obj;
47788 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47789 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47790 return SWIG_Py_Void();
47791 }
47792
47793 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47794 return SWIG_Python_InitShadowInstance(args);
47795 }
47796
47797 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47798 PyObject *resultobj = 0;
47799 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47800 wxString *arg2 = 0 ;
47801 PyObject *arg3 = (PyObject *) NULL ;
47802 int result;
47803 void *argp1 = 0 ;
47804 int res1 = 0 ;
47805 bool temp2 = false ;
47806 PyObject * obj0 = 0 ;
47807 PyObject * obj1 = 0 ;
47808 PyObject * obj2 = 0 ;
47809 char * kwnames[] = {
47810 (char *) "self",(char *) "item",(char *) "clientData", NULL
47811 };
47812
47813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47815 if (!SWIG_IsOK(res1)) {
47816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47817 }
47818 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47819 {
47820 arg2 = wxString_in_helper(obj1);
47821 if (arg2 == NULL) SWIG_fail;
47822 temp2 = true;
47823 }
47824 if (obj2) {
47825 arg3 = obj2;
47826 }
47827 {
47828 PyThreadState* __tstate = wxPyBeginAllowThreads();
47829 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47830 wxPyEndAllowThreads(__tstate);
47831 if (PyErr_Occurred()) SWIG_fail;
47832 }
47833 resultobj = SWIG_From_int(static_cast< int >(result));
47834 {
47835 if (temp2)
47836 delete arg2;
47837 }
47838 return resultobj;
47839 fail:
47840 {
47841 if (temp2)
47842 delete arg2;
47843 }
47844 return NULL;
47845 }
47846
47847
47848 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47849 PyObject *resultobj = 0;
47850 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47851 wxArrayString *arg2 = 0 ;
47852 void *argp1 = 0 ;
47853 int res1 = 0 ;
47854 bool temp2 = false ;
47855 PyObject * obj0 = 0 ;
47856 PyObject * obj1 = 0 ;
47857 char * kwnames[] = {
47858 (char *) "self",(char *) "strings", NULL
47859 };
47860
47861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
47862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47863 if (!SWIG_IsOK(res1)) {
47864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47865 }
47866 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47867 {
47868 if (! PySequence_Check(obj1)) {
47869 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
47870 SWIG_fail;
47871 }
47872 arg2 = new wxArrayString;
47873 temp2 = true;
47874 int i, len=PySequence_Length(obj1);
47875 for (i=0; i<len; i++) {
47876 PyObject* item = PySequence_GetItem(obj1, i);
47877 wxString* s = wxString_in_helper(item);
47878 if (PyErr_Occurred()) SWIG_fail;
47879 arg2->Add(*s);
47880 delete s;
47881 Py_DECREF(item);
47882 }
47883 }
47884 {
47885 PyThreadState* __tstate = wxPyBeginAllowThreads();
47886 (arg1)->Append((wxArrayString const &)*arg2);
47887 wxPyEndAllowThreads(__tstate);
47888 if (PyErr_Occurred()) SWIG_fail;
47889 }
47890 resultobj = SWIG_Py_Void();
47891 {
47892 if (temp2) delete arg2;
47893 }
47894 return resultobj;
47895 fail:
47896 {
47897 if (temp2) delete arg2;
47898 }
47899 return NULL;
47900 }
47901
47902
47903 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47904 PyObject *resultobj = 0;
47905 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47906 wxString *arg2 = 0 ;
47907 int arg3 ;
47908 PyObject *arg4 = (PyObject *) NULL ;
47909 int result;
47910 void *argp1 = 0 ;
47911 int res1 = 0 ;
47912 bool temp2 = false ;
47913 int val3 ;
47914 int ecode3 = 0 ;
47915 PyObject * obj0 = 0 ;
47916 PyObject * obj1 = 0 ;
47917 PyObject * obj2 = 0 ;
47918 PyObject * obj3 = 0 ;
47919 char * kwnames[] = {
47920 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
47921 };
47922
47923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47925 if (!SWIG_IsOK(res1)) {
47926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47927 }
47928 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47929 {
47930 arg2 = wxString_in_helper(obj1);
47931 if (arg2 == NULL) SWIG_fail;
47932 temp2 = true;
47933 }
47934 ecode3 = SWIG_AsVal_int(obj2, &val3);
47935 if (!SWIG_IsOK(ecode3)) {
47936 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
47937 }
47938 arg3 = static_cast< int >(val3);
47939 if (obj3) {
47940 arg4 = obj3;
47941 }
47942 {
47943 PyThreadState* __tstate = wxPyBeginAllowThreads();
47944 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
47945 wxPyEndAllowThreads(__tstate);
47946 if (PyErr_Occurred()) SWIG_fail;
47947 }
47948 resultobj = SWIG_From_int(static_cast< int >(result));
47949 {
47950 if (temp2)
47951 delete arg2;
47952 }
47953 return resultobj;
47954 fail:
47955 {
47956 if (temp2)
47957 delete arg2;
47958 }
47959 return NULL;
47960 }
47961
47962
47963 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47964 PyObject *resultobj = 0;
47965 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47966 void *argp1 = 0 ;
47967 int res1 = 0 ;
47968 PyObject *swig_obj[1] ;
47969
47970 if (!args) SWIG_fail;
47971 swig_obj[0] = args;
47972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47973 if (!SWIG_IsOK(res1)) {
47974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47975 }
47976 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47977 {
47978 PyThreadState* __tstate = wxPyBeginAllowThreads();
47979 (arg1)->Clear();
47980 wxPyEndAllowThreads(__tstate);
47981 if (PyErr_Occurred()) SWIG_fail;
47982 }
47983 resultobj = SWIG_Py_Void();
47984 return resultobj;
47985 fail:
47986 return NULL;
47987 }
47988
47989
47990 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47991 PyObject *resultobj = 0;
47992 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47993 int arg2 ;
47994 void *argp1 = 0 ;
47995 int res1 = 0 ;
47996 int val2 ;
47997 int ecode2 = 0 ;
47998 PyObject * obj0 = 0 ;
47999 PyObject * obj1 = 0 ;
48000 char * kwnames[] = {
48001 (char *) "self",(char *) "n", NULL
48002 };
48003
48004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
48005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48006 if (!SWIG_IsOK(res1)) {
48007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48008 }
48009 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48010 ecode2 = SWIG_AsVal_int(obj1, &val2);
48011 if (!SWIG_IsOK(ecode2)) {
48012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
48013 }
48014 arg2 = static_cast< int >(val2);
48015 {
48016 PyThreadState* __tstate = wxPyBeginAllowThreads();
48017 (arg1)->Delete(arg2);
48018 wxPyEndAllowThreads(__tstate);
48019 if (PyErr_Occurred()) SWIG_fail;
48020 }
48021 resultobj = SWIG_Py_Void();
48022 return resultobj;
48023 fail:
48024 return NULL;
48025 }
48026
48027
48028 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48029 PyObject *resultobj = 0;
48030 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48031 int arg2 ;
48032 PyObject *result = 0 ;
48033 void *argp1 = 0 ;
48034 int res1 = 0 ;
48035 int val2 ;
48036 int ecode2 = 0 ;
48037 PyObject * obj0 = 0 ;
48038 PyObject * obj1 = 0 ;
48039 char * kwnames[] = {
48040 (char *) "self",(char *) "n", NULL
48041 };
48042
48043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
48044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48045 if (!SWIG_IsOK(res1)) {
48046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48047 }
48048 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48049 ecode2 = SWIG_AsVal_int(obj1, &val2);
48050 if (!SWIG_IsOK(ecode2)) {
48051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
48052 }
48053 arg2 = static_cast< int >(val2);
48054 {
48055 PyThreadState* __tstate = wxPyBeginAllowThreads();
48056 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
48057 wxPyEndAllowThreads(__tstate);
48058 if (PyErr_Occurred()) SWIG_fail;
48059 }
48060 resultobj = result;
48061 return resultobj;
48062 fail:
48063 return NULL;
48064 }
48065
48066
48067 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48068 PyObject *resultobj = 0;
48069 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48070 int arg2 ;
48071 PyObject *arg3 = (PyObject *) 0 ;
48072 void *argp1 = 0 ;
48073 int res1 = 0 ;
48074 int val2 ;
48075 int ecode2 = 0 ;
48076 PyObject * obj0 = 0 ;
48077 PyObject * obj1 = 0 ;
48078 PyObject * obj2 = 0 ;
48079 char * kwnames[] = {
48080 (char *) "self",(char *) "n",(char *) "clientData", NULL
48081 };
48082
48083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48085 if (!SWIG_IsOK(res1)) {
48086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48087 }
48088 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48089 ecode2 = SWIG_AsVal_int(obj1, &val2);
48090 if (!SWIG_IsOK(ecode2)) {
48091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
48092 }
48093 arg2 = static_cast< int >(val2);
48094 arg3 = obj2;
48095 {
48096 PyThreadState* __tstate = wxPyBeginAllowThreads();
48097 wxItemContainer_SetClientData(arg1,arg2,arg3);
48098 wxPyEndAllowThreads(__tstate);
48099 if (PyErr_Occurred()) SWIG_fail;
48100 }
48101 resultobj = SWIG_Py_Void();
48102 return resultobj;
48103 fail:
48104 return NULL;
48105 }
48106
48107
48108 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48109 PyObject *resultobj = 0;
48110 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48111 int result;
48112 void *argp1 = 0 ;
48113 int res1 = 0 ;
48114 PyObject *swig_obj[1] ;
48115
48116 if (!args) SWIG_fail;
48117 swig_obj[0] = args;
48118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48119 if (!SWIG_IsOK(res1)) {
48120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48121 }
48122 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48123 {
48124 PyThreadState* __tstate = wxPyBeginAllowThreads();
48125 result = (int)((wxItemContainer const *)arg1)->GetCount();
48126 wxPyEndAllowThreads(__tstate);
48127 if (PyErr_Occurred()) SWIG_fail;
48128 }
48129 resultobj = SWIG_From_int(static_cast< int >(result));
48130 return resultobj;
48131 fail:
48132 return NULL;
48133 }
48134
48135
48136 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48137 PyObject *resultobj = 0;
48138 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48139 bool result;
48140 void *argp1 = 0 ;
48141 int res1 = 0 ;
48142 PyObject *swig_obj[1] ;
48143
48144 if (!args) SWIG_fail;
48145 swig_obj[0] = args;
48146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48147 if (!SWIG_IsOK(res1)) {
48148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48149 }
48150 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48151 {
48152 PyThreadState* __tstate = wxPyBeginAllowThreads();
48153 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48154 wxPyEndAllowThreads(__tstate);
48155 if (PyErr_Occurred()) SWIG_fail;
48156 }
48157 {
48158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48159 }
48160 return resultobj;
48161 fail:
48162 return NULL;
48163 }
48164
48165
48166 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48167 PyObject *resultobj = 0;
48168 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48169 int arg2 ;
48170 wxString result;
48171 void *argp1 = 0 ;
48172 int res1 = 0 ;
48173 int val2 ;
48174 int ecode2 = 0 ;
48175 PyObject * obj0 = 0 ;
48176 PyObject * obj1 = 0 ;
48177 char * kwnames[] = {
48178 (char *) "self",(char *) "n", NULL
48179 };
48180
48181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48183 if (!SWIG_IsOK(res1)) {
48184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48185 }
48186 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48187 ecode2 = SWIG_AsVal_int(obj1, &val2);
48188 if (!SWIG_IsOK(ecode2)) {
48189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
48190 }
48191 arg2 = static_cast< int >(val2);
48192 {
48193 PyThreadState* __tstate = wxPyBeginAllowThreads();
48194 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48195 wxPyEndAllowThreads(__tstate);
48196 if (PyErr_Occurred()) SWIG_fail;
48197 }
48198 {
48199 #if wxUSE_UNICODE
48200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48201 #else
48202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48203 #endif
48204 }
48205 return resultobj;
48206 fail:
48207 return NULL;
48208 }
48209
48210
48211 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48212 PyObject *resultobj = 0;
48213 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48214 wxArrayString result;
48215 void *argp1 = 0 ;
48216 int res1 = 0 ;
48217 PyObject *swig_obj[1] ;
48218
48219 if (!args) SWIG_fail;
48220 swig_obj[0] = args;
48221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48222 if (!SWIG_IsOK(res1)) {
48223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48224 }
48225 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48226 {
48227 PyThreadState* __tstate = wxPyBeginAllowThreads();
48228 result = ((wxItemContainer const *)arg1)->GetStrings();
48229 wxPyEndAllowThreads(__tstate);
48230 if (PyErr_Occurred()) SWIG_fail;
48231 }
48232 {
48233 resultobj = wxArrayString2PyList_helper(result);
48234 }
48235 return resultobj;
48236 fail:
48237 return NULL;
48238 }
48239
48240
48241 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48242 PyObject *resultobj = 0;
48243 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48244 int arg2 ;
48245 wxString *arg3 = 0 ;
48246 void *argp1 = 0 ;
48247 int res1 = 0 ;
48248 int val2 ;
48249 int ecode2 = 0 ;
48250 bool temp3 = false ;
48251 PyObject * obj0 = 0 ;
48252 PyObject * obj1 = 0 ;
48253 PyObject * obj2 = 0 ;
48254 char * kwnames[] = {
48255 (char *) "self",(char *) "n",(char *) "s", NULL
48256 };
48257
48258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48260 if (!SWIG_IsOK(res1)) {
48261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48262 }
48263 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48264 ecode2 = SWIG_AsVal_int(obj1, &val2);
48265 if (!SWIG_IsOK(ecode2)) {
48266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
48267 }
48268 arg2 = static_cast< int >(val2);
48269 {
48270 arg3 = wxString_in_helper(obj2);
48271 if (arg3 == NULL) SWIG_fail;
48272 temp3 = true;
48273 }
48274 {
48275 PyThreadState* __tstate = wxPyBeginAllowThreads();
48276 (arg1)->SetString(arg2,(wxString const &)*arg3);
48277 wxPyEndAllowThreads(__tstate);
48278 if (PyErr_Occurred()) SWIG_fail;
48279 }
48280 resultobj = SWIG_Py_Void();
48281 {
48282 if (temp3)
48283 delete arg3;
48284 }
48285 return resultobj;
48286 fail:
48287 {
48288 if (temp3)
48289 delete arg3;
48290 }
48291 return NULL;
48292 }
48293
48294
48295 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48296 PyObject *resultobj = 0;
48297 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48298 wxString *arg2 = 0 ;
48299 int result;
48300 void *argp1 = 0 ;
48301 int res1 = 0 ;
48302 bool temp2 = false ;
48303 PyObject * obj0 = 0 ;
48304 PyObject * obj1 = 0 ;
48305 char * kwnames[] = {
48306 (char *) "self",(char *) "s", NULL
48307 };
48308
48309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48311 if (!SWIG_IsOK(res1)) {
48312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48313 }
48314 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48315 {
48316 arg2 = wxString_in_helper(obj1);
48317 if (arg2 == NULL) SWIG_fail;
48318 temp2 = true;
48319 }
48320 {
48321 PyThreadState* __tstate = wxPyBeginAllowThreads();
48322 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48323 wxPyEndAllowThreads(__tstate);
48324 if (PyErr_Occurred()) SWIG_fail;
48325 }
48326 resultobj = SWIG_From_int(static_cast< int >(result));
48327 {
48328 if (temp2)
48329 delete arg2;
48330 }
48331 return resultobj;
48332 fail:
48333 {
48334 if (temp2)
48335 delete arg2;
48336 }
48337 return NULL;
48338 }
48339
48340
48341 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48342 PyObject *resultobj = 0;
48343 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48344 int arg2 ;
48345 void *argp1 = 0 ;
48346 int res1 = 0 ;
48347 int val2 ;
48348 int ecode2 = 0 ;
48349 PyObject * obj0 = 0 ;
48350 PyObject * obj1 = 0 ;
48351 char * kwnames[] = {
48352 (char *) "self",(char *) "n", NULL
48353 };
48354
48355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48357 if (!SWIG_IsOK(res1)) {
48358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48359 }
48360 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48361 ecode2 = SWIG_AsVal_int(obj1, &val2);
48362 if (!SWIG_IsOK(ecode2)) {
48363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48364 }
48365 arg2 = static_cast< int >(val2);
48366 {
48367 PyThreadState* __tstate = wxPyBeginAllowThreads();
48368 (arg1)->SetSelection(arg2);
48369 wxPyEndAllowThreads(__tstate);
48370 if (PyErr_Occurred()) SWIG_fail;
48371 }
48372 resultobj = SWIG_Py_Void();
48373 return resultobj;
48374 fail:
48375 return NULL;
48376 }
48377
48378
48379 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48380 PyObject *resultobj = 0;
48381 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48382 int result;
48383 void *argp1 = 0 ;
48384 int res1 = 0 ;
48385 PyObject *swig_obj[1] ;
48386
48387 if (!args) SWIG_fail;
48388 swig_obj[0] = args;
48389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48390 if (!SWIG_IsOK(res1)) {
48391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48392 }
48393 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48394 {
48395 PyThreadState* __tstate = wxPyBeginAllowThreads();
48396 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48397 wxPyEndAllowThreads(__tstate);
48398 if (PyErr_Occurred()) SWIG_fail;
48399 }
48400 resultobj = SWIG_From_int(static_cast< int >(result));
48401 return resultobj;
48402 fail:
48403 return NULL;
48404 }
48405
48406
48407 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48408 PyObject *resultobj = 0;
48409 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48410 wxString *arg2 = 0 ;
48411 bool result;
48412 void *argp1 = 0 ;
48413 int res1 = 0 ;
48414 bool temp2 = false ;
48415 PyObject * obj0 = 0 ;
48416 PyObject * obj1 = 0 ;
48417 char * kwnames[] = {
48418 (char *) "self",(char *) "s", NULL
48419 };
48420
48421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48423 if (!SWIG_IsOK(res1)) {
48424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48425 }
48426 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48427 {
48428 arg2 = wxString_in_helper(obj1);
48429 if (arg2 == NULL) SWIG_fail;
48430 temp2 = true;
48431 }
48432 {
48433 PyThreadState* __tstate = wxPyBeginAllowThreads();
48434 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48435 wxPyEndAllowThreads(__tstate);
48436 if (PyErr_Occurred()) SWIG_fail;
48437 }
48438 {
48439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48440 }
48441 {
48442 if (temp2)
48443 delete arg2;
48444 }
48445 return resultobj;
48446 fail:
48447 {
48448 if (temp2)
48449 delete arg2;
48450 }
48451 return NULL;
48452 }
48453
48454
48455 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48456 PyObject *resultobj = 0;
48457 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48458 wxString result;
48459 void *argp1 = 0 ;
48460 int res1 = 0 ;
48461 PyObject *swig_obj[1] ;
48462
48463 if (!args) SWIG_fail;
48464 swig_obj[0] = args;
48465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48466 if (!SWIG_IsOK(res1)) {
48467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48468 }
48469 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48470 {
48471 PyThreadState* __tstate = wxPyBeginAllowThreads();
48472 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48473 wxPyEndAllowThreads(__tstate);
48474 if (PyErr_Occurred()) SWIG_fail;
48475 }
48476 {
48477 #if wxUSE_UNICODE
48478 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48479 #else
48480 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48481 #endif
48482 }
48483 return resultobj;
48484 fail:
48485 return NULL;
48486 }
48487
48488
48489 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48490 PyObject *resultobj = 0;
48491 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48492 int arg2 ;
48493 void *argp1 = 0 ;
48494 int res1 = 0 ;
48495 int val2 ;
48496 int ecode2 = 0 ;
48497 PyObject * obj0 = 0 ;
48498 PyObject * obj1 = 0 ;
48499 char * kwnames[] = {
48500 (char *) "self",(char *) "n", NULL
48501 };
48502
48503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48505 if (!SWIG_IsOK(res1)) {
48506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48507 }
48508 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48509 ecode2 = SWIG_AsVal_int(obj1, &val2);
48510 if (!SWIG_IsOK(ecode2)) {
48511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48512 }
48513 arg2 = static_cast< int >(val2);
48514 {
48515 PyThreadState* __tstate = wxPyBeginAllowThreads();
48516 (arg1)->Select(arg2);
48517 wxPyEndAllowThreads(__tstate);
48518 if (PyErr_Occurred()) SWIG_fail;
48519 }
48520 resultobj = SWIG_Py_Void();
48521 return resultobj;
48522 fail:
48523 return NULL;
48524 }
48525
48526
48527 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48528 PyObject *obj;
48529 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48530 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48531 return SWIG_Py_Void();
48532 }
48533
48534 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48535 PyObject *obj;
48536 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48537 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48538 return SWIG_Py_Void();
48539 }
48540
48541 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48542 PyObject *resultobj = 0;
48543 wxSizerItem *result = 0 ;
48544
48545 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
48546 {
48547 PyThreadState* __tstate = wxPyBeginAllowThreads();
48548 result = (wxSizerItem *)new wxSizerItem();
48549 wxPyEndAllowThreads(__tstate);
48550 if (PyErr_Occurred()) SWIG_fail;
48551 }
48552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
48553 return resultobj;
48554 fail:
48555 return NULL;
48556 }
48557
48558
48559 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48560 PyObject *resultobj = 0;
48561 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48562 void *argp1 = 0 ;
48563 int res1 = 0 ;
48564 PyObject *swig_obj[1] ;
48565
48566 if (!args) SWIG_fail;
48567 swig_obj[0] = args;
48568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48569 if (!SWIG_IsOK(res1)) {
48570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48571 }
48572 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48573 {
48574 PyThreadState* __tstate = wxPyBeginAllowThreads();
48575 delete arg1;
48576
48577 wxPyEndAllowThreads(__tstate);
48578 if (PyErr_Occurred()) SWIG_fail;
48579 }
48580 resultobj = SWIG_Py_Void();
48581 return resultobj;
48582 fail:
48583 return NULL;
48584 }
48585
48586
48587 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48588 PyObject *resultobj = 0;
48589 wxWindow *arg1 = (wxWindow *) 0 ;
48590 int arg2 ;
48591 int arg3 ;
48592 int arg4 ;
48593 PyObject *arg5 = (PyObject *) NULL ;
48594 wxSizerItem *result = 0 ;
48595 void *argp1 = 0 ;
48596 int res1 = 0 ;
48597 int val2 ;
48598 int ecode2 = 0 ;
48599 int val3 ;
48600 int ecode3 = 0 ;
48601 int val4 ;
48602 int ecode4 = 0 ;
48603 PyObject * obj0 = 0 ;
48604 PyObject * obj1 = 0 ;
48605 PyObject * obj2 = 0 ;
48606 PyObject * obj3 = 0 ;
48607 PyObject * obj4 = 0 ;
48608 char * kwnames[] = {
48609 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48610 };
48611
48612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48614 if (!SWIG_IsOK(res1)) {
48615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
48616 }
48617 arg1 = reinterpret_cast< wxWindow * >(argp1);
48618 ecode2 = SWIG_AsVal_int(obj1, &val2);
48619 if (!SWIG_IsOK(ecode2)) {
48620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
48621 }
48622 arg2 = static_cast< int >(val2);
48623 ecode3 = SWIG_AsVal_int(obj2, &val3);
48624 if (!SWIG_IsOK(ecode3)) {
48625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
48626 }
48627 arg3 = static_cast< int >(val3);
48628 ecode4 = SWIG_AsVal_int(obj3, &val4);
48629 if (!SWIG_IsOK(ecode4)) {
48630 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
48631 }
48632 arg4 = static_cast< int >(val4);
48633 if (obj4) {
48634 arg5 = obj4;
48635 }
48636 {
48637 PyThreadState* __tstate = wxPyBeginAllowThreads();
48638 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48639 wxPyEndAllowThreads(__tstate);
48640 if (PyErr_Occurred()) SWIG_fail;
48641 }
48642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48643 return resultobj;
48644 fail:
48645 return NULL;
48646 }
48647
48648
48649 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48650 PyObject *resultobj = 0;
48651 int arg1 ;
48652 int arg2 ;
48653 int arg3 ;
48654 int arg4 ;
48655 int arg5 ;
48656 PyObject *arg6 = (PyObject *) NULL ;
48657 wxSizerItem *result = 0 ;
48658 int val1 ;
48659 int ecode1 = 0 ;
48660 int val2 ;
48661 int ecode2 = 0 ;
48662 int val3 ;
48663 int ecode3 = 0 ;
48664 int val4 ;
48665 int ecode4 = 0 ;
48666 int val5 ;
48667 int ecode5 = 0 ;
48668 PyObject * obj0 = 0 ;
48669 PyObject * obj1 = 0 ;
48670 PyObject * obj2 = 0 ;
48671 PyObject * obj3 = 0 ;
48672 PyObject * obj4 = 0 ;
48673 PyObject * obj5 = 0 ;
48674 char * kwnames[] = {
48675 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48676 };
48677
48678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
48679 ecode1 = SWIG_AsVal_int(obj0, &val1);
48680 if (!SWIG_IsOK(ecode1)) {
48681 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
48682 }
48683 arg1 = static_cast< int >(val1);
48684 ecode2 = SWIG_AsVal_int(obj1, &val2);
48685 if (!SWIG_IsOK(ecode2)) {
48686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
48687 }
48688 arg2 = static_cast< int >(val2);
48689 ecode3 = SWIG_AsVal_int(obj2, &val3);
48690 if (!SWIG_IsOK(ecode3)) {
48691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
48692 }
48693 arg3 = static_cast< int >(val3);
48694 ecode4 = SWIG_AsVal_int(obj3, &val4);
48695 if (!SWIG_IsOK(ecode4)) {
48696 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
48697 }
48698 arg4 = static_cast< int >(val4);
48699 ecode5 = SWIG_AsVal_int(obj4, &val5);
48700 if (!SWIG_IsOK(ecode5)) {
48701 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
48702 }
48703 arg5 = static_cast< int >(val5);
48704 if (obj5) {
48705 arg6 = obj5;
48706 }
48707 {
48708 PyThreadState* __tstate = wxPyBeginAllowThreads();
48709 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
48710 wxPyEndAllowThreads(__tstate);
48711 if (PyErr_Occurred()) SWIG_fail;
48712 }
48713 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48714 return resultobj;
48715 fail:
48716 return NULL;
48717 }
48718
48719
48720 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48721 PyObject *resultobj = 0;
48722 wxSizer *arg1 = (wxSizer *) 0 ;
48723 int arg2 ;
48724 int arg3 ;
48725 int arg4 ;
48726 PyObject *arg5 = (PyObject *) NULL ;
48727 wxSizerItem *result = 0 ;
48728 int res1 = 0 ;
48729 int val2 ;
48730 int ecode2 = 0 ;
48731 int val3 ;
48732 int ecode3 = 0 ;
48733 int val4 ;
48734 int ecode4 = 0 ;
48735 PyObject * obj0 = 0 ;
48736 PyObject * obj1 = 0 ;
48737 PyObject * obj2 = 0 ;
48738 PyObject * obj3 = 0 ;
48739 PyObject * obj4 = 0 ;
48740 char * kwnames[] = {
48741 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48742 };
48743
48744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48745 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
48746 if (!SWIG_IsOK(res1)) {
48747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48748 }
48749 ecode2 = SWIG_AsVal_int(obj1, &val2);
48750 if (!SWIG_IsOK(ecode2)) {
48751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
48752 }
48753 arg2 = static_cast< int >(val2);
48754 ecode3 = SWIG_AsVal_int(obj2, &val3);
48755 if (!SWIG_IsOK(ecode3)) {
48756 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
48757 }
48758 arg3 = static_cast< int >(val3);
48759 ecode4 = SWIG_AsVal_int(obj3, &val4);
48760 if (!SWIG_IsOK(ecode4)) {
48761 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
48762 }
48763 arg4 = static_cast< int >(val4);
48764 if (obj4) {
48765 arg5 = obj4;
48766 }
48767 {
48768 PyThreadState* __tstate = wxPyBeginAllowThreads();
48769 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48770 wxPyEndAllowThreads(__tstate);
48771 if (PyErr_Occurred()) SWIG_fail;
48772 }
48773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48774 return resultobj;
48775 fail:
48776 return NULL;
48777 }
48778
48779
48780 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48781 PyObject *resultobj = 0;
48782 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48783 void *argp1 = 0 ;
48784 int res1 = 0 ;
48785 PyObject *swig_obj[1] ;
48786
48787 if (!args) SWIG_fail;
48788 swig_obj[0] = args;
48789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48790 if (!SWIG_IsOK(res1)) {
48791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48792 }
48793 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48794 {
48795 PyThreadState* __tstate = wxPyBeginAllowThreads();
48796 (arg1)->DeleteWindows();
48797 wxPyEndAllowThreads(__tstate);
48798 if (PyErr_Occurred()) SWIG_fail;
48799 }
48800 resultobj = SWIG_Py_Void();
48801 return resultobj;
48802 fail:
48803 return NULL;
48804 }
48805
48806
48807 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48808 PyObject *resultobj = 0;
48809 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48810 void *argp1 = 0 ;
48811 int res1 = 0 ;
48812 PyObject *swig_obj[1] ;
48813
48814 if (!args) SWIG_fail;
48815 swig_obj[0] = args;
48816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48817 if (!SWIG_IsOK(res1)) {
48818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48819 }
48820 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48821 {
48822 PyThreadState* __tstate = wxPyBeginAllowThreads();
48823 (arg1)->DetachSizer();
48824 wxPyEndAllowThreads(__tstate);
48825 if (PyErr_Occurred()) SWIG_fail;
48826 }
48827 resultobj = SWIG_Py_Void();
48828 return resultobj;
48829 fail:
48830 return NULL;
48831 }
48832
48833
48834 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48835 PyObject *resultobj = 0;
48836 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48837 wxSize result;
48838 void *argp1 = 0 ;
48839 int res1 = 0 ;
48840 PyObject *swig_obj[1] ;
48841
48842 if (!args) SWIG_fail;
48843 swig_obj[0] = args;
48844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48845 if (!SWIG_IsOK(res1)) {
48846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48847 }
48848 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48849 {
48850 PyThreadState* __tstate = wxPyBeginAllowThreads();
48851 result = (arg1)->GetSize();
48852 wxPyEndAllowThreads(__tstate);
48853 if (PyErr_Occurred()) SWIG_fail;
48854 }
48855 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48856 return resultobj;
48857 fail:
48858 return NULL;
48859 }
48860
48861
48862 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48863 PyObject *resultobj = 0;
48864 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48865 wxSize result;
48866 void *argp1 = 0 ;
48867 int res1 = 0 ;
48868 PyObject *swig_obj[1] ;
48869
48870 if (!args) SWIG_fail;
48871 swig_obj[0] = args;
48872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48873 if (!SWIG_IsOK(res1)) {
48874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48875 }
48876 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48877 {
48878 PyThreadState* __tstate = wxPyBeginAllowThreads();
48879 result = (arg1)->CalcMin();
48880 wxPyEndAllowThreads(__tstate);
48881 if (PyErr_Occurred()) SWIG_fail;
48882 }
48883 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48884 return resultobj;
48885 fail:
48886 return NULL;
48887 }
48888
48889
48890 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48891 PyObject *resultobj = 0;
48892 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48893 wxPoint *arg2 = 0 ;
48894 wxSize *arg3 = 0 ;
48895 void *argp1 = 0 ;
48896 int res1 = 0 ;
48897 wxPoint temp2 ;
48898 wxSize temp3 ;
48899 PyObject * obj0 = 0 ;
48900 PyObject * obj1 = 0 ;
48901 PyObject * obj2 = 0 ;
48902 char * kwnames[] = {
48903 (char *) "self",(char *) "pos",(char *) "size", NULL
48904 };
48905
48906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48908 if (!SWIG_IsOK(res1)) {
48909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48910 }
48911 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48912 {
48913 arg2 = &temp2;
48914 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
48915 }
48916 {
48917 arg3 = &temp3;
48918 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48919 }
48920 {
48921 PyThreadState* __tstate = wxPyBeginAllowThreads();
48922 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
48923 wxPyEndAllowThreads(__tstate);
48924 if (PyErr_Occurred()) SWIG_fail;
48925 }
48926 resultobj = SWIG_Py_Void();
48927 return resultobj;
48928 fail:
48929 return NULL;
48930 }
48931
48932
48933 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48934 PyObject *resultobj = 0;
48935 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48936 wxSize result;
48937 void *argp1 = 0 ;
48938 int res1 = 0 ;
48939 PyObject *swig_obj[1] ;
48940
48941 if (!args) SWIG_fail;
48942 swig_obj[0] = args;
48943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48944 if (!SWIG_IsOK(res1)) {
48945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48946 }
48947 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48948 {
48949 PyThreadState* __tstate = wxPyBeginAllowThreads();
48950 result = (arg1)->GetMinSize();
48951 wxPyEndAllowThreads(__tstate);
48952 if (PyErr_Occurred()) SWIG_fail;
48953 }
48954 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48955 return resultobj;
48956 fail:
48957 return NULL;
48958 }
48959
48960
48961 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48962 PyObject *resultobj = 0;
48963 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48964 wxSize result;
48965 void *argp1 = 0 ;
48966 int res1 = 0 ;
48967 PyObject *swig_obj[1] ;
48968
48969 if (!args) SWIG_fail;
48970 swig_obj[0] = args;
48971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48972 if (!SWIG_IsOK(res1)) {
48973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
48974 }
48975 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48976 {
48977 PyThreadState* __tstate = wxPyBeginAllowThreads();
48978 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
48979 wxPyEndAllowThreads(__tstate);
48980 if (PyErr_Occurred()) SWIG_fail;
48981 }
48982 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48983 return resultobj;
48984 fail:
48985 return NULL;
48986 }
48987
48988
48989 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48990 PyObject *resultobj = 0;
48991 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48992 int arg2 ;
48993 int arg3 ;
48994 void *argp1 = 0 ;
48995 int res1 = 0 ;
48996 int val2 ;
48997 int ecode2 = 0 ;
48998 int val3 ;
48999 int ecode3 = 0 ;
49000 PyObject * obj0 = 0 ;
49001 PyObject * obj1 = 0 ;
49002 PyObject * obj2 = 0 ;
49003 char * kwnames[] = {
49004 (char *) "self",(char *) "x",(char *) "y", NULL
49005 };
49006
49007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49009 if (!SWIG_IsOK(res1)) {
49010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49011 }
49012 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49013 ecode2 = SWIG_AsVal_int(obj1, &val2);
49014 if (!SWIG_IsOK(ecode2)) {
49015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
49016 }
49017 arg2 = static_cast< int >(val2);
49018 ecode3 = SWIG_AsVal_int(obj2, &val3);
49019 if (!SWIG_IsOK(ecode3)) {
49020 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
49021 }
49022 arg3 = static_cast< int >(val3);
49023 {
49024 PyThreadState* __tstate = wxPyBeginAllowThreads();
49025 (arg1)->SetInitSize(arg2,arg3);
49026 wxPyEndAllowThreads(__tstate);
49027 if (PyErr_Occurred()) SWIG_fail;
49028 }
49029 resultobj = SWIG_Py_Void();
49030 return resultobj;
49031 fail:
49032 return NULL;
49033 }
49034
49035
49036 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49037 PyObject *resultobj = 0;
49038 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49039 int arg2 ;
49040 int arg3 ;
49041 void *argp1 = 0 ;
49042 int res1 = 0 ;
49043 int val2 ;
49044 int ecode2 = 0 ;
49045 int val3 ;
49046 int ecode3 = 0 ;
49047 PyObject * obj0 = 0 ;
49048 PyObject * obj1 = 0 ;
49049 PyObject * obj2 = 0 ;
49050 char * kwnames[] = {
49051 (char *) "self",(char *) "width",(char *) "height", NULL
49052 };
49053
49054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49056 if (!SWIG_IsOK(res1)) {
49057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49058 }
49059 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49060 ecode2 = SWIG_AsVal_int(obj1, &val2);
49061 if (!SWIG_IsOK(ecode2)) {
49062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
49063 }
49064 arg2 = static_cast< int >(val2);
49065 ecode3 = SWIG_AsVal_int(obj2, &val3);
49066 if (!SWIG_IsOK(ecode3)) {
49067 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
49068 }
49069 arg3 = static_cast< int >(val3);
49070 {
49071 PyThreadState* __tstate = wxPyBeginAllowThreads();
49072 (arg1)->SetRatio(arg2,arg3);
49073 wxPyEndAllowThreads(__tstate);
49074 if (PyErr_Occurred()) SWIG_fail;
49075 }
49076 resultobj = SWIG_Py_Void();
49077 return resultobj;
49078 fail:
49079 return NULL;
49080 }
49081
49082
49083 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49084 PyObject *resultobj = 0;
49085 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49086 wxSize *arg2 = 0 ;
49087 void *argp1 = 0 ;
49088 int res1 = 0 ;
49089 wxSize temp2 ;
49090 PyObject * obj0 = 0 ;
49091 PyObject * obj1 = 0 ;
49092 char * kwnames[] = {
49093 (char *) "self",(char *) "size", NULL
49094 };
49095
49096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
49097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49098 if (!SWIG_IsOK(res1)) {
49099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49100 }
49101 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49102 {
49103 arg2 = &temp2;
49104 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49105 }
49106 {
49107 PyThreadState* __tstate = wxPyBeginAllowThreads();
49108 (arg1)->SetRatio((wxSize const &)*arg2);
49109 wxPyEndAllowThreads(__tstate);
49110 if (PyErr_Occurred()) SWIG_fail;
49111 }
49112 resultobj = SWIG_Py_Void();
49113 return resultobj;
49114 fail:
49115 return NULL;
49116 }
49117
49118
49119 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49120 PyObject *resultobj = 0;
49121 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49122 float arg2 ;
49123 void *argp1 = 0 ;
49124 int res1 = 0 ;
49125 float val2 ;
49126 int ecode2 = 0 ;
49127 PyObject * obj0 = 0 ;
49128 PyObject * obj1 = 0 ;
49129 char * kwnames[] = {
49130 (char *) "self",(char *) "ratio", NULL
49131 };
49132
49133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
49134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49135 if (!SWIG_IsOK(res1)) {
49136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49137 }
49138 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49139 ecode2 = SWIG_AsVal_float(obj1, &val2);
49140 if (!SWIG_IsOK(ecode2)) {
49141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
49142 }
49143 arg2 = static_cast< float >(val2);
49144 {
49145 PyThreadState* __tstate = wxPyBeginAllowThreads();
49146 (arg1)->SetRatio(arg2);
49147 wxPyEndAllowThreads(__tstate);
49148 if (PyErr_Occurred()) SWIG_fail;
49149 }
49150 resultobj = SWIG_Py_Void();
49151 return resultobj;
49152 fail:
49153 return NULL;
49154 }
49155
49156
49157 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49158 PyObject *resultobj = 0;
49159 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49160 float result;
49161 void *argp1 = 0 ;
49162 int res1 = 0 ;
49163 PyObject *swig_obj[1] ;
49164
49165 if (!args) SWIG_fail;
49166 swig_obj[0] = args;
49167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49168 if (!SWIG_IsOK(res1)) {
49169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49170 }
49171 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49172 {
49173 PyThreadState* __tstate = wxPyBeginAllowThreads();
49174 result = (float)(arg1)->GetRatio();
49175 wxPyEndAllowThreads(__tstate);
49176 if (PyErr_Occurred()) SWIG_fail;
49177 }
49178 resultobj = SWIG_From_float(static_cast< float >(result));
49179 return resultobj;
49180 fail:
49181 return NULL;
49182 }
49183
49184
49185 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49186 PyObject *resultobj = 0;
49187 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49188 wxRect result;
49189 void *argp1 = 0 ;
49190 int res1 = 0 ;
49191 PyObject *swig_obj[1] ;
49192
49193 if (!args) SWIG_fail;
49194 swig_obj[0] = args;
49195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49196 if (!SWIG_IsOK(res1)) {
49197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49198 }
49199 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49200 {
49201 PyThreadState* __tstate = wxPyBeginAllowThreads();
49202 result = (arg1)->GetRect();
49203 wxPyEndAllowThreads(__tstate);
49204 if (PyErr_Occurred()) SWIG_fail;
49205 }
49206 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
49207 return resultobj;
49208 fail:
49209 return NULL;
49210 }
49211
49212
49213 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49214 PyObject *resultobj = 0;
49215 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49216 bool result;
49217 void *argp1 = 0 ;
49218 int res1 = 0 ;
49219 PyObject *swig_obj[1] ;
49220
49221 if (!args) SWIG_fail;
49222 swig_obj[0] = args;
49223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49224 if (!SWIG_IsOK(res1)) {
49225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49226 }
49227 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49228 {
49229 PyThreadState* __tstate = wxPyBeginAllowThreads();
49230 result = (bool)(arg1)->IsWindow();
49231 wxPyEndAllowThreads(__tstate);
49232 if (PyErr_Occurred()) SWIG_fail;
49233 }
49234 {
49235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49236 }
49237 return resultobj;
49238 fail:
49239 return NULL;
49240 }
49241
49242
49243 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49244 PyObject *resultobj = 0;
49245 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49246 bool result;
49247 void *argp1 = 0 ;
49248 int res1 = 0 ;
49249 PyObject *swig_obj[1] ;
49250
49251 if (!args) SWIG_fail;
49252 swig_obj[0] = args;
49253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49254 if (!SWIG_IsOK(res1)) {
49255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49256 }
49257 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49258 {
49259 PyThreadState* __tstate = wxPyBeginAllowThreads();
49260 result = (bool)(arg1)->IsSizer();
49261 wxPyEndAllowThreads(__tstate);
49262 if (PyErr_Occurred()) SWIG_fail;
49263 }
49264 {
49265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49266 }
49267 return resultobj;
49268 fail:
49269 return NULL;
49270 }
49271
49272
49273 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49274 PyObject *resultobj = 0;
49275 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49276 bool result;
49277 void *argp1 = 0 ;
49278 int res1 = 0 ;
49279 PyObject *swig_obj[1] ;
49280
49281 if (!args) SWIG_fail;
49282 swig_obj[0] = args;
49283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49284 if (!SWIG_IsOK(res1)) {
49285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49286 }
49287 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49288 {
49289 PyThreadState* __tstate = wxPyBeginAllowThreads();
49290 result = (bool)(arg1)->IsSpacer();
49291 wxPyEndAllowThreads(__tstate);
49292 if (PyErr_Occurred()) SWIG_fail;
49293 }
49294 {
49295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49296 }
49297 return resultobj;
49298 fail:
49299 return NULL;
49300 }
49301
49302
49303 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49304 PyObject *resultobj = 0;
49305 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49306 int arg2 ;
49307 void *argp1 = 0 ;
49308 int res1 = 0 ;
49309 int val2 ;
49310 int ecode2 = 0 ;
49311 PyObject * obj0 = 0 ;
49312 PyObject * obj1 = 0 ;
49313 char * kwnames[] = {
49314 (char *) "self",(char *) "proportion", NULL
49315 };
49316
49317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
49318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49319 if (!SWIG_IsOK(res1)) {
49320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49321 }
49322 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49323 ecode2 = SWIG_AsVal_int(obj1, &val2);
49324 if (!SWIG_IsOK(ecode2)) {
49325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
49326 }
49327 arg2 = static_cast< int >(val2);
49328 {
49329 PyThreadState* __tstate = wxPyBeginAllowThreads();
49330 (arg1)->SetProportion(arg2);
49331 wxPyEndAllowThreads(__tstate);
49332 if (PyErr_Occurred()) SWIG_fail;
49333 }
49334 resultobj = SWIG_Py_Void();
49335 return resultobj;
49336 fail:
49337 return NULL;
49338 }
49339
49340
49341 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49342 PyObject *resultobj = 0;
49343 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49344 int result;
49345 void *argp1 = 0 ;
49346 int res1 = 0 ;
49347 PyObject *swig_obj[1] ;
49348
49349 if (!args) SWIG_fail;
49350 swig_obj[0] = args;
49351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49352 if (!SWIG_IsOK(res1)) {
49353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49354 }
49355 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49356 {
49357 PyThreadState* __tstate = wxPyBeginAllowThreads();
49358 result = (int)(arg1)->GetProportion();
49359 wxPyEndAllowThreads(__tstate);
49360 if (PyErr_Occurred()) SWIG_fail;
49361 }
49362 resultobj = SWIG_From_int(static_cast< int >(result));
49363 return resultobj;
49364 fail:
49365 return NULL;
49366 }
49367
49368
49369 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49370 PyObject *resultobj = 0;
49371 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49372 int arg2 ;
49373 void *argp1 = 0 ;
49374 int res1 = 0 ;
49375 int val2 ;
49376 int ecode2 = 0 ;
49377 PyObject * obj0 = 0 ;
49378 PyObject * obj1 = 0 ;
49379 char * kwnames[] = {
49380 (char *) "self",(char *) "flag", NULL
49381 };
49382
49383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
49384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49385 if (!SWIG_IsOK(res1)) {
49386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49387 }
49388 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49389 ecode2 = SWIG_AsVal_int(obj1, &val2);
49390 if (!SWIG_IsOK(ecode2)) {
49391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
49392 }
49393 arg2 = static_cast< int >(val2);
49394 {
49395 PyThreadState* __tstate = wxPyBeginAllowThreads();
49396 (arg1)->SetFlag(arg2);
49397 wxPyEndAllowThreads(__tstate);
49398 if (PyErr_Occurred()) SWIG_fail;
49399 }
49400 resultobj = SWIG_Py_Void();
49401 return resultobj;
49402 fail:
49403 return NULL;
49404 }
49405
49406
49407 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49408 PyObject *resultobj = 0;
49409 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49410 int result;
49411 void *argp1 = 0 ;
49412 int res1 = 0 ;
49413 PyObject *swig_obj[1] ;
49414
49415 if (!args) SWIG_fail;
49416 swig_obj[0] = args;
49417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49418 if (!SWIG_IsOK(res1)) {
49419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49420 }
49421 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49422 {
49423 PyThreadState* __tstate = wxPyBeginAllowThreads();
49424 result = (int)(arg1)->GetFlag();
49425 wxPyEndAllowThreads(__tstate);
49426 if (PyErr_Occurred()) SWIG_fail;
49427 }
49428 resultobj = SWIG_From_int(static_cast< int >(result));
49429 return resultobj;
49430 fail:
49431 return NULL;
49432 }
49433
49434
49435 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49436 PyObject *resultobj = 0;
49437 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49438 int arg2 ;
49439 void *argp1 = 0 ;
49440 int res1 = 0 ;
49441 int val2 ;
49442 int ecode2 = 0 ;
49443 PyObject * obj0 = 0 ;
49444 PyObject * obj1 = 0 ;
49445 char * kwnames[] = {
49446 (char *) "self",(char *) "border", NULL
49447 };
49448
49449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49451 if (!SWIG_IsOK(res1)) {
49452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49453 }
49454 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49455 ecode2 = SWIG_AsVal_int(obj1, &val2);
49456 if (!SWIG_IsOK(ecode2)) {
49457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
49458 }
49459 arg2 = static_cast< int >(val2);
49460 {
49461 PyThreadState* __tstate = wxPyBeginAllowThreads();
49462 (arg1)->SetBorder(arg2);
49463 wxPyEndAllowThreads(__tstate);
49464 if (PyErr_Occurred()) SWIG_fail;
49465 }
49466 resultobj = SWIG_Py_Void();
49467 return resultobj;
49468 fail:
49469 return NULL;
49470 }
49471
49472
49473 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49474 PyObject *resultobj = 0;
49475 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49476 int result;
49477 void *argp1 = 0 ;
49478 int res1 = 0 ;
49479 PyObject *swig_obj[1] ;
49480
49481 if (!args) SWIG_fail;
49482 swig_obj[0] = args;
49483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49484 if (!SWIG_IsOK(res1)) {
49485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49486 }
49487 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49488 {
49489 PyThreadState* __tstate = wxPyBeginAllowThreads();
49490 result = (int)(arg1)->GetBorder();
49491 wxPyEndAllowThreads(__tstate);
49492 if (PyErr_Occurred()) SWIG_fail;
49493 }
49494 resultobj = SWIG_From_int(static_cast< int >(result));
49495 return resultobj;
49496 fail:
49497 return NULL;
49498 }
49499
49500
49501 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49502 PyObject *resultobj = 0;
49503 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49504 wxWindow *result = 0 ;
49505 void *argp1 = 0 ;
49506 int res1 = 0 ;
49507 PyObject *swig_obj[1] ;
49508
49509 if (!args) SWIG_fail;
49510 swig_obj[0] = args;
49511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49512 if (!SWIG_IsOK(res1)) {
49513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49514 }
49515 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49516 {
49517 PyThreadState* __tstate = wxPyBeginAllowThreads();
49518 result = (wxWindow *)(arg1)->GetWindow();
49519 wxPyEndAllowThreads(__tstate);
49520 if (PyErr_Occurred()) SWIG_fail;
49521 }
49522 {
49523 resultobj = wxPyMake_wxObject(result, 0);
49524 }
49525 return resultobj;
49526 fail:
49527 return NULL;
49528 }
49529
49530
49531 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49532 PyObject *resultobj = 0;
49533 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49534 wxWindow *arg2 = (wxWindow *) 0 ;
49535 void *argp1 = 0 ;
49536 int res1 = 0 ;
49537 void *argp2 = 0 ;
49538 int res2 = 0 ;
49539 PyObject * obj0 = 0 ;
49540 PyObject * obj1 = 0 ;
49541 char * kwnames[] = {
49542 (char *) "self",(char *) "window", NULL
49543 };
49544
49545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
49546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49547 if (!SWIG_IsOK(res1)) {
49548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49549 }
49550 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49551 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49552 if (!SWIG_IsOK(res2)) {
49553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
49554 }
49555 arg2 = reinterpret_cast< wxWindow * >(argp2);
49556 {
49557 PyThreadState* __tstate = wxPyBeginAllowThreads();
49558 (arg1)->SetWindow(arg2);
49559 wxPyEndAllowThreads(__tstate);
49560 if (PyErr_Occurred()) SWIG_fail;
49561 }
49562 resultobj = SWIG_Py_Void();
49563 return resultobj;
49564 fail:
49565 return NULL;
49566 }
49567
49568
49569 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49570 PyObject *resultobj = 0;
49571 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49572 wxSizer *result = 0 ;
49573 void *argp1 = 0 ;
49574 int res1 = 0 ;
49575 PyObject *swig_obj[1] ;
49576
49577 if (!args) SWIG_fail;
49578 swig_obj[0] = args;
49579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49580 if (!SWIG_IsOK(res1)) {
49581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49582 }
49583 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49584 {
49585 PyThreadState* __tstate = wxPyBeginAllowThreads();
49586 result = (wxSizer *)(arg1)->GetSizer();
49587 wxPyEndAllowThreads(__tstate);
49588 if (PyErr_Occurred()) SWIG_fail;
49589 }
49590 {
49591 resultobj = wxPyMake_wxObject(result, (bool)0);
49592 }
49593 return resultobj;
49594 fail:
49595 return NULL;
49596 }
49597
49598
49599 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49600 PyObject *resultobj = 0;
49601 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49602 wxSizer *arg2 = (wxSizer *) 0 ;
49603 void *argp1 = 0 ;
49604 int res1 = 0 ;
49605 int res2 = 0 ;
49606 PyObject * obj0 = 0 ;
49607 PyObject * obj1 = 0 ;
49608 char * kwnames[] = {
49609 (char *) "self",(char *) "sizer", NULL
49610 };
49611
49612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49614 if (!SWIG_IsOK(res1)) {
49615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49616 }
49617 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49618 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49619 if (!SWIG_IsOK(res2)) {
49620 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
49621 }
49622 {
49623 PyThreadState* __tstate = wxPyBeginAllowThreads();
49624 (arg1)->SetSizer(arg2);
49625 wxPyEndAllowThreads(__tstate);
49626 if (PyErr_Occurred()) SWIG_fail;
49627 }
49628 resultobj = SWIG_Py_Void();
49629 return resultobj;
49630 fail:
49631 return NULL;
49632 }
49633
49634
49635 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49636 PyObject *resultobj = 0;
49637 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49638 wxSize result;
49639 void *argp1 = 0 ;
49640 int res1 = 0 ;
49641 PyObject *swig_obj[1] ;
49642
49643 if (!args) SWIG_fail;
49644 swig_obj[0] = args;
49645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49646 if (!SWIG_IsOK(res1)) {
49647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49648 }
49649 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49650 {
49651 PyThreadState* __tstate = wxPyBeginAllowThreads();
49652 result = (arg1)->GetSpacer();
49653 wxPyEndAllowThreads(__tstate);
49654 if (PyErr_Occurred()) SWIG_fail;
49655 }
49656 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49657 return resultobj;
49658 fail:
49659 return NULL;
49660 }
49661
49662
49663 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49664 PyObject *resultobj = 0;
49665 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49666 wxSize *arg2 = 0 ;
49667 void *argp1 = 0 ;
49668 int res1 = 0 ;
49669 wxSize temp2 ;
49670 PyObject * obj0 = 0 ;
49671 PyObject * obj1 = 0 ;
49672 char * kwnames[] = {
49673 (char *) "self",(char *) "size", NULL
49674 };
49675
49676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
49677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49678 if (!SWIG_IsOK(res1)) {
49679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49680 }
49681 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49682 {
49683 arg2 = &temp2;
49684 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49685 }
49686 {
49687 PyThreadState* __tstate = wxPyBeginAllowThreads();
49688 (arg1)->SetSpacer((wxSize const &)*arg2);
49689 wxPyEndAllowThreads(__tstate);
49690 if (PyErr_Occurred()) SWIG_fail;
49691 }
49692 resultobj = SWIG_Py_Void();
49693 return resultobj;
49694 fail:
49695 return NULL;
49696 }
49697
49698
49699 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49700 PyObject *resultobj = 0;
49701 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49702 bool arg2 ;
49703 void *argp1 = 0 ;
49704 int res1 = 0 ;
49705 bool val2 ;
49706 int ecode2 = 0 ;
49707 PyObject * obj0 = 0 ;
49708 PyObject * obj1 = 0 ;
49709 char * kwnames[] = {
49710 (char *) "self",(char *) "show", NULL
49711 };
49712
49713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
49714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49715 if (!SWIG_IsOK(res1)) {
49716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49717 }
49718 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49719 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49720 if (!SWIG_IsOK(ecode2)) {
49721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
49722 }
49723 arg2 = static_cast< bool >(val2);
49724 {
49725 PyThreadState* __tstate = wxPyBeginAllowThreads();
49726 (arg1)->Show(arg2);
49727 wxPyEndAllowThreads(__tstate);
49728 if (PyErr_Occurred()) SWIG_fail;
49729 }
49730 resultobj = SWIG_Py_Void();
49731 return resultobj;
49732 fail:
49733 return NULL;
49734 }
49735
49736
49737 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49738 PyObject *resultobj = 0;
49739 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49740 bool result;
49741 void *argp1 = 0 ;
49742 int res1 = 0 ;
49743 PyObject *swig_obj[1] ;
49744
49745 if (!args) SWIG_fail;
49746 swig_obj[0] = args;
49747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49748 if (!SWIG_IsOK(res1)) {
49749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49750 }
49751 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49752 {
49753 PyThreadState* __tstate = wxPyBeginAllowThreads();
49754 result = (bool)(arg1)->IsShown();
49755 wxPyEndAllowThreads(__tstate);
49756 if (PyErr_Occurred()) SWIG_fail;
49757 }
49758 {
49759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49760 }
49761 return resultobj;
49762 fail:
49763 return NULL;
49764 }
49765
49766
49767 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49768 PyObject *resultobj = 0;
49769 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49770 wxPoint result;
49771 void *argp1 = 0 ;
49772 int res1 = 0 ;
49773 PyObject *swig_obj[1] ;
49774
49775 if (!args) SWIG_fail;
49776 swig_obj[0] = args;
49777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49778 if (!SWIG_IsOK(res1)) {
49779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49780 }
49781 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49782 {
49783 PyThreadState* __tstate = wxPyBeginAllowThreads();
49784 result = (arg1)->GetPosition();
49785 wxPyEndAllowThreads(__tstate);
49786 if (PyErr_Occurred()) SWIG_fail;
49787 }
49788 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
49789 return resultobj;
49790 fail:
49791 return NULL;
49792 }
49793
49794
49795 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49796 PyObject *resultobj = 0;
49797 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49798 PyObject *result = 0 ;
49799 void *argp1 = 0 ;
49800 int res1 = 0 ;
49801 PyObject *swig_obj[1] ;
49802
49803 if (!args) SWIG_fail;
49804 swig_obj[0] = args;
49805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49806 if (!SWIG_IsOK(res1)) {
49807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49808 }
49809 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49810 {
49811 PyThreadState* __tstate = wxPyBeginAllowThreads();
49812 result = (PyObject *)wxSizerItem_GetUserData(arg1);
49813 wxPyEndAllowThreads(__tstate);
49814 if (PyErr_Occurred()) SWIG_fail;
49815 }
49816 resultobj = result;
49817 return resultobj;
49818 fail:
49819 return NULL;
49820 }
49821
49822
49823 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49824 PyObject *resultobj = 0;
49825 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49826 PyObject *arg2 = (PyObject *) 0 ;
49827 void *argp1 = 0 ;
49828 int res1 = 0 ;
49829 PyObject * obj0 = 0 ;
49830 PyObject * obj1 = 0 ;
49831 char * kwnames[] = {
49832 (char *) "self",(char *) "userData", NULL
49833 };
49834
49835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
49836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49837 if (!SWIG_IsOK(res1)) {
49838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49839 }
49840 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49841 arg2 = obj1;
49842 {
49843 PyThreadState* __tstate = wxPyBeginAllowThreads();
49844 wxSizerItem_SetUserData(arg1,arg2);
49845 wxPyEndAllowThreads(__tstate);
49846 if (PyErr_Occurred()) SWIG_fail;
49847 }
49848 resultobj = SWIG_Py_Void();
49849 return resultobj;
49850 fail:
49851 return NULL;
49852 }
49853
49854
49855 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49856 PyObject *obj;
49857 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49858 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
49859 return SWIG_Py_Void();
49860 }
49861
49862 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49863 return SWIG_Python_InitShadowInstance(args);
49864 }
49865
49866 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49867 PyObject *resultobj = 0;
49868 wxSizer *arg1 = (wxSizer *) 0 ;
49869 void *argp1 = 0 ;
49870 int res1 = 0 ;
49871 PyObject *swig_obj[1] ;
49872
49873 if (!args) SWIG_fail;
49874 swig_obj[0] = args;
49875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49876 if (!SWIG_IsOK(res1)) {
49877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49878 }
49879 arg1 = reinterpret_cast< wxSizer * >(argp1);
49880 {
49881 PyThreadState* __tstate = wxPyBeginAllowThreads();
49882 delete arg1;
49883
49884 wxPyEndAllowThreads(__tstate);
49885 if (PyErr_Occurred()) SWIG_fail;
49886 }
49887 resultobj = SWIG_Py_Void();
49888 return resultobj;
49889 fail:
49890 return NULL;
49891 }
49892
49893
49894 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49895 PyObject *resultobj = 0;
49896 wxSizer *arg1 = (wxSizer *) 0 ;
49897 PyObject *arg2 = (PyObject *) 0 ;
49898 void *argp1 = 0 ;
49899 int res1 = 0 ;
49900 PyObject * obj0 = 0 ;
49901 PyObject * obj1 = 0 ;
49902 char * kwnames[] = {
49903 (char *) "self",(char *) "_self", NULL
49904 };
49905
49906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
49907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49908 if (!SWIG_IsOK(res1)) {
49909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
49910 }
49911 arg1 = reinterpret_cast< wxSizer * >(argp1);
49912 arg2 = obj1;
49913 {
49914 PyThreadState* __tstate = wxPyBeginAllowThreads();
49915 wxSizer__setOORInfo(arg1,arg2);
49916 wxPyEndAllowThreads(__tstate);
49917 if (PyErr_Occurred()) SWIG_fail;
49918 }
49919 resultobj = SWIG_Py_Void();
49920 return resultobj;
49921 fail:
49922 return NULL;
49923 }
49924
49925
49926 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49927 PyObject *resultobj = 0;
49928 wxSizer *arg1 = (wxSizer *) 0 ;
49929 PyObject *arg2 = (PyObject *) 0 ;
49930 int arg3 = (int) 0 ;
49931 int arg4 = (int) 0 ;
49932 int arg5 = (int) 0 ;
49933 PyObject *arg6 = (PyObject *) NULL ;
49934 wxSizerItem *result = 0 ;
49935 void *argp1 = 0 ;
49936 int res1 = 0 ;
49937 int val3 ;
49938 int ecode3 = 0 ;
49939 int val4 ;
49940 int ecode4 = 0 ;
49941 int val5 ;
49942 int ecode5 = 0 ;
49943 PyObject * obj0 = 0 ;
49944 PyObject * obj1 = 0 ;
49945 PyObject * obj2 = 0 ;
49946 PyObject * obj3 = 0 ;
49947 PyObject * obj4 = 0 ;
49948 PyObject * obj5 = 0 ;
49949 char * kwnames[] = {
49950 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49951 };
49952
49953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49955 if (!SWIG_IsOK(res1)) {
49956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
49957 }
49958 arg1 = reinterpret_cast< wxSizer * >(argp1);
49959 arg2 = obj1;
49960 if (obj2) {
49961 ecode3 = SWIG_AsVal_int(obj2, &val3);
49962 if (!SWIG_IsOK(ecode3)) {
49963 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
49964 }
49965 arg3 = static_cast< int >(val3);
49966 }
49967 if (obj3) {
49968 ecode4 = SWIG_AsVal_int(obj3, &val4);
49969 if (!SWIG_IsOK(ecode4)) {
49970 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
49971 }
49972 arg4 = static_cast< int >(val4);
49973 }
49974 if (obj4) {
49975 ecode5 = SWIG_AsVal_int(obj4, &val5);
49976 if (!SWIG_IsOK(ecode5)) {
49977 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
49978 }
49979 arg5 = static_cast< int >(val5);
49980 }
49981 if (obj5) {
49982 arg6 = obj5;
49983 }
49984 {
49985 PyThreadState* __tstate = wxPyBeginAllowThreads();
49986 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
49987 wxPyEndAllowThreads(__tstate);
49988 if (PyErr_Occurred()) SWIG_fail;
49989 }
49990 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49991 return resultobj;
49992 fail:
49993 return NULL;
49994 }
49995
49996
49997 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49998 PyObject *resultobj = 0;
49999 wxSizer *arg1 = (wxSizer *) 0 ;
50000 int arg2 ;
50001 PyObject *arg3 = (PyObject *) 0 ;
50002 int arg4 = (int) 0 ;
50003 int arg5 = (int) 0 ;
50004 int arg6 = (int) 0 ;
50005 PyObject *arg7 = (PyObject *) NULL ;
50006 wxSizerItem *result = 0 ;
50007 void *argp1 = 0 ;
50008 int res1 = 0 ;
50009 int val2 ;
50010 int ecode2 = 0 ;
50011 int val4 ;
50012 int ecode4 = 0 ;
50013 int val5 ;
50014 int ecode5 = 0 ;
50015 int val6 ;
50016 int ecode6 = 0 ;
50017 PyObject * obj0 = 0 ;
50018 PyObject * obj1 = 0 ;
50019 PyObject * obj2 = 0 ;
50020 PyObject * obj3 = 0 ;
50021 PyObject * obj4 = 0 ;
50022 PyObject * obj5 = 0 ;
50023 PyObject * obj6 = 0 ;
50024 char * kwnames[] = {
50025 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50026 };
50027
50028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50030 if (!SWIG_IsOK(res1)) {
50031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
50032 }
50033 arg1 = reinterpret_cast< wxSizer * >(argp1);
50034 ecode2 = SWIG_AsVal_int(obj1, &val2);
50035 if (!SWIG_IsOK(ecode2)) {
50036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
50037 }
50038 arg2 = static_cast< int >(val2);
50039 arg3 = obj2;
50040 if (obj3) {
50041 ecode4 = SWIG_AsVal_int(obj3, &val4);
50042 if (!SWIG_IsOK(ecode4)) {
50043 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
50044 }
50045 arg4 = static_cast< int >(val4);
50046 }
50047 if (obj4) {
50048 ecode5 = SWIG_AsVal_int(obj4, &val5);
50049 if (!SWIG_IsOK(ecode5)) {
50050 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
50051 }
50052 arg5 = static_cast< int >(val5);
50053 }
50054 if (obj5) {
50055 ecode6 = SWIG_AsVal_int(obj5, &val6);
50056 if (!SWIG_IsOK(ecode6)) {
50057 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
50058 }
50059 arg6 = static_cast< int >(val6);
50060 }
50061 if (obj6) {
50062 arg7 = obj6;
50063 }
50064 {
50065 PyThreadState* __tstate = wxPyBeginAllowThreads();
50066 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
50067 wxPyEndAllowThreads(__tstate);
50068 if (PyErr_Occurred()) SWIG_fail;
50069 }
50070 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50071 return resultobj;
50072 fail:
50073 return NULL;
50074 }
50075
50076
50077 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50078 PyObject *resultobj = 0;
50079 wxSizer *arg1 = (wxSizer *) 0 ;
50080 PyObject *arg2 = (PyObject *) 0 ;
50081 int arg3 = (int) 0 ;
50082 int arg4 = (int) 0 ;
50083 int arg5 = (int) 0 ;
50084 PyObject *arg6 = (PyObject *) NULL ;
50085 wxSizerItem *result = 0 ;
50086 void *argp1 = 0 ;
50087 int res1 = 0 ;
50088 int val3 ;
50089 int ecode3 = 0 ;
50090 int val4 ;
50091 int ecode4 = 0 ;
50092 int val5 ;
50093 int ecode5 = 0 ;
50094 PyObject * obj0 = 0 ;
50095 PyObject * obj1 = 0 ;
50096 PyObject * obj2 = 0 ;
50097 PyObject * obj3 = 0 ;
50098 PyObject * obj4 = 0 ;
50099 PyObject * obj5 = 0 ;
50100 char * kwnames[] = {
50101 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50102 };
50103
50104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50106 if (!SWIG_IsOK(res1)) {
50107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
50108 }
50109 arg1 = reinterpret_cast< wxSizer * >(argp1);
50110 arg2 = obj1;
50111 if (obj2) {
50112 ecode3 = SWIG_AsVal_int(obj2, &val3);
50113 if (!SWIG_IsOK(ecode3)) {
50114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
50115 }
50116 arg3 = static_cast< int >(val3);
50117 }
50118 if (obj3) {
50119 ecode4 = SWIG_AsVal_int(obj3, &val4);
50120 if (!SWIG_IsOK(ecode4)) {
50121 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
50122 }
50123 arg4 = static_cast< int >(val4);
50124 }
50125 if (obj4) {
50126 ecode5 = SWIG_AsVal_int(obj4, &val5);
50127 if (!SWIG_IsOK(ecode5)) {
50128 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
50129 }
50130 arg5 = static_cast< int >(val5);
50131 }
50132 if (obj5) {
50133 arg6 = obj5;
50134 }
50135 {
50136 PyThreadState* __tstate = wxPyBeginAllowThreads();
50137 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
50138 wxPyEndAllowThreads(__tstate);
50139 if (PyErr_Occurred()) SWIG_fail;
50140 }
50141 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50142 return resultobj;
50143 fail:
50144 return NULL;
50145 }
50146
50147
50148 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50149 PyObject *resultobj = 0;
50150 wxSizer *arg1 = (wxSizer *) 0 ;
50151 PyObject *arg2 = (PyObject *) 0 ;
50152 bool result;
50153 void *argp1 = 0 ;
50154 int res1 = 0 ;
50155 PyObject * obj0 = 0 ;
50156 PyObject * obj1 = 0 ;
50157 char * kwnames[] = {
50158 (char *) "self",(char *) "item", NULL
50159 };
50160
50161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
50162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50163 if (!SWIG_IsOK(res1)) {
50164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
50165 }
50166 arg1 = reinterpret_cast< wxSizer * >(argp1);
50167 arg2 = obj1;
50168 {
50169 PyThreadState* __tstate = wxPyBeginAllowThreads();
50170 result = (bool)wxSizer_Remove(arg1,arg2);
50171 wxPyEndAllowThreads(__tstate);
50172 if (PyErr_Occurred()) SWIG_fail;
50173 }
50174 {
50175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50176 }
50177 return resultobj;
50178 fail:
50179 return NULL;
50180 }
50181
50182
50183 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50184 PyObject *resultobj = 0;
50185 wxSizer *arg1 = (wxSizer *) 0 ;
50186 PyObject *arg2 = (PyObject *) 0 ;
50187 bool result;
50188 void *argp1 = 0 ;
50189 int res1 = 0 ;
50190 PyObject * obj0 = 0 ;
50191 PyObject * obj1 = 0 ;
50192 char * kwnames[] = {
50193 (char *) "self",(char *) "item", NULL
50194 };
50195
50196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
50197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50198 if (!SWIG_IsOK(res1)) {
50199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
50200 }
50201 arg1 = reinterpret_cast< wxSizer * >(argp1);
50202 arg2 = obj1;
50203 {
50204 PyThreadState* __tstate = wxPyBeginAllowThreads();
50205 result = (bool)wxSizer_Detach(arg1,arg2);
50206 wxPyEndAllowThreads(__tstate);
50207 if (PyErr_Occurred()) SWIG_fail;
50208 }
50209 {
50210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50211 }
50212 return resultobj;
50213 fail:
50214 return NULL;
50215 }
50216
50217
50218 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50219 PyObject *resultobj = 0;
50220 wxSizer *arg1 = (wxSizer *) 0 ;
50221 PyObject *arg2 = (PyObject *) 0 ;
50222 wxSizerItem *result = 0 ;
50223 void *argp1 = 0 ;
50224 int res1 = 0 ;
50225 PyObject * obj0 = 0 ;
50226 PyObject * obj1 = 0 ;
50227 char * kwnames[] = {
50228 (char *) "self",(char *) "item", NULL
50229 };
50230
50231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
50232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50233 if (!SWIG_IsOK(res1)) {
50234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50235 }
50236 arg1 = reinterpret_cast< wxSizer * >(argp1);
50237 arg2 = obj1;
50238 {
50239 PyThreadState* __tstate = wxPyBeginAllowThreads();
50240 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
50241 wxPyEndAllowThreads(__tstate);
50242 if (PyErr_Occurred()) SWIG_fail;
50243 }
50244 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50245 return resultobj;
50246 fail:
50247 return NULL;
50248 }
50249
50250
50251 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50252 PyObject *resultobj = 0;
50253 wxSizer *arg1 = (wxSizer *) 0 ;
50254 PyObject *arg2 = (PyObject *) 0 ;
50255 wxSize *arg3 = 0 ;
50256 void *argp1 = 0 ;
50257 int res1 = 0 ;
50258 wxSize temp3 ;
50259 PyObject * obj0 = 0 ;
50260 PyObject * obj1 = 0 ;
50261 PyObject * obj2 = 0 ;
50262 char * kwnames[] = {
50263 (char *) "self",(char *) "item",(char *) "size", NULL
50264 };
50265
50266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50268 if (!SWIG_IsOK(res1)) {
50269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50270 }
50271 arg1 = reinterpret_cast< wxSizer * >(argp1);
50272 arg2 = obj1;
50273 {
50274 arg3 = &temp3;
50275 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50276 }
50277 {
50278 PyThreadState* __tstate = wxPyBeginAllowThreads();
50279 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
50280 wxPyEndAllowThreads(__tstate);
50281 if (PyErr_Occurred()) SWIG_fail;
50282 }
50283 resultobj = SWIG_Py_Void();
50284 return resultobj;
50285 fail:
50286 return NULL;
50287 }
50288
50289
50290 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50291 PyObject *resultobj = 0;
50292 wxSizer *arg1 = (wxSizer *) 0 ;
50293 wxWindow *arg2 = (wxWindow *) 0 ;
50294 wxWindow *arg3 = (wxWindow *) 0 ;
50295 bool arg4 = (bool) false ;
50296 bool result;
50297 void *argp1 = 0 ;
50298 int res1 = 0 ;
50299 void *argp2 = 0 ;
50300 int res2 = 0 ;
50301 void *argp3 = 0 ;
50302 int res3 = 0 ;
50303 bool val4 ;
50304 int ecode4 = 0 ;
50305 PyObject * obj0 = 0 ;
50306 PyObject * obj1 = 0 ;
50307 PyObject * obj2 = 0 ;
50308 PyObject * obj3 = 0 ;
50309 char * kwnames[] = {
50310 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
50311 };
50312
50313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50315 if (!SWIG_IsOK(res1)) {
50316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
50317 }
50318 arg1 = reinterpret_cast< wxSizer * >(argp1);
50319 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50320 if (!SWIG_IsOK(res2)) {
50321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
50322 }
50323 arg2 = reinterpret_cast< wxWindow * >(argp2);
50324 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50325 if (!SWIG_IsOK(res3)) {
50326 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
50327 }
50328 arg3 = reinterpret_cast< wxWindow * >(argp3);
50329 if (obj3) {
50330 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50331 if (!SWIG_IsOK(ecode4)) {
50332 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
50333 }
50334 arg4 = static_cast< bool >(val4);
50335 }
50336 {
50337 PyThreadState* __tstate = wxPyBeginAllowThreads();
50338 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50339 wxPyEndAllowThreads(__tstate);
50340 if (PyErr_Occurred()) SWIG_fail;
50341 }
50342 {
50343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50344 }
50345 return resultobj;
50346 fail:
50347 return NULL;
50348 }
50349
50350
50351 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50352 PyObject *resultobj = 0;
50353 wxSizer *arg1 = (wxSizer *) 0 ;
50354 wxSizer *arg2 = (wxSizer *) 0 ;
50355 wxSizer *arg3 = (wxSizer *) 0 ;
50356 bool arg4 = (bool) false ;
50357 bool result;
50358 void *argp1 = 0 ;
50359 int res1 = 0 ;
50360 void *argp2 = 0 ;
50361 int res2 = 0 ;
50362 void *argp3 = 0 ;
50363 int res3 = 0 ;
50364 bool val4 ;
50365 int ecode4 = 0 ;
50366 PyObject * obj0 = 0 ;
50367 PyObject * obj1 = 0 ;
50368 PyObject * obj2 = 0 ;
50369 PyObject * obj3 = 0 ;
50370 char * kwnames[] = {
50371 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
50372 };
50373
50374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50376 if (!SWIG_IsOK(res1)) {
50377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50378 }
50379 arg1 = reinterpret_cast< wxSizer * >(argp1);
50380 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50381 if (!SWIG_IsOK(res2)) {
50382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50383 }
50384 arg2 = reinterpret_cast< wxSizer * >(argp2);
50385 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
50386 if (!SWIG_IsOK(res3)) {
50387 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
50388 }
50389 arg3 = reinterpret_cast< wxSizer * >(argp3);
50390 if (obj3) {
50391 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50392 if (!SWIG_IsOK(ecode4)) {
50393 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
50394 }
50395 arg4 = static_cast< bool >(val4);
50396 }
50397 {
50398 PyThreadState* __tstate = wxPyBeginAllowThreads();
50399 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50400 wxPyEndAllowThreads(__tstate);
50401 if (PyErr_Occurred()) SWIG_fail;
50402 }
50403 {
50404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50405 }
50406 return resultobj;
50407 fail:
50408 return NULL;
50409 }
50410
50411
50412 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50413 PyObject *resultobj = 0;
50414 wxSizer *arg1 = (wxSizer *) 0 ;
50415 size_t arg2 ;
50416 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50417 bool result;
50418 void *argp1 = 0 ;
50419 int res1 = 0 ;
50420 size_t val2 ;
50421 int ecode2 = 0 ;
50422 void *argp3 = 0 ;
50423 int res3 = 0 ;
50424 PyObject * obj0 = 0 ;
50425 PyObject * obj1 = 0 ;
50426 PyObject * obj2 = 0 ;
50427 char * kwnames[] = {
50428 (char *) "self",(char *) "index",(char *) "newitem", NULL
50429 };
50430
50431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50433 if (!SWIG_IsOK(res1)) {
50434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50435 }
50436 arg1 = reinterpret_cast< wxSizer * >(argp1);
50437 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50438 if (!SWIG_IsOK(ecode2)) {
50439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
50440 }
50441 arg2 = static_cast< size_t >(val2);
50442 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50443 if (!SWIG_IsOK(res3)) {
50444 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50445 }
50446 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
50447 {
50448 PyThreadState* __tstate = wxPyBeginAllowThreads();
50449 result = (bool)(arg1)->Replace(arg2,arg3);
50450 wxPyEndAllowThreads(__tstate);
50451 if (PyErr_Occurred()) SWIG_fail;
50452 }
50453 {
50454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50455 }
50456 return resultobj;
50457 fail:
50458 return NULL;
50459 }
50460
50461
50462 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50463 PyObject *resultobj = 0;
50464 wxSizer *arg1 = (wxSizer *) 0 ;
50465 wxWindow *arg2 = (wxWindow *) 0 ;
50466 void *argp1 = 0 ;
50467 int res1 = 0 ;
50468 void *argp2 = 0 ;
50469 int res2 = 0 ;
50470 PyObject * obj0 = 0 ;
50471 PyObject * obj1 = 0 ;
50472 char * kwnames[] = {
50473 (char *) "self",(char *) "window", NULL
50474 };
50475
50476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50478 if (!SWIG_IsOK(res1)) {
50479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
50480 }
50481 arg1 = reinterpret_cast< wxSizer * >(argp1);
50482 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50483 if (!SWIG_IsOK(res2)) {
50484 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50485 }
50486 arg2 = reinterpret_cast< wxWindow * >(argp2);
50487 {
50488 PyThreadState* __tstate = wxPyBeginAllowThreads();
50489 (arg1)->SetContainingWindow(arg2);
50490 wxPyEndAllowThreads(__tstate);
50491 if (PyErr_Occurred()) SWIG_fail;
50492 }
50493 resultobj = SWIG_Py_Void();
50494 return resultobj;
50495 fail:
50496 return NULL;
50497 }
50498
50499
50500 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50501 PyObject *resultobj = 0;
50502 wxSizer *arg1 = (wxSizer *) 0 ;
50503 wxWindow *result = 0 ;
50504 void *argp1 = 0 ;
50505 int res1 = 0 ;
50506 PyObject *swig_obj[1] ;
50507
50508 if (!args) SWIG_fail;
50509 swig_obj[0] = args;
50510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50511 if (!SWIG_IsOK(res1)) {
50512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
50513 }
50514 arg1 = reinterpret_cast< wxSizer * >(argp1);
50515 {
50516 PyThreadState* __tstate = wxPyBeginAllowThreads();
50517 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
50518 wxPyEndAllowThreads(__tstate);
50519 if (PyErr_Occurred()) SWIG_fail;
50520 }
50521 {
50522 resultobj = wxPyMake_wxObject(result, 0);
50523 }
50524 return resultobj;
50525 fail:
50526 return NULL;
50527 }
50528
50529
50530 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50531 PyObject *resultobj = 0;
50532 wxSizer *arg1 = (wxSizer *) 0 ;
50533 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50534 wxSizerItem *result = 0 ;
50535 void *argp1 = 0 ;
50536 int res1 = 0 ;
50537 int res2 = 0 ;
50538 PyObject * obj0 = 0 ;
50539 PyObject * obj1 = 0 ;
50540 char * kwnames[] = {
50541 (char *) "self",(char *) "item", NULL
50542 };
50543
50544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50546 if (!SWIG_IsOK(res1)) {
50547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50548 }
50549 arg1 = reinterpret_cast< wxSizer * >(argp1);
50550 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50551 if (!SWIG_IsOK(res2)) {
50552 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50553 }
50554 {
50555 PyThreadState* __tstate = wxPyBeginAllowThreads();
50556 result = (wxSizerItem *)(arg1)->Add(arg2);
50557 wxPyEndAllowThreads(__tstate);
50558 if (PyErr_Occurred()) SWIG_fail;
50559 }
50560 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50561 return resultobj;
50562 fail:
50563 return NULL;
50564 }
50565
50566
50567 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50568 PyObject *resultobj = 0;
50569 wxSizer *arg1 = (wxSizer *) 0 ;
50570 size_t arg2 ;
50571 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50572 wxSizerItem *result = 0 ;
50573 void *argp1 = 0 ;
50574 int res1 = 0 ;
50575 size_t val2 ;
50576 int ecode2 = 0 ;
50577 int res3 = 0 ;
50578 PyObject * obj0 = 0 ;
50579 PyObject * obj1 = 0 ;
50580 PyObject * obj2 = 0 ;
50581 char * kwnames[] = {
50582 (char *) "self",(char *) "index",(char *) "item", NULL
50583 };
50584
50585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50587 if (!SWIG_IsOK(res1)) {
50588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50589 }
50590 arg1 = reinterpret_cast< wxSizer * >(argp1);
50591 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50592 if (!SWIG_IsOK(ecode2)) {
50593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
50594 }
50595 arg2 = static_cast< size_t >(val2);
50596 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50597 if (!SWIG_IsOK(res3)) {
50598 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50599 }
50600 {
50601 PyThreadState* __tstate = wxPyBeginAllowThreads();
50602 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
50603 wxPyEndAllowThreads(__tstate);
50604 if (PyErr_Occurred()) SWIG_fail;
50605 }
50606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50607 return resultobj;
50608 fail:
50609 return NULL;
50610 }
50611
50612
50613 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50614 PyObject *resultobj = 0;
50615 wxSizer *arg1 = (wxSizer *) 0 ;
50616 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50617 wxSizerItem *result = 0 ;
50618 void *argp1 = 0 ;
50619 int res1 = 0 ;
50620 int res2 = 0 ;
50621 PyObject * obj0 = 0 ;
50622 PyObject * obj1 = 0 ;
50623 char * kwnames[] = {
50624 (char *) "self",(char *) "item", NULL
50625 };
50626
50627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
50628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50629 if (!SWIG_IsOK(res1)) {
50630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50631 }
50632 arg1 = reinterpret_cast< wxSizer * >(argp1);
50633 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50634 if (!SWIG_IsOK(res2)) {
50635 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50636 }
50637 {
50638 PyThreadState* __tstate = wxPyBeginAllowThreads();
50639 result = (wxSizerItem *)(arg1)->Prepend(arg2);
50640 wxPyEndAllowThreads(__tstate);
50641 if (PyErr_Occurred()) SWIG_fail;
50642 }
50643 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50644 return resultobj;
50645 fail:
50646 return NULL;
50647 }
50648
50649
50650 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50651 PyObject *resultobj = 0;
50652 wxSizer *arg1 = (wxSizer *) 0 ;
50653 int arg2 ;
50654 int arg3 ;
50655 int arg4 ;
50656 int arg5 ;
50657 void *argp1 = 0 ;
50658 int res1 = 0 ;
50659 int val2 ;
50660 int ecode2 = 0 ;
50661 int val3 ;
50662 int ecode3 = 0 ;
50663 int val4 ;
50664 int ecode4 = 0 ;
50665 int val5 ;
50666 int ecode5 = 0 ;
50667 PyObject * obj0 = 0 ;
50668 PyObject * obj1 = 0 ;
50669 PyObject * obj2 = 0 ;
50670 PyObject * obj3 = 0 ;
50671 PyObject * obj4 = 0 ;
50672 char * kwnames[] = {
50673 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
50674 };
50675
50676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50678 if (!SWIG_IsOK(res1)) {
50679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
50680 }
50681 arg1 = reinterpret_cast< wxSizer * >(argp1);
50682 ecode2 = SWIG_AsVal_int(obj1, &val2);
50683 if (!SWIG_IsOK(ecode2)) {
50684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
50685 }
50686 arg2 = static_cast< int >(val2);
50687 ecode3 = SWIG_AsVal_int(obj2, &val3);
50688 if (!SWIG_IsOK(ecode3)) {
50689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
50690 }
50691 arg3 = static_cast< int >(val3);
50692 ecode4 = SWIG_AsVal_int(obj3, &val4);
50693 if (!SWIG_IsOK(ecode4)) {
50694 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
50695 }
50696 arg4 = static_cast< int >(val4);
50697 ecode5 = SWIG_AsVal_int(obj4, &val5);
50698 if (!SWIG_IsOK(ecode5)) {
50699 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
50700 }
50701 arg5 = static_cast< int >(val5);
50702 {
50703 PyThreadState* __tstate = wxPyBeginAllowThreads();
50704 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
50705 wxPyEndAllowThreads(__tstate);
50706 if (PyErr_Occurred()) SWIG_fail;
50707 }
50708 resultobj = SWIG_Py_Void();
50709 return resultobj;
50710 fail:
50711 return NULL;
50712 }
50713
50714
50715 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50716 PyObject *resultobj = 0;
50717 wxSizer *arg1 = (wxSizer *) 0 ;
50718 wxSize *arg2 = 0 ;
50719 void *argp1 = 0 ;
50720 int res1 = 0 ;
50721 wxSize temp2 ;
50722 PyObject * obj0 = 0 ;
50723 PyObject * obj1 = 0 ;
50724 char * kwnames[] = {
50725 (char *) "self",(char *) "size", NULL
50726 };
50727
50728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
50729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50730 if (!SWIG_IsOK(res1)) {
50731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50732 }
50733 arg1 = reinterpret_cast< wxSizer * >(argp1);
50734 {
50735 arg2 = &temp2;
50736 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50737 }
50738 {
50739 PyThreadState* __tstate = wxPyBeginAllowThreads();
50740 (arg1)->SetMinSize((wxSize const &)*arg2);
50741 wxPyEndAllowThreads(__tstate);
50742 if (PyErr_Occurred()) SWIG_fail;
50743 }
50744 resultobj = SWIG_Py_Void();
50745 return resultobj;
50746 fail:
50747 return NULL;
50748 }
50749
50750
50751 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50752 PyObject *resultobj = 0;
50753 wxSizer *arg1 = (wxSizer *) 0 ;
50754 wxSize result;
50755 void *argp1 = 0 ;
50756 int res1 = 0 ;
50757 PyObject *swig_obj[1] ;
50758
50759 if (!args) SWIG_fail;
50760 swig_obj[0] = args;
50761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50762 if (!SWIG_IsOK(res1)) {
50763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50764 }
50765 arg1 = reinterpret_cast< wxSizer * >(argp1);
50766 {
50767 PyThreadState* __tstate = wxPyBeginAllowThreads();
50768 result = (arg1)->GetSize();
50769 wxPyEndAllowThreads(__tstate);
50770 if (PyErr_Occurred()) SWIG_fail;
50771 }
50772 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50773 return resultobj;
50774 fail:
50775 return NULL;
50776 }
50777
50778
50779 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50780 PyObject *resultobj = 0;
50781 wxSizer *arg1 = (wxSizer *) 0 ;
50782 wxPoint result;
50783 void *argp1 = 0 ;
50784 int res1 = 0 ;
50785 PyObject *swig_obj[1] ;
50786
50787 if (!args) SWIG_fail;
50788 swig_obj[0] = args;
50789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50790 if (!SWIG_IsOK(res1)) {
50791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
50792 }
50793 arg1 = reinterpret_cast< wxSizer * >(argp1);
50794 {
50795 PyThreadState* __tstate = wxPyBeginAllowThreads();
50796 result = (arg1)->GetPosition();
50797 wxPyEndAllowThreads(__tstate);
50798 if (PyErr_Occurred()) SWIG_fail;
50799 }
50800 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50801 return resultobj;
50802 fail:
50803 return NULL;
50804 }
50805
50806
50807 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50808 PyObject *resultobj = 0;
50809 wxSizer *arg1 = (wxSizer *) 0 ;
50810 wxSize result;
50811 void *argp1 = 0 ;
50812 int res1 = 0 ;
50813 PyObject *swig_obj[1] ;
50814
50815 if (!args) SWIG_fail;
50816 swig_obj[0] = args;
50817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50818 if (!SWIG_IsOK(res1)) {
50819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50820 }
50821 arg1 = reinterpret_cast< wxSizer * >(argp1);
50822 {
50823 PyThreadState* __tstate = wxPyBeginAllowThreads();
50824 result = (arg1)->GetMinSize();
50825 wxPyEndAllowThreads(__tstate);
50826 if (PyErr_Occurred()) SWIG_fail;
50827 }
50828 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50829 return resultobj;
50830 fail:
50831 return NULL;
50832 }
50833
50834
50835 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50836 PyObject *resultobj = 0;
50837 wxSizer *arg1 = (wxSizer *) 0 ;
50838 void *argp1 = 0 ;
50839 int res1 = 0 ;
50840 PyObject *swig_obj[1] ;
50841
50842 if (!args) SWIG_fail;
50843 swig_obj[0] = args;
50844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50845 if (!SWIG_IsOK(res1)) {
50846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
50847 }
50848 arg1 = reinterpret_cast< wxSizer * >(argp1);
50849 {
50850 PyThreadState* __tstate = wxPyBeginAllowThreads();
50851 (arg1)->RecalcSizes();
50852 wxPyEndAllowThreads(__tstate);
50853 if (PyErr_Occurred()) SWIG_fail;
50854 }
50855 resultobj = SWIG_Py_Void();
50856 return resultobj;
50857 fail:
50858 return NULL;
50859 }
50860
50861
50862 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50863 PyObject *resultobj = 0;
50864 wxSizer *arg1 = (wxSizer *) 0 ;
50865 wxSize result;
50866 void *argp1 = 0 ;
50867 int res1 = 0 ;
50868 PyObject *swig_obj[1] ;
50869
50870 if (!args) SWIG_fail;
50871 swig_obj[0] = args;
50872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50873 if (!SWIG_IsOK(res1)) {
50874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
50875 }
50876 arg1 = reinterpret_cast< wxSizer * >(argp1);
50877 {
50878 PyThreadState* __tstate = wxPyBeginAllowThreads();
50879 result = (arg1)->CalcMin();
50880 wxPyEndAllowThreads(__tstate);
50881 if (PyErr_Occurred()) SWIG_fail;
50882 }
50883 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50884 return resultobj;
50885 fail:
50886 return NULL;
50887 }
50888
50889
50890 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50891 PyObject *resultobj = 0;
50892 wxSizer *arg1 = (wxSizer *) 0 ;
50893 void *argp1 = 0 ;
50894 int res1 = 0 ;
50895 PyObject *swig_obj[1] ;
50896
50897 if (!args) SWIG_fail;
50898 swig_obj[0] = args;
50899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50900 if (!SWIG_IsOK(res1)) {
50901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
50902 }
50903 arg1 = reinterpret_cast< wxSizer * >(argp1);
50904 {
50905 PyThreadState* __tstate = wxPyBeginAllowThreads();
50906 (arg1)->Layout();
50907 wxPyEndAllowThreads(__tstate);
50908 if (PyErr_Occurred()) SWIG_fail;
50909 }
50910 resultobj = SWIG_Py_Void();
50911 return resultobj;
50912 fail:
50913 return NULL;
50914 }
50915
50916
50917 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50918 PyObject *resultobj = 0;
50919 wxSizer *arg1 = (wxSizer *) 0 ;
50920 wxWindow *arg2 = (wxWindow *) 0 ;
50921 wxSize result;
50922 void *argp1 = 0 ;
50923 int res1 = 0 ;
50924 void *argp2 = 0 ;
50925 int res2 = 0 ;
50926 PyObject * obj0 = 0 ;
50927 PyObject * obj1 = 0 ;
50928 char * kwnames[] = {
50929 (char *) "self",(char *) "window", NULL
50930 };
50931
50932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
50933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50934 if (!SWIG_IsOK(res1)) {
50935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
50936 }
50937 arg1 = reinterpret_cast< wxSizer * >(argp1);
50938 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50939 if (!SWIG_IsOK(res2)) {
50940 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
50941 }
50942 arg2 = reinterpret_cast< wxWindow * >(argp2);
50943 {
50944 PyThreadState* __tstate = wxPyBeginAllowThreads();
50945 result = (arg1)->Fit(arg2);
50946 wxPyEndAllowThreads(__tstate);
50947 if (PyErr_Occurred()) SWIG_fail;
50948 }
50949 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50950 return resultobj;
50951 fail:
50952 return NULL;
50953 }
50954
50955
50956 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50957 PyObject *resultobj = 0;
50958 wxSizer *arg1 = (wxSizer *) 0 ;
50959 wxWindow *arg2 = (wxWindow *) 0 ;
50960 void *argp1 = 0 ;
50961 int res1 = 0 ;
50962 void *argp2 = 0 ;
50963 int res2 = 0 ;
50964 PyObject * obj0 = 0 ;
50965 PyObject * obj1 = 0 ;
50966 char * kwnames[] = {
50967 (char *) "self",(char *) "window", NULL
50968 };
50969
50970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
50971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50972 if (!SWIG_IsOK(res1)) {
50973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
50974 }
50975 arg1 = reinterpret_cast< wxSizer * >(argp1);
50976 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50977 if (!SWIG_IsOK(res2)) {
50978 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
50979 }
50980 arg2 = reinterpret_cast< wxWindow * >(argp2);
50981 {
50982 PyThreadState* __tstate = wxPyBeginAllowThreads();
50983 (arg1)->FitInside(arg2);
50984 wxPyEndAllowThreads(__tstate);
50985 if (PyErr_Occurred()) SWIG_fail;
50986 }
50987 resultobj = SWIG_Py_Void();
50988 return resultobj;
50989 fail:
50990 return NULL;
50991 }
50992
50993
50994 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50995 PyObject *resultobj = 0;
50996 wxSizer *arg1 = (wxSizer *) 0 ;
50997 wxWindow *arg2 = (wxWindow *) 0 ;
50998 void *argp1 = 0 ;
50999 int res1 = 0 ;
51000 void *argp2 = 0 ;
51001 int res2 = 0 ;
51002 PyObject * obj0 = 0 ;
51003 PyObject * obj1 = 0 ;
51004 char * kwnames[] = {
51005 (char *) "self",(char *) "window", NULL
51006 };
51007
51008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
51009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51010 if (!SWIG_IsOK(res1)) {
51011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
51012 }
51013 arg1 = reinterpret_cast< wxSizer * >(argp1);
51014 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51015 if (!SWIG_IsOK(res2)) {
51016 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
51017 }
51018 arg2 = reinterpret_cast< wxWindow * >(argp2);
51019 {
51020 PyThreadState* __tstate = wxPyBeginAllowThreads();
51021 (arg1)->SetSizeHints(arg2);
51022 wxPyEndAllowThreads(__tstate);
51023 if (PyErr_Occurred()) SWIG_fail;
51024 }
51025 resultobj = SWIG_Py_Void();
51026 return resultobj;
51027 fail:
51028 return NULL;
51029 }
51030
51031
51032 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51033 PyObject *resultobj = 0;
51034 wxSizer *arg1 = (wxSizer *) 0 ;
51035 wxWindow *arg2 = (wxWindow *) 0 ;
51036 void *argp1 = 0 ;
51037 int res1 = 0 ;
51038 void *argp2 = 0 ;
51039 int res2 = 0 ;
51040 PyObject * obj0 = 0 ;
51041 PyObject * obj1 = 0 ;
51042 char * kwnames[] = {
51043 (char *) "self",(char *) "window", NULL
51044 };
51045
51046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
51047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51048 if (!SWIG_IsOK(res1)) {
51049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
51050 }
51051 arg1 = reinterpret_cast< wxSizer * >(argp1);
51052 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51053 if (!SWIG_IsOK(res2)) {
51054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
51055 }
51056 arg2 = reinterpret_cast< wxWindow * >(argp2);
51057 {
51058 PyThreadState* __tstate = wxPyBeginAllowThreads();
51059 (arg1)->SetVirtualSizeHints(arg2);
51060 wxPyEndAllowThreads(__tstate);
51061 if (PyErr_Occurred()) SWIG_fail;
51062 }
51063 resultobj = SWIG_Py_Void();
51064 return resultobj;
51065 fail:
51066 return NULL;
51067 }
51068
51069
51070 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51071 PyObject *resultobj = 0;
51072 wxSizer *arg1 = (wxSizer *) 0 ;
51073 bool arg2 = (bool) false ;
51074 void *argp1 = 0 ;
51075 int res1 = 0 ;
51076 bool val2 ;
51077 int ecode2 = 0 ;
51078 PyObject * obj0 = 0 ;
51079 PyObject * obj1 = 0 ;
51080 char * kwnames[] = {
51081 (char *) "self",(char *) "deleteWindows", NULL
51082 };
51083
51084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
51085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51086 if (!SWIG_IsOK(res1)) {
51087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
51088 }
51089 arg1 = reinterpret_cast< wxSizer * >(argp1);
51090 if (obj1) {
51091 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51092 if (!SWIG_IsOK(ecode2)) {
51093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
51094 }
51095 arg2 = static_cast< bool >(val2);
51096 }
51097 {
51098 PyThreadState* __tstate = wxPyBeginAllowThreads();
51099 (arg1)->Clear(arg2);
51100 wxPyEndAllowThreads(__tstate);
51101 if (PyErr_Occurred()) SWIG_fail;
51102 }
51103 resultobj = SWIG_Py_Void();
51104 return resultobj;
51105 fail:
51106 return NULL;
51107 }
51108
51109
51110 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51111 PyObject *resultobj = 0;
51112 wxSizer *arg1 = (wxSizer *) 0 ;
51113 void *argp1 = 0 ;
51114 int res1 = 0 ;
51115 PyObject *swig_obj[1] ;
51116
51117 if (!args) SWIG_fail;
51118 swig_obj[0] = args;
51119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51120 if (!SWIG_IsOK(res1)) {
51121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
51122 }
51123 arg1 = reinterpret_cast< wxSizer * >(argp1);
51124 {
51125 PyThreadState* __tstate = wxPyBeginAllowThreads();
51126 (arg1)->DeleteWindows();
51127 wxPyEndAllowThreads(__tstate);
51128 if (PyErr_Occurred()) SWIG_fail;
51129 }
51130 resultobj = SWIG_Py_Void();
51131 return resultobj;
51132 fail:
51133 return NULL;
51134 }
51135
51136
51137 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51138 PyObject *resultobj = 0;
51139 wxSizer *arg1 = (wxSizer *) 0 ;
51140 PyObject *result = 0 ;
51141 void *argp1 = 0 ;
51142 int res1 = 0 ;
51143 PyObject *swig_obj[1] ;
51144
51145 if (!args) SWIG_fail;
51146 swig_obj[0] = args;
51147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51148 if (!SWIG_IsOK(res1)) {
51149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
51150 }
51151 arg1 = reinterpret_cast< wxSizer * >(argp1);
51152 {
51153 PyThreadState* __tstate = wxPyBeginAllowThreads();
51154 result = (PyObject *)wxSizer_GetChildren(arg1);
51155 wxPyEndAllowThreads(__tstate);
51156 if (PyErr_Occurred()) SWIG_fail;
51157 }
51158 resultobj = result;
51159 return resultobj;
51160 fail:
51161 return NULL;
51162 }
51163
51164
51165 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51166 PyObject *resultobj = 0;
51167 wxSizer *arg1 = (wxSizer *) 0 ;
51168 PyObject *arg2 = (PyObject *) 0 ;
51169 bool arg3 = (bool) true ;
51170 bool arg4 = (bool) false ;
51171 bool result;
51172 void *argp1 = 0 ;
51173 int res1 = 0 ;
51174 bool val3 ;
51175 int ecode3 = 0 ;
51176 bool val4 ;
51177 int ecode4 = 0 ;
51178 PyObject * obj0 = 0 ;
51179 PyObject * obj1 = 0 ;
51180 PyObject * obj2 = 0 ;
51181 PyObject * obj3 = 0 ;
51182 char * kwnames[] = {
51183 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
51184 };
51185
51186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51188 if (!SWIG_IsOK(res1)) {
51189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
51190 }
51191 arg1 = reinterpret_cast< wxSizer * >(argp1);
51192 arg2 = obj1;
51193 if (obj2) {
51194 ecode3 = SWIG_AsVal_bool(obj2, &val3);
51195 if (!SWIG_IsOK(ecode3)) {
51196 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
51197 }
51198 arg3 = static_cast< bool >(val3);
51199 }
51200 if (obj3) {
51201 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51202 if (!SWIG_IsOK(ecode4)) {
51203 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
51204 }
51205 arg4 = static_cast< bool >(val4);
51206 }
51207 {
51208 PyThreadState* __tstate = wxPyBeginAllowThreads();
51209 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
51210 wxPyEndAllowThreads(__tstate);
51211 if (PyErr_Occurred()) SWIG_fail;
51212 }
51213 {
51214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51215 }
51216 return resultobj;
51217 fail:
51218 return NULL;
51219 }
51220
51221
51222 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51223 PyObject *resultobj = 0;
51224 wxSizer *arg1 = (wxSizer *) 0 ;
51225 PyObject *arg2 = (PyObject *) 0 ;
51226 bool result;
51227 void *argp1 = 0 ;
51228 int res1 = 0 ;
51229 PyObject * obj0 = 0 ;
51230 PyObject * obj1 = 0 ;
51231 char * kwnames[] = {
51232 (char *) "self",(char *) "item", NULL
51233 };
51234
51235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
51236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51237 if (!SWIG_IsOK(res1)) {
51238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
51239 }
51240 arg1 = reinterpret_cast< wxSizer * >(argp1);
51241 arg2 = obj1;
51242 {
51243 PyThreadState* __tstate = wxPyBeginAllowThreads();
51244 result = (bool)wxSizer_IsShown(arg1,arg2);
51245 wxPyEndAllowThreads(__tstate);
51246 if (PyErr_Occurred()) SWIG_fail;
51247 }
51248 {
51249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51250 }
51251 return resultobj;
51252 fail:
51253 return NULL;
51254 }
51255
51256
51257 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51258 PyObject *resultobj = 0;
51259 wxSizer *arg1 = (wxSizer *) 0 ;
51260 bool arg2 ;
51261 void *argp1 = 0 ;
51262 int res1 = 0 ;
51263 bool val2 ;
51264 int ecode2 = 0 ;
51265 PyObject * obj0 = 0 ;
51266 PyObject * obj1 = 0 ;
51267 char * kwnames[] = {
51268 (char *) "self",(char *) "show", NULL
51269 };
51270
51271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
51272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51273 if (!SWIG_IsOK(res1)) {
51274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
51275 }
51276 arg1 = reinterpret_cast< wxSizer * >(argp1);
51277 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51278 if (!SWIG_IsOK(ecode2)) {
51279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
51280 }
51281 arg2 = static_cast< bool >(val2);
51282 {
51283 PyThreadState* __tstate = wxPyBeginAllowThreads();
51284 (arg1)->ShowItems(arg2);
51285 wxPyEndAllowThreads(__tstate);
51286 if (PyErr_Occurred()) SWIG_fail;
51287 }
51288 resultobj = SWIG_Py_Void();
51289 return resultobj;
51290 fail:
51291 return NULL;
51292 }
51293
51294
51295 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51296 PyObject *obj;
51297 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51298 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
51299 return SWIG_Py_Void();
51300 }
51301
51302 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51303 PyObject *resultobj = 0;
51304 wxPySizer *result = 0 ;
51305
51306 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
51307 {
51308 PyThreadState* __tstate = wxPyBeginAllowThreads();
51309 result = (wxPySizer *)new wxPySizer();
51310 wxPyEndAllowThreads(__tstate);
51311 if (PyErr_Occurred()) SWIG_fail;
51312 }
51313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
51314 return resultobj;
51315 fail:
51316 return NULL;
51317 }
51318
51319
51320 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51321 PyObject *resultobj = 0;
51322 wxPySizer *arg1 = (wxPySizer *) 0 ;
51323 PyObject *arg2 = (PyObject *) 0 ;
51324 PyObject *arg3 = (PyObject *) 0 ;
51325 void *argp1 = 0 ;
51326 int res1 = 0 ;
51327 PyObject * obj0 = 0 ;
51328 PyObject * obj1 = 0 ;
51329 PyObject * obj2 = 0 ;
51330 char * kwnames[] = {
51331 (char *) "self",(char *) "self",(char *) "_class", NULL
51332 };
51333
51334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
51336 if (!SWIG_IsOK(res1)) {
51337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
51338 }
51339 arg1 = reinterpret_cast< wxPySizer * >(argp1);
51340 arg2 = obj1;
51341 arg3 = obj2;
51342 {
51343 PyThreadState* __tstate = wxPyBeginAllowThreads();
51344 (arg1)->_setCallbackInfo(arg2,arg3);
51345 wxPyEndAllowThreads(__tstate);
51346 if (PyErr_Occurred()) SWIG_fail;
51347 }
51348 resultobj = SWIG_Py_Void();
51349 return resultobj;
51350 fail:
51351 return NULL;
51352 }
51353
51354
51355 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51356 PyObject *obj;
51357 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51358 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
51359 return SWIG_Py_Void();
51360 }
51361
51362 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51363 return SWIG_Python_InitShadowInstance(args);
51364 }
51365
51366 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51367 PyObject *resultobj = 0;
51368 int arg1 = (int) wxHORIZONTAL ;
51369 wxBoxSizer *result = 0 ;
51370 int val1 ;
51371 int ecode1 = 0 ;
51372 PyObject * obj0 = 0 ;
51373 char * kwnames[] = {
51374 (char *) "orient", NULL
51375 };
51376
51377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
51378 if (obj0) {
51379 ecode1 = SWIG_AsVal_int(obj0, &val1);
51380 if (!SWIG_IsOK(ecode1)) {
51381 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
51382 }
51383 arg1 = static_cast< int >(val1);
51384 }
51385 {
51386 PyThreadState* __tstate = wxPyBeginAllowThreads();
51387 result = (wxBoxSizer *)new wxBoxSizer(arg1);
51388 wxPyEndAllowThreads(__tstate);
51389 if (PyErr_Occurred()) SWIG_fail;
51390 }
51391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
51392 return resultobj;
51393 fail:
51394 return NULL;
51395 }
51396
51397
51398 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51399 PyObject *resultobj = 0;
51400 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51401 int result;
51402 void *argp1 = 0 ;
51403 int res1 = 0 ;
51404 PyObject *swig_obj[1] ;
51405
51406 if (!args) SWIG_fail;
51407 swig_obj[0] = args;
51408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51409 if (!SWIG_IsOK(res1)) {
51410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51411 }
51412 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51413 {
51414 PyThreadState* __tstate = wxPyBeginAllowThreads();
51415 result = (int)(arg1)->GetOrientation();
51416 wxPyEndAllowThreads(__tstate);
51417 if (PyErr_Occurred()) SWIG_fail;
51418 }
51419 resultobj = SWIG_From_int(static_cast< int >(result));
51420 return resultobj;
51421 fail:
51422 return NULL;
51423 }
51424
51425
51426 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51427 PyObject *resultobj = 0;
51428 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51429 int arg2 ;
51430 void *argp1 = 0 ;
51431 int res1 = 0 ;
51432 int val2 ;
51433 int ecode2 = 0 ;
51434 PyObject * obj0 = 0 ;
51435 PyObject * obj1 = 0 ;
51436 char * kwnames[] = {
51437 (char *) "self",(char *) "orient", NULL
51438 };
51439
51440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
51441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51442 if (!SWIG_IsOK(res1)) {
51443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51444 }
51445 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51446 ecode2 = SWIG_AsVal_int(obj1, &val2);
51447 if (!SWIG_IsOK(ecode2)) {
51448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
51449 }
51450 arg2 = static_cast< int >(val2);
51451 {
51452 PyThreadState* __tstate = wxPyBeginAllowThreads();
51453 (arg1)->SetOrientation(arg2);
51454 wxPyEndAllowThreads(__tstate);
51455 if (PyErr_Occurred()) SWIG_fail;
51456 }
51457 resultobj = SWIG_Py_Void();
51458 return resultobj;
51459 fail:
51460 return NULL;
51461 }
51462
51463
51464 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51465 PyObject *obj;
51466 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51467 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
51468 return SWIG_Py_Void();
51469 }
51470
51471 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51472 return SWIG_Python_InitShadowInstance(args);
51473 }
51474
51475 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51476 PyObject *resultobj = 0;
51477 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
51478 int arg2 = (int) wxHORIZONTAL ;
51479 wxStaticBoxSizer *result = 0 ;
51480 void *argp1 = 0 ;
51481 int res1 = 0 ;
51482 int val2 ;
51483 int ecode2 = 0 ;
51484 PyObject * obj0 = 0 ;
51485 PyObject * obj1 = 0 ;
51486 char * kwnames[] = {
51487 (char *) "box",(char *) "orient", NULL
51488 };
51489
51490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
51492 if (!SWIG_IsOK(res1)) {
51493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
51494 }
51495 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
51496 if (obj1) {
51497 ecode2 = SWIG_AsVal_int(obj1, &val2);
51498 if (!SWIG_IsOK(ecode2)) {
51499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
51500 }
51501 arg2 = static_cast< int >(val2);
51502 }
51503 {
51504 PyThreadState* __tstate = wxPyBeginAllowThreads();
51505 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
51506 wxPyEndAllowThreads(__tstate);
51507 if (PyErr_Occurred()) SWIG_fail;
51508 }
51509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
51510 return resultobj;
51511 fail:
51512 return NULL;
51513 }
51514
51515
51516 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51517 PyObject *resultobj = 0;
51518 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
51519 wxStaticBox *result = 0 ;
51520 void *argp1 = 0 ;
51521 int res1 = 0 ;
51522 PyObject *swig_obj[1] ;
51523
51524 if (!args) SWIG_fail;
51525 swig_obj[0] = args;
51526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
51527 if (!SWIG_IsOK(res1)) {
51528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
51529 }
51530 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
51531 {
51532 PyThreadState* __tstate = wxPyBeginAllowThreads();
51533 result = (wxStaticBox *)(arg1)->GetStaticBox();
51534 wxPyEndAllowThreads(__tstate);
51535 if (PyErr_Occurred()) SWIG_fail;
51536 }
51537 {
51538 resultobj = wxPyMake_wxObject(result, (bool)0);
51539 }
51540 return resultobj;
51541 fail:
51542 return NULL;
51543 }
51544
51545
51546 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51547 PyObject *obj;
51548 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51549 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
51550 return SWIG_Py_Void();
51551 }
51552
51553 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51554 return SWIG_Python_InitShadowInstance(args);
51555 }
51556
51557 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51558 PyObject *resultobj = 0;
51559 int arg1 = (int) 1 ;
51560 int arg2 = (int) 0 ;
51561 int arg3 = (int) 0 ;
51562 int arg4 = (int) 0 ;
51563 wxGridSizer *result = 0 ;
51564 int val1 ;
51565 int ecode1 = 0 ;
51566 int val2 ;
51567 int ecode2 = 0 ;
51568 int val3 ;
51569 int ecode3 = 0 ;
51570 int val4 ;
51571 int ecode4 = 0 ;
51572 PyObject * obj0 = 0 ;
51573 PyObject * obj1 = 0 ;
51574 PyObject * obj2 = 0 ;
51575 PyObject * obj3 = 0 ;
51576 char * kwnames[] = {
51577 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51578 };
51579
51580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51581 if (obj0) {
51582 ecode1 = SWIG_AsVal_int(obj0, &val1);
51583 if (!SWIG_IsOK(ecode1)) {
51584 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
51585 }
51586 arg1 = static_cast< int >(val1);
51587 }
51588 if (obj1) {
51589 ecode2 = SWIG_AsVal_int(obj1, &val2);
51590 if (!SWIG_IsOK(ecode2)) {
51591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
51592 }
51593 arg2 = static_cast< int >(val2);
51594 }
51595 if (obj2) {
51596 ecode3 = SWIG_AsVal_int(obj2, &val3);
51597 if (!SWIG_IsOK(ecode3)) {
51598 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
51599 }
51600 arg3 = static_cast< int >(val3);
51601 }
51602 if (obj3) {
51603 ecode4 = SWIG_AsVal_int(obj3, &val4);
51604 if (!SWIG_IsOK(ecode4)) {
51605 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
51606 }
51607 arg4 = static_cast< int >(val4);
51608 }
51609 {
51610 PyThreadState* __tstate = wxPyBeginAllowThreads();
51611 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
51612 wxPyEndAllowThreads(__tstate);
51613 if (PyErr_Occurred()) SWIG_fail;
51614 }
51615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
51616 return resultobj;
51617 fail:
51618 return NULL;
51619 }
51620
51621
51622 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51623 PyObject *resultobj = 0;
51624 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51625 int arg2 ;
51626 void *argp1 = 0 ;
51627 int res1 = 0 ;
51628 int val2 ;
51629 int ecode2 = 0 ;
51630 PyObject * obj0 = 0 ;
51631 PyObject * obj1 = 0 ;
51632 char * kwnames[] = {
51633 (char *) "self",(char *) "cols", NULL
51634 };
51635
51636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
51637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51638 if (!SWIG_IsOK(res1)) {
51639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51640 }
51641 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51642 ecode2 = SWIG_AsVal_int(obj1, &val2);
51643 if (!SWIG_IsOK(ecode2)) {
51644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
51645 }
51646 arg2 = static_cast< int >(val2);
51647 {
51648 PyThreadState* __tstate = wxPyBeginAllowThreads();
51649 (arg1)->SetCols(arg2);
51650 wxPyEndAllowThreads(__tstate);
51651 if (PyErr_Occurred()) SWIG_fail;
51652 }
51653 resultobj = SWIG_Py_Void();
51654 return resultobj;
51655 fail:
51656 return NULL;
51657 }
51658
51659
51660 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51661 PyObject *resultobj = 0;
51662 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51663 int arg2 ;
51664 void *argp1 = 0 ;
51665 int res1 = 0 ;
51666 int val2 ;
51667 int ecode2 = 0 ;
51668 PyObject * obj0 = 0 ;
51669 PyObject * obj1 = 0 ;
51670 char * kwnames[] = {
51671 (char *) "self",(char *) "rows", NULL
51672 };
51673
51674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
51675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51676 if (!SWIG_IsOK(res1)) {
51677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51678 }
51679 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51680 ecode2 = SWIG_AsVal_int(obj1, &val2);
51681 if (!SWIG_IsOK(ecode2)) {
51682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
51683 }
51684 arg2 = static_cast< int >(val2);
51685 {
51686 PyThreadState* __tstate = wxPyBeginAllowThreads();
51687 (arg1)->SetRows(arg2);
51688 wxPyEndAllowThreads(__tstate);
51689 if (PyErr_Occurred()) SWIG_fail;
51690 }
51691 resultobj = SWIG_Py_Void();
51692 return resultobj;
51693 fail:
51694 return NULL;
51695 }
51696
51697
51698 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51699 PyObject *resultobj = 0;
51700 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51701 int arg2 ;
51702 void *argp1 = 0 ;
51703 int res1 = 0 ;
51704 int val2 ;
51705 int ecode2 = 0 ;
51706 PyObject * obj0 = 0 ;
51707 PyObject * obj1 = 0 ;
51708 char * kwnames[] = {
51709 (char *) "self",(char *) "gap", NULL
51710 };
51711
51712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
51713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51714 if (!SWIG_IsOK(res1)) {
51715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51716 }
51717 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51718 ecode2 = SWIG_AsVal_int(obj1, &val2);
51719 if (!SWIG_IsOK(ecode2)) {
51720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
51721 }
51722 arg2 = static_cast< int >(val2);
51723 {
51724 PyThreadState* __tstate = wxPyBeginAllowThreads();
51725 (arg1)->SetVGap(arg2);
51726 wxPyEndAllowThreads(__tstate);
51727 if (PyErr_Occurred()) SWIG_fail;
51728 }
51729 resultobj = SWIG_Py_Void();
51730 return resultobj;
51731 fail:
51732 return NULL;
51733 }
51734
51735
51736 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51737 PyObject *resultobj = 0;
51738 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51739 int arg2 ;
51740 void *argp1 = 0 ;
51741 int res1 = 0 ;
51742 int val2 ;
51743 int ecode2 = 0 ;
51744 PyObject * obj0 = 0 ;
51745 PyObject * obj1 = 0 ;
51746 char * kwnames[] = {
51747 (char *) "self",(char *) "gap", NULL
51748 };
51749
51750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
51751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51752 if (!SWIG_IsOK(res1)) {
51753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51754 }
51755 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51756 ecode2 = SWIG_AsVal_int(obj1, &val2);
51757 if (!SWIG_IsOK(ecode2)) {
51758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
51759 }
51760 arg2 = static_cast< int >(val2);
51761 {
51762 PyThreadState* __tstate = wxPyBeginAllowThreads();
51763 (arg1)->SetHGap(arg2);
51764 wxPyEndAllowThreads(__tstate);
51765 if (PyErr_Occurred()) SWIG_fail;
51766 }
51767 resultobj = SWIG_Py_Void();
51768 return resultobj;
51769 fail:
51770 return NULL;
51771 }
51772
51773
51774 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51775 PyObject *resultobj = 0;
51776 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51777 int result;
51778 void *argp1 = 0 ;
51779 int res1 = 0 ;
51780 PyObject *swig_obj[1] ;
51781
51782 if (!args) SWIG_fail;
51783 swig_obj[0] = args;
51784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51785 if (!SWIG_IsOK(res1)) {
51786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51787 }
51788 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51789 {
51790 PyThreadState* __tstate = wxPyBeginAllowThreads();
51791 result = (int)(arg1)->GetCols();
51792 wxPyEndAllowThreads(__tstate);
51793 if (PyErr_Occurred()) SWIG_fail;
51794 }
51795 resultobj = SWIG_From_int(static_cast< int >(result));
51796 return resultobj;
51797 fail:
51798 return NULL;
51799 }
51800
51801
51802 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51803 PyObject *resultobj = 0;
51804 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51805 int result;
51806 void *argp1 = 0 ;
51807 int res1 = 0 ;
51808 PyObject *swig_obj[1] ;
51809
51810 if (!args) SWIG_fail;
51811 swig_obj[0] = args;
51812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51813 if (!SWIG_IsOK(res1)) {
51814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51815 }
51816 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51817 {
51818 PyThreadState* __tstate = wxPyBeginAllowThreads();
51819 result = (int)(arg1)->GetRows();
51820 wxPyEndAllowThreads(__tstate);
51821 if (PyErr_Occurred()) SWIG_fail;
51822 }
51823 resultobj = SWIG_From_int(static_cast< int >(result));
51824 return resultobj;
51825 fail:
51826 return NULL;
51827 }
51828
51829
51830 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51831 PyObject *resultobj = 0;
51832 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51833 int result;
51834 void *argp1 = 0 ;
51835 int res1 = 0 ;
51836 PyObject *swig_obj[1] ;
51837
51838 if (!args) SWIG_fail;
51839 swig_obj[0] = args;
51840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51841 if (!SWIG_IsOK(res1)) {
51842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51843 }
51844 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51845 {
51846 PyThreadState* __tstate = wxPyBeginAllowThreads();
51847 result = (int)(arg1)->GetVGap();
51848 wxPyEndAllowThreads(__tstate);
51849 if (PyErr_Occurred()) SWIG_fail;
51850 }
51851 resultobj = SWIG_From_int(static_cast< int >(result));
51852 return resultobj;
51853 fail:
51854 return NULL;
51855 }
51856
51857
51858 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51859 PyObject *resultobj = 0;
51860 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51861 int result;
51862 void *argp1 = 0 ;
51863 int res1 = 0 ;
51864 PyObject *swig_obj[1] ;
51865
51866 if (!args) SWIG_fail;
51867 swig_obj[0] = args;
51868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51869 if (!SWIG_IsOK(res1)) {
51870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51871 }
51872 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51873 {
51874 PyThreadState* __tstate = wxPyBeginAllowThreads();
51875 result = (int)(arg1)->GetHGap();
51876 wxPyEndAllowThreads(__tstate);
51877 if (PyErr_Occurred()) SWIG_fail;
51878 }
51879 resultobj = SWIG_From_int(static_cast< int >(result));
51880 return resultobj;
51881 fail:
51882 return NULL;
51883 }
51884
51885
51886 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51887 PyObject *obj;
51888 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51889 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
51890 return SWIG_Py_Void();
51891 }
51892
51893 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51894 return SWIG_Python_InitShadowInstance(args);
51895 }
51896
51897 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51898 PyObject *resultobj = 0;
51899 int arg1 = (int) 1 ;
51900 int arg2 = (int) 0 ;
51901 int arg3 = (int) 0 ;
51902 int arg4 = (int) 0 ;
51903 wxFlexGridSizer *result = 0 ;
51904 int val1 ;
51905 int ecode1 = 0 ;
51906 int val2 ;
51907 int ecode2 = 0 ;
51908 int val3 ;
51909 int ecode3 = 0 ;
51910 int val4 ;
51911 int ecode4 = 0 ;
51912 PyObject * obj0 = 0 ;
51913 PyObject * obj1 = 0 ;
51914 PyObject * obj2 = 0 ;
51915 PyObject * obj3 = 0 ;
51916 char * kwnames[] = {
51917 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51918 };
51919
51920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51921 if (obj0) {
51922 ecode1 = SWIG_AsVal_int(obj0, &val1);
51923 if (!SWIG_IsOK(ecode1)) {
51924 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
51925 }
51926 arg1 = static_cast< int >(val1);
51927 }
51928 if (obj1) {
51929 ecode2 = SWIG_AsVal_int(obj1, &val2);
51930 if (!SWIG_IsOK(ecode2)) {
51931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
51932 }
51933 arg2 = static_cast< int >(val2);
51934 }
51935 if (obj2) {
51936 ecode3 = SWIG_AsVal_int(obj2, &val3);
51937 if (!SWIG_IsOK(ecode3)) {
51938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
51939 }
51940 arg3 = static_cast< int >(val3);
51941 }
51942 if (obj3) {
51943 ecode4 = SWIG_AsVal_int(obj3, &val4);
51944 if (!SWIG_IsOK(ecode4)) {
51945 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
51946 }
51947 arg4 = static_cast< int >(val4);
51948 }
51949 {
51950 PyThreadState* __tstate = wxPyBeginAllowThreads();
51951 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
51952 wxPyEndAllowThreads(__tstate);
51953 if (PyErr_Occurred()) SWIG_fail;
51954 }
51955 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
51956 return resultobj;
51957 fail:
51958 return NULL;
51959 }
51960
51961
51962 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51963 PyObject *resultobj = 0;
51964 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51965 size_t arg2 ;
51966 int arg3 = (int) 0 ;
51967 void *argp1 = 0 ;
51968 int res1 = 0 ;
51969 size_t val2 ;
51970 int ecode2 = 0 ;
51971 int val3 ;
51972 int ecode3 = 0 ;
51973 PyObject * obj0 = 0 ;
51974 PyObject * obj1 = 0 ;
51975 PyObject * obj2 = 0 ;
51976 char * kwnames[] = {
51977 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51978 };
51979
51980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51982 if (!SWIG_IsOK(res1)) {
51983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51984 }
51985 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51986 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51987 if (!SWIG_IsOK(ecode2)) {
51988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51989 }
51990 arg2 = static_cast< size_t >(val2);
51991 if (obj2) {
51992 ecode3 = SWIG_AsVal_int(obj2, &val3);
51993 if (!SWIG_IsOK(ecode3)) {
51994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
51995 }
51996 arg3 = static_cast< int >(val3);
51997 }
51998 {
51999 PyThreadState* __tstate = wxPyBeginAllowThreads();
52000 (arg1)->AddGrowableRow(arg2,arg3);
52001 wxPyEndAllowThreads(__tstate);
52002 if (PyErr_Occurred()) SWIG_fail;
52003 }
52004 resultobj = SWIG_Py_Void();
52005 return resultobj;
52006 fail:
52007 return NULL;
52008 }
52009
52010
52011 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52012 PyObject *resultobj = 0;
52013 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52014 size_t arg2 ;
52015 void *argp1 = 0 ;
52016 int res1 = 0 ;
52017 size_t val2 ;
52018 int ecode2 = 0 ;
52019 PyObject * obj0 = 0 ;
52020 PyObject * obj1 = 0 ;
52021 char * kwnames[] = {
52022 (char *) "self",(char *) "idx", NULL
52023 };
52024
52025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
52026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52027 if (!SWIG_IsOK(res1)) {
52028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52029 }
52030 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52031 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52032 if (!SWIG_IsOK(ecode2)) {
52033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
52034 }
52035 arg2 = static_cast< size_t >(val2);
52036 {
52037 PyThreadState* __tstate = wxPyBeginAllowThreads();
52038 (arg1)->RemoveGrowableRow(arg2);
52039 wxPyEndAllowThreads(__tstate);
52040 if (PyErr_Occurred()) SWIG_fail;
52041 }
52042 resultobj = SWIG_Py_Void();
52043 return resultobj;
52044 fail:
52045 return NULL;
52046 }
52047
52048
52049 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52050 PyObject *resultobj = 0;
52051 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52052 size_t arg2 ;
52053 int arg3 = (int) 0 ;
52054 void *argp1 = 0 ;
52055 int res1 = 0 ;
52056 size_t val2 ;
52057 int ecode2 = 0 ;
52058 int val3 ;
52059 int ecode3 = 0 ;
52060 PyObject * obj0 = 0 ;
52061 PyObject * obj1 = 0 ;
52062 PyObject * obj2 = 0 ;
52063 char * kwnames[] = {
52064 (char *) "self",(char *) "idx",(char *) "proportion", NULL
52065 };
52066
52067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52069 if (!SWIG_IsOK(res1)) {
52070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52071 }
52072 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52073 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52074 if (!SWIG_IsOK(ecode2)) {
52075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
52076 }
52077 arg2 = static_cast< size_t >(val2);
52078 if (obj2) {
52079 ecode3 = SWIG_AsVal_int(obj2, &val3);
52080 if (!SWIG_IsOK(ecode3)) {
52081 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
52082 }
52083 arg3 = static_cast< int >(val3);
52084 }
52085 {
52086 PyThreadState* __tstate = wxPyBeginAllowThreads();
52087 (arg1)->AddGrowableCol(arg2,arg3);
52088 wxPyEndAllowThreads(__tstate);
52089 if (PyErr_Occurred()) SWIG_fail;
52090 }
52091 resultobj = SWIG_Py_Void();
52092 return resultobj;
52093 fail:
52094 return NULL;
52095 }
52096
52097
52098 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52099 PyObject *resultobj = 0;
52100 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52101 size_t arg2 ;
52102 void *argp1 = 0 ;
52103 int res1 = 0 ;
52104 size_t val2 ;
52105 int ecode2 = 0 ;
52106 PyObject * obj0 = 0 ;
52107 PyObject * obj1 = 0 ;
52108 char * kwnames[] = {
52109 (char *) "self",(char *) "idx", NULL
52110 };
52111
52112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
52113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52114 if (!SWIG_IsOK(res1)) {
52115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52116 }
52117 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52118 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52119 if (!SWIG_IsOK(ecode2)) {
52120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
52121 }
52122 arg2 = static_cast< size_t >(val2);
52123 {
52124 PyThreadState* __tstate = wxPyBeginAllowThreads();
52125 (arg1)->RemoveGrowableCol(arg2);
52126 wxPyEndAllowThreads(__tstate);
52127 if (PyErr_Occurred()) SWIG_fail;
52128 }
52129 resultobj = SWIG_Py_Void();
52130 return resultobj;
52131 fail:
52132 return NULL;
52133 }
52134
52135
52136 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52137 PyObject *resultobj = 0;
52138 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52139 int arg2 ;
52140 void *argp1 = 0 ;
52141 int res1 = 0 ;
52142 int val2 ;
52143 int ecode2 = 0 ;
52144 PyObject * obj0 = 0 ;
52145 PyObject * obj1 = 0 ;
52146 char * kwnames[] = {
52147 (char *) "self",(char *) "direction", NULL
52148 };
52149
52150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
52151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52152 if (!SWIG_IsOK(res1)) {
52153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52154 }
52155 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52156 ecode2 = SWIG_AsVal_int(obj1, &val2);
52157 if (!SWIG_IsOK(ecode2)) {
52158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
52159 }
52160 arg2 = static_cast< int >(val2);
52161 {
52162 PyThreadState* __tstate = wxPyBeginAllowThreads();
52163 (arg1)->SetFlexibleDirection(arg2);
52164 wxPyEndAllowThreads(__tstate);
52165 if (PyErr_Occurred()) SWIG_fail;
52166 }
52167 resultobj = SWIG_Py_Void();
52168 return resultobj;
52169 fail:
52170 return NULL;
52171 }
52172
52173
52174 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52175 PyObject *resultobj = 0;
52176 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52177 int result;
52178 void *argp1 = 0 ;
52179 int res1 = 0 ;
52180 PyObject *swig_obj[1] ;
52181
52182 if (!args) SWIG_fail;
52183 swig_obj[0] = args;
52184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52185 if (!SWIG_IsOK(res1)) {
52186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52187 }
52188 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52189 {
52190 PyThreadState* __tstate = wxPyBeginAllowThreads();
52191 result = (int)(arg1)->GetFlexibleDirection();
52192 wxPyEndAllowThreads(__tstate);
52193 if (PyErr_Occurred()) SWIG_fail;
52194 }
52195 resultobj = SWIG_From_int(static_cast< int >(result));
52196 return resultobj;
52197 fail:
52198 return NULL;
52199 }
52200
52201
52202 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52203 PyObject *resultobj = 0;
52204 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52205 wxFlexSizerGrowMode arg2 ;
52206 void *argp1 = 0 ;
52207 int res1 = 0 ;
52208 int val2 ;
52209 int ecode2 = 0 ;
52210 PyObject * obj0 = 0 ;
52211 PyObject * obj1 = 0 ;
52212 char * kwnames[] = {
52213 (char *) "self",(char *) "mode", NULL
52214 };
52215
52216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
52217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52218 if (!SWIG_IsOK(res1)) {
52219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52220 }
52221 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52222 ecode2 = SWIG_AsVal_int(obj1, &val2);
52223 if (!SWIG_IsOK(ecode2)) {
52224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
52225 }
52226 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
52227 {
52228 PyThreadState* __tstate = wxPyBeginAllowThreads();
52229 (arg1)->SetNonFlexibleGrowMode(arg2);
52230 wxPyEndAllowThreads(__tstate);
52231 if (PyErr_Occurred()) SWIG_fail;
52232 }
52233 resultobj = SWIG_Py_Void();
52234 return resultobj;
52235 fail:
52236 return NULL;
52237 }
52238
52239
52240 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52241 PyObject *resultobj = 0;
52242 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52243 wxFlexSizerGrowMode result;
52244 void *argp1 = 0 ;
52245 int res1 = 0 ;
52246 PyObject *swig_obj[1] ;
52247
52248 if (!args) SWIG_fail;
52249 swig_obj[0] = args;
52250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52251 if (!SWIG_IsOK(res1)) {
52252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52253 }
52254 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52255 {
52256 PyThreadState* __tstate = wxPyBeginAllowThreads();
52257 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
52258 wxPyEndAllowThreads(__tstate);
52259 if (PyErr_Occurred()) SWIG_fail;
52260 }
52261 resultobj = SWIG_From_int(static_cast< int >(result));
52262 return resultobj;
52263 fail:
52264 return NULL;
52265 }
52266
52267
52268 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52269 PyObject *resultobj = 0;
52270 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52271 wxArrayInt *result = 0 ;
52272 void *argp1 = 0 ;
52273 int res1 = 0 ;
52274 PyObject *swig_obj[1] ;
52275
52276 if (!args) SWIG_fail;
52277 swig_obj[0] = args;
52278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52279 if (!SWIG_IsOK(res1)) {
52280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52281 }
52282 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52283 {
52284 PyThreadState* __tstate = wxPyBeginAllowThreads();
52285 {
52286 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
52287 result = (wxArrayInt *) &_result_ref;
52288 }
52289 wxPyEndAllowThreads(__tstate);
52290 if (PyErr_Occurred()) SWIG_fail;
52291 }
52292 {
52293 resultobj = wxArrayInt2PyList_helper(*result);
52294 }
52295 return resultobj;
52296 fail:
52297 return NULL;
52298 }
52299
52300
52301 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52302 PyObject *resultobj = 0;
52303 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52304 wxArrayInt *result = 0 ;
52305 void *argp1 = 0 ;
52306 int res1 = 0 ;
52307 PyObject *swig_obj[1] ;
52308
52309 if (!args) SWIG_fail;
52310 swig_obj[0] = args;
52311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52312 if (!SWIG_IsOK(res1)) {
52313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52314 }
52315 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52316 {
52317 PyThreadState* __tstate = wxPyBeginAllowThreads();
52318 {
52319 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
52320 result = (wxArrayInt *) &_result_ref;
52321 }
52322 wxPyEndAllowThreads(__tstate);
52323 if (PyErr_Occurred()) SWIG_fail;
52324 }
52325 {
52326 resultobj = wxArrayInt2PyList_helper(*result);
52327 }
52328 return resultobj;
52329 fail:
52330 return NULL;
52331 }
52332
52333
52334 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52335 PyObject *obj;
52336 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52337 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
52338 return SWIG_Py_Void();
52339 }
52340
52341 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52342 return SWIG_Python_InitShadowInstance(args);
52343 }
52344
52345 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52346 PyObject *resultobj = 0;
52347 wxStdDialogButtonSizer *result = 0 ;
52348
52349 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
52350 {
52351 PyThreadState* __tstate = wxPyBeginAllowThreads();
52352 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
52353 wxPyEndAllowThreads(__tstate);
52354 if (PyErr_Occurred()) SWIG_fail;
52355 }
52356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
52357 return resultobj;
52358 fail:
52359 return NULL;
52360 }
52361
52362
52363 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52364 PyObject *resultobj = 0;
52365 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52366 wxButton *arg2 = (wxButton *) 0 ;
52367 void *argp1 = 0 ;
52368 int res1 = 0 ;
52369 void *argp2 = 0 ;
52370 int res2 = 0 ;
52371 PyObject * obj0 = 0 ;
52372 PyObject * obj1 = 0 ;
52373 char * kwnames[] = {
52374 (char *) "self",(char *) "button", NULL
52375 };
52376
52377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
52378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52379 if (!SWIG_IsOK(res1)) {
52380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52381 }
52382 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52383 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52384 if (!SWIG_IsOK(res2)) {
52385 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
52386 }
52387 arg2 = reinterpret_cast< wxButton * >(argp2);
52388 {
52389 PyThreadState* __tstate = wxPyBeginAllowThreads();
52390 (arg1)->AddButton(arg2);
52391 wxPyEndAllowThreads(__tstate);
52392 if (PyErr_Occurred()) SWIG_fail;
52393 }
52394 resultobj = SWIG_Py_Void();
52395 return resultobj;
52396 fail:
52397 return NULL;
52398 }
52399
52400
52401 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52402 PyObject *resultobj = 0;
52403 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52404 void *argp1 = 0 ;
52405 int res1 = 0 ;
52406 PyObject *swig_obj[1] ;
52407
52408 if (!args) SWIG_fail;
52409 swig_obj[0] = args;
52410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52411 if (!SWIG_IsOK(res1)) {
52412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52413 }
52414 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52415 {
52416 PyThreadState* __tstate = wxPyBeginAllowThreads();
52417 (arg1)->Realize();
52418 wxPyEndAllowThreads(__tstate);
52419 if (PyErr_Occurred()) SWIG_fail;
52420 }
52421 resultobj = SWIG_Py_Void();
52422 return resultobj;
52423 fail:
52424 return NULL;
52425 }
52426
52427
52428 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52429 PyObject *resultobj = 0;
52430 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52431 wxButton *arg2 = (wxButton *) 0 ;
52432 void *argp1 = 0 ;
52433 int res1 = 0 ;
52434 void *argp2 = 0 ;
52435 int res2 = 0 ;
52436 PyObject * obj0 = 0 ;
52437 PyObject * obj1 = 0 ;
52438 char * kwnames[] = {
52439 (char *) "self",(char *) "button", NULL
52440 };
52441
52442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52444 if (!SWIG_IsOK(res1)) {
52445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52446 }
52447 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52448 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52449 if (!SWIG_IsOK(res2)) {
52450 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52451 }
52452 arg2 = reinterpret_cast< wxButton * >(argp2);
52453 {
52454 PyThreadState* __tstate = wxPyBeginAllowThreads();
52455 (arg1)->SetAffirmativeButton(arg2);
52456 wxPyEndAllowThreads(__tstate);
52457 if (PyErr_Occurred()) SWIG_fail;
52458 }
52459 resultobj = SWIG_Py_Void();
52460 return resultobj;
52461 fail:
52462 return NULL;
52463 }
52464
52465
52466 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52467 PyObject *resultobj = 0;
52468 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52469 wxButton *arg2 = (wxButton *) 0 ;
52470 void *argp1 = 0 ;
52471 int res1 = 0 ;
52472 void *argp2 = 0 ;
52473 int res2 = 0 ;
52474 PyObject * obj0 = 0 ;
52475 PyObject * obj1 = 0 ;
52476 char * kwnames[] = {
52477 (char *) "self",(char *) "button", NULL
52478 };
52479
52480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52482 if (!SWIG_IsOK(res1)) {
52483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52484 }
52485 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52486 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52487 if (!SWIG_IsOK(res2)) {
52488 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52489 }
52490 arg2 = reinterpret_cast< wxButton * >(argp2);
52491 {
52492 PyThreadState* __tstate = wxPyBeginAllowThreads();
52493 (arg1)->SetNegativeButton(arg2);
52494 wxPyEndAllowThreads(__tstate);
52495 if (PyErr_Occurred()) SWIG_fail;
52496 }
52497 resultobj = SWIG_Py_Void();
52498 return resultobj;
52499 fail:
52500 return NULL;
52501 }
52502
52503
52504 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52505 PyObject *resultobj = 0;
52506 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52507 wxButton *arg2 = (wxButton *) 0 ;
52508 void *argp1 = 0 ;
52509 int res1 = 0 ;
52510 void *argp2 = 0 ;
52511 int res2 = 0 ;
52512 PyObject * obj0 = 0 ;
52513 PyObject * obj1 = 0 ;
52514 char * kwnames[] = {
52515 (char *) "self",(char *) "button", NULL
52516 };
52517
52518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
52519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52520 if (!SWIG_IsOK(res1)) {
52521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52522 }
52523 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52524 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52525 if (!SWIG_IsOK(res2)) {
52526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
52527 }
52528 arg2 = reinterpret_cast< wxButton * >(argp2);
52529 {
52530 PyThreadState* __tstate = wxPyBeginAllowThreads();
52531 (arg1)->SetCancelButton(arg2);
52532 wxPyEndAllowThreads(__tstate);
52533 if (PyErr_Occurred()) SWIG_fail;
52534 }
52535 resultobj = SWIG_Py_Void();
52536 return resultobj;
52537 fail:
52538 return NULL;
52539 }
52540
52541
52542 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52543 PyObject *resultobj = 0;
52544 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52545 wxButton *result = 0 ;
52546 void *argp1 = 0 ;
52547 int res1 = 0 ;
52548 PyObject *swig_obj[1] ;
52549
52550 if (!args) SWIG_fail;
52551 swig_obj[0] = args;
52552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52553 if (!SWIG_IsOK(res1)) {
52554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52555 }
52556 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52557 {
52558 PyThreadState* __tstate = wxPyBeginAllowThreads();
52559 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
52560 wxPyEndAllowThreads(__tstate);
52561 if (PyErr_Occurred()) SWIG_fail;
52562 }
52563 {
52564 resultobj = wxPyMake_wxObject(result, (bool)0);
52565 }
52566 return resultobj;
52567 fail:
52568 return NULL;
52569 }
52570
52571
52572 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52573 PyObject *resultobj = 0;
52574 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52575 wxButton *result = 0 ;
52576 void *argp1 = 0 ;
52577 int res1 = 0 ;
52578 PyObject *swig_obj[1] ;
52579
52580 if (!args) SWIG_fail;
52581 swig_obj[0] = args;
52582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52583 if (!SWIG_IsOK(res1)) {
52584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52585 }
52586 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52587 {
52588 PyThreadState* __tstate = wxPyBeginAllowThreads();
52589 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
52590 wxPyEndAllowThreads(__tstate);
52591 if (PyErr_Occurred()) SWIG_fail;
52592 }
52593 {
52594 resultobj = wxPyMake_wxObject(result, (bool)0);
52595 }
52596 return resultobj;
52597 fail:
52598 return NULL;
52599 }
52600
52601
52602 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52603 PyObject *resultobj = 0;
52604 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52605 wxButton *result = 0 ;
52606 void *argp1 = 0 ;
52607 int res1 = 0 ;
52608 PyObject *swig_obj[1] ;
52609
52610 if (!args) SWIG_fail;
52611 swig_obj[0] = args;
52612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52613 if (!SWIG_IsOK(res1)) {
52614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52615 }
52616 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52617 {
52618 PyThreadState* __tstate = wxPyBeginAllowThreads();
52619 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
52620 wxPyEndAllowThreads(__tstate);
52621 if (PyErr_Occurred()) SWIG_fail;
52622 }
52623 {
52624 resultobj = wxPyMake_wxObject(result, (bool)0);
52625 }
52626 return resultobj;
52627 fail:
52628 return NULL;
52629 }
52630
52631
52632 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52633 PyObject *resultobj = 0;
52634 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52635 wxButton *result = 0 ;
52636 void *argp1 = 0 ;
52637 int res1 = 0 ;
52638 PyObject *swig_obj[1] ;
52639
52640 if (!args) SWIG_fail;
52641 swig_obj[0] = args;
52642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52643 if (!SWIG_IsOK(res1)) {
52644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52645 }
52646 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52647 {
52648 PyThreadState* __tstate = wxPyBeginAllowThreads();
52649 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
52650 wxPyEndAllowThreads(__tstate);
52651 if (PyErr_Occurred()) SWIG_fail;
52652 }
52653 {
52654 resultobj = wxPyMake_wxObject(result, (bool)0);
52655 }
52656 return resultobj;
52657 fail:
52658 return NULL;
52659 }
52660
52661
52662 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52663 PyObject *resultobj = 0;
52664 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52665 wxButton *result = 0 ;
52666 void *argp1 = 0 ;
52667 int res1 = 0 ;
52668 PyObject *swig_obj[1] ;
52669
52670 if (!args) SWIG_fail;
52671 swig_obj[0] = args;
52672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52673 if (!SWIG_IsOK(res1)) {
52674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52675 }
52676 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52677 {
52678 PyThreadState* __tstate = wxPyBeginAllowThreads();
52679 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
52680 wxPyEndAllowThreads(__tstate);
52681 if (PyErr_Occurred()) SWIG_fail;
52682 }
52683 {
52684 resultobj = wxPyMake_wxObject(result, (bool)0);
52685 }
52686 return resultobj;
52687 fail:
52688 return NULL;
52689 }
52690
52691
52692 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52693 PyObject *obj;
52694 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52695 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
52696 return SWIG_Py_Void();
52697 }
52698
52699 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52700 return SWIG_Python_InitShadowInstance(args);
52701 }
52702
52703 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52704 PyObject *resultobj = 0;
52705 int arg1 = (int) 0 ;
52706 int arg2 = (int) 0 ;
52707 wxGBPosition *result = 0 ;
52708 int val1 ;
52709 int ecode1 = 0 ;
52710 int val2 ;
52711 int ecode2 = 0 ;
52712 PyObject * obj0 = 0 ;
52713 PyObject * obj1 = 0 ;
52714 char * kwnames[] = {
52715 (char *) "row",(char *) "col", NULL
52716 };
52717
52718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52719 if (obj0) {
52720 ecode1 = SWIG_AsVal_int(obj0, &val1);
52721 if (!SWIG_IsOK(ecode1)) {
52722 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
52723 }
52724 arg1 = static_cast< int >(val1);
52725 }
52726 if (obj1) {
52727 ecode2 = SWIG_AsVal_int(obj1, &val2);
52728 if (!SWIG_IsOK(ecode2)) {
52729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
52730 }
52731 arg2 = static_cast< int >(val2);
52732 }
52733 {
52734 PyThreadState* __tstate = wxPyBeginAllowThreads();
52735 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
52736 wxPyEndAllowThreads(__tstate);
52737 if (PyErr_Occurred()) SWIG_fail;
52738 }
52739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
52740 return resultobj;
52741 fail:
52742 return NULL;
52743 }
52744
52745
52746 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52747 PyObject *resultobj = 0;
52748 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52749 void *argp1 = 0 ;
52750 int res1 = 0 ;
52751 PyObject *swig_obj[1] ;
52752
52753 if (!args) SWIG_fail;
52754 swig_obj[0] = args;
52755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
52756 if (!SWIG_IsOK(res1)) {
52757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52758 }
52759 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52760 {
52761 PyThreadState* __tstate = wxPyBeginAllowThreads();
52762 delete arg1;
52763
52764 wxPyEndAllowThreads(__tstate);
52765 if (PyErr_Occurred()) SWIG_fail;
52766 }
52767 resultobj = SWIG_Py_Void();
52768 return resultobj;
52769 fail:
52770 return NULL;
52771 }
52772
52773
52774 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52775 PyObject *resultobj = 0;
52776 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52777 int result;
52778 void *argp1 = 0 ;
52779 int res1 = 0 ;
52780 PyObject *swig_obj[1] ;
52781
52782 if (!args) SWIG_fail;
52783 swig_obj[0] = args;
52784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52785 if (!SWIG_IsOK(res1)) {
52786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52787 }
52788 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52789 {
52790 PyThreadState* __tstate = wxPyBeginAllowThreads();
52791 result = (int)((wxGBPosition const *)arg1)->GetRow();
52792 wxPyEndAllowThreads(__tstate);
52793 if (PyErr_Occurred()) SWIG_fail;
52794 }
52795 resultobj = SWIG_From_int(static_cast< int >(result));
52796 return resultobj;
52797 fail:
52798 return NULL;
52799 }
52800
52801
52802 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52803 PyObject *resultobj = 0;
52804 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52805 int result;
52806 void *argp1 = 0 ;
52807 int res1 = 0 ;
52808 PyObject *swig_obj[1] ;
52809
52810 if (!args) SWIG_fail;
52811 swig_obj[0] = args;
52812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52813 if (!SWIG_IsOK(res1)) {
52814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52815 }
52816 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52817 {
52818 PyThreadState* __tstate = wxPyBeginAllowThreads();
52819 result = (int)((wxGBPosition const *)arg1)->GetCol();
52820 wxPyEndAllowThreads(__tstate);
52821 if (PyErr_Occurred()) SWIG_fail;
52822 }
52823 resultobj = SWIG_From_int(static_cast< int >(result));
52824 return resultobj;
52825 fail:
52826 return NULL;
52827 }
52828
52829
52830 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52831 PyObject *resultobj = 0;
52832 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52833 int arg2 ;
52834 void *argp1 = 0 ;
52835 int res1 = 0 ;
52836 int val2 ;
52837 int ecode2 = 0 ;
52838 PyObject * obj0 = 0 ;
52839 PyObject * obj1 = 0 ;
52840 char * kwnames[] = {
52841 (char *) "self",(char *) "row", NULL
52842 };
52843
52844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
52845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52846 if (!SWIG_IsOK(res1)) {
52847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52848 }
52849 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52850 ecode2 = SWIG_AsVal_int(obj1, &val2);
52851 if (!SWIG_IsOK(ecode2)) {
52852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
52853 }
52854 arg2 = static_cast< int >(val2);
52855 {
52856 PyThreadState* __tstate = wxPyBeginAllowThreads();
52857 (arg1)->SetRow(arg2);
52858 wxPyEndAllowThreads(__tstate);
52859 if (PyErr_Occurred()) SWIG_fail;
52860 }
52861 resultobj = SWIG_Py_Void();
52862 return resultobj;
52863 fail:
52864 return NULL;
52865 }
52866
52867
52868 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52869 PyObject *resultobj = 0;
52870 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52871 int arg2 ;
52872 void *argp1 = 0 ;
52873 int res1 = 0 ;
52874 int val2 ;
52875 int ecode2 = 0 ;
52876 PyObject * obj0 = 0 ;
52877 PyObject * obj1 = 0 ;
52878 char * kwnames[] = {
52879 (char *) "self",(char *) "col", NULL
52880 };
52881
52882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
52883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52884 if (!SWIG_IsOK(res1)) {
52885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52886 }
52887 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52888 ecode2 = SWIG_AsVal_int(obj1, &val2);
52889 if (!SWIG_IsOK(ecode2)) {
52890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
52891 }
52892 arg2 = static_cast< int >(val2);
52893 {
52894 PyThreadState* __tstate = wxPyBeginAllowThreads();
52895 (arg1)->SetCol(arg2);
52896 wxPyEndAllowThreads(__tstate);
52897 if (PyErr_Occurred()) SWIG_fail;
52898 }
52899 resultobj = SWIG_Py_Void();
52900 return resultobj;
52901 fail:
52902 return NULL;
52903 }
52904
52905
52906 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52907 PyObject *resultobj = 0;
52908 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52909 PyObject *arg2 = (PyObject *) 0 ;
52910 bool result;
52911 void *argp1 = 0 ;
52912 int res1 = 0 ;
52913 PyObject * obj0 = 0 ;
52914 PyObject * obj1 = 0 ;
52915 char * kwnames[] = {
52916 (char *) "self",(char *) "other", NULL
52917 };
52918
52919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
52920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52921 if (!SWIG_IsOK(res1)) {
52922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52923 }
52924 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52925 arg2 = obj1;
52926 {
52927 result = (bool)wxGBPosition___eq__(arg1,arg2);
52928 if (PyErr_Occurred()) SWIG_fail;
52929 }
52930 {
52931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52932 }
52933 return resultobj;
52934 fail:
52935 return NULL;
52936 }
52937
52938
52939 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52940 PyObject *resultobj = 0;
52941 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52942 PyObject *arg2 = (PyObject *) 0 ;
52943 bool result;
52944 void *argp1 = 0 ;
52945 int res1 = 0 ;
52946 PyObject * obj0 = 0 ;
52947 PyObject * obj1 = 0 ;
52948 char * kwnames[] = {
52949 (char *) "self",(char *) "other", NULL
52950 };
52951
52952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
52953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52954 if (!SWIG_IsOK(res1)) {
52955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52956 }
52957 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52958 arg2 = obj1;
52959 {
52960 result = (bool)wxGBPosition___ne__(arg1,arg2);
52961 if (PyErr_Occurred()) SWIG_fail;
52962 }
52963 {
52964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52965 }
52966 return resultobj;
52967 fail:
52968 return NULL;
52969 }
52970
52971
52972 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52973 PyObject *resultobj = 0;
52974 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52975 int arg2 = (int) 0 ;
52976 int arg3 = (int) 0 ;
52977 void *argp1 = 0 ;
52978 int res1 = 0 ;
52979 int val2 ;
52980 int ecode2 = 0 ;
52981 int val3 ;
52982 int ecode3 = 0 ;
52983 PyObject * obj0 = 0 ;
52984 PyObject * obj1 = 0 ;
52985 PyObject * obj2 = 0 ;
52986 char * kwnames[] = {
52987 (char *) "self",(char *) "row",(char *) "col", NULL
52988 };
52989
52990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52992 if (!SWIG_IsOK(res1)) {
52993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52994 }
52995 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52996 if (obj1) {
52997 ecode2 = SWIG_AsVal_int(obj1, &val2);
52998 if (!SWIG_IsOK(ecode2)) {
52999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
53000 }
53001 arg2 = static_cast< int >(val2);
53002 }
53003 if (obj2) {
53004 ecode3 = SWIG_AsVal_int(obj2, &val3);
53005 if (!SWIG_IsOK(ecode3)) {
53006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
53007 }
53008 arg3 = static_cast< int >(val3);
53009 }
53010 {
53011 PyThreadState* __tstate = wxPyBeginAllowThreads();
53012 wxGBPosition_Set(arg1,arg2,arg3);
53013 wxPyEndAllowThreads(__tstate);
53014 if (PyErr_Occurred()) SWIG_fail;
53015 }
53016 resultobj = SWIG_Py_Void();
53017 return resultobj;
53018 fail:
53019 return NULL;
53020 }
53021
53022
53023 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53024 PyObject *resultobj = 0;
53025 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
53026 PyObject *result = 0 ;
53027 void *argp1 = 0 ;
53028 int res1 = 0 ;
53029 PyObject *swig_obj[1] ;
53030
53031 if (!args) SWIG_fail;
53032 swig_obj[0] = args;
53033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
53034 if (!SWIG_IsOK(res1)) {
53035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
53036 }
53037 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
53038 {
53039 PyThreadState* __tstate = wxPyBeginAllowThreads();
53040 result = (PyObject *)wxGBPosition_Get(arg1);
53041 wxPyEndAllowThreads(__tstate);
53042 if (PyErr_Occurred()) SWIG_fail;
53043 }
53044 resultobj = result;
53045 return resultobj;
53046 fail:
53047 return NULL;
53048 }
53049
53050
53051 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53052 PyObject *obj;
53053 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53054 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
53055 return SWIG_Py_Void();
53056 }
53057
53058 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53059 return SWIG_Python_InitShadowInstance(args);
53060 }
53061
53062 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53063 PyObject *resultobj = 0;
53064 int arg1 = (int) 1 ;
53065 int arg2 = (int) 1 ;
53066 wxGBSpan *result = 0 ;
53067 int val1 ;
53068 int ecode1 = 0 ;
53069 int val2 ;
53070 int ecode2 = 0 ;
53071 PyObject * obj0 = 0 ;
53072 PyObject * obj1 = 0 ;
53073 char * kwnames[] = {
53074 (char *) "rowspan",(char *) "colspan", NULL
53075 };
53076
53077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53078 if (obj0) {
53079 ecode1 = SWIG_AsVal_int(obj0, &val1);
53080 if (!SWIG_IsOK(ecode1)) {
53081 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
53082 }
53083 arg1 = static_cast< int >(val1);
53084 }
53085 if (obj1) {
53086 ecode2 = SWIG_AsVal_int(obj1, &val2);
53087 if (!SWIG_IsOK(ecode2)) {
53088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
53089 }
53090 arg2 = static_cast< int >(val2);
53091 }
53092 {
53093 PyThreadState* __tstate = wxPyBeginAllowThreads();
53094 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
53095 wxPyEndAllowThreads(__tstate);
53096 if (PyErr_Occurred()) SWIG_fail;
53097 }
53098 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
53099 return resultobj;
53100 fail:
53101 return NULL;
53102 }
53103
53104
53105 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53106 PyObject *resultobj = 0;
53107 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53108 void *argp1 = 0 ;
53109 int res1 = 0 ;
53110 PyObject *swig_obj[1] ;
53111
53112 if (!args) SWIG_fail;
53113 swig_obj[0] = args;
53114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
53115 if (!SWIG_IsOK(res1)) {
53116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53117 }
53118 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53119 {
53120 PyThreadState* __tstate = wxPyBeginAllowThreads();
53121 delete arg1;
53122
53123 wxPyEndAllowThreads(__tstate);
53124 if (PyErr_Occurred()) SWIG_fail;
53125 }
53126 resultobj = SWIG_Py_Void();
53127 return resultobj;
53128 fail:
53129 return NULL;
53130 }
53131
53132
53133 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53134 PyObject *resultobj = 0;
53135 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53136 int result;
53137 void *argp1 = 0 ;
53138 int res1 = 0 ;
53139 PyObject *swig_obj[1] ;
53140
53141 if (!args) SWIG_fail;
53142 swig_obj[0] = args;
53143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53144 if (!SWIG_IsOK(res1)) {
53145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53146 }
53147 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53148 {
53149 PyThreadState* __tstate = wxPyBeginAllowThreads();
53150 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
53151 wxPyEndAllowThreads(__tstate);
53152 if (PyErr_Occurred()) SWIG_fail;
53153 }
53154 resultobj = SWIG_From_int(static_cast< int >(result));
53155 return resultobj;
53156 fail:
53157 return NULL;
53158 }
53159
53160
53161 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53162 PyObject *resultobj = 0;
53163 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53164 int result;
53165 void *argp1 = 0 ;
53166 int res1 = 0 ;
53167 PyObject *swig_obj[1] ;
53168
53169 if (!args) SWIG_fail;
53170 swig_obj[0] = args;
53171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53172 if (!SWIG_IsOK(res1)) {
53173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53174 }
53175 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53176 {
53177 PyThreadState* __tstate = wxPyBeginAllowThreads();
53178 result = (int)((wxGBSpan const *)arg1)->GetColspan();
53179 wxPyEndAllowThreads(__tstate);
53180 if (PyErr_Occurred()) SWIG_fail;
53181 }
53182 resultobj = SWIG_From_int(static_cast< int >(result));
53183 return resultobj;
53184 fail:
53185 return NULL;
53186 }
53187
53188
53189 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53190 PyObject *resultobj = 0;
53191 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53192 int arg2 ;
53193 void *argp1 = 0 ;
53194 int res1 = 0 ;
53195 int val2 ;
53196 int ecode2 = 0 ;
53197 PyObject * obj0 = 0 ;
53198 PyObject * obj1 = 0 ;
53199 char * kwnames[] = {
53200 (char *) "self",(char *) "rowspan", NULL
53201 };
53202
53203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
53204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53205 if (!SWIG_IsOK(res1)) {
53206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53207 }
53208 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53209 ecode2 = SWIG_AsVal_int(obj1, &val2);
53210 if (!SWIG_IsOK(ecode2)) {
53211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
53212 }
53213 arg2 = static_cast< int >(val2);
53214 {
53215 PyThreadState* __tstate = wxPyBeginAllowThreads();
53216 (arg1)->SetRowspan(arg2);
53217 wxPyEndAllowThreads(__tstate);
53218 if (PyErr_Occurred()) SWIG_fail;
53219 }
53220 resultobj = SWIG_Py_Void();
53221 return resultobj;
53222 fail:
53223 return NULL;
53224 }
53225
53226
53227 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53228 PyObject *resultobj = 0;
53229 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53230 int arg2 ;
53231 void *argp1 = 0 ;
53232 int res1 = 0 ;
53233 int val2 ;
53234 int ecode2 = 0 ;
53235 PyObject * obj0 = 0 ;
53236 PyObject * obj1 = 0 ;
53237 char * kwnames[] = {
53238 (char *) "self",(char *) "colspan", NULL
53239 };
53240
53241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
53242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53243 if (!SWIG_IsOK(res1)) {
53244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53245 }
53246 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53247 ecode2 = SWIG_AsVal_int(obj1, &val2);
53248 if (!SWIG_IsOK(ecode2)) {
53249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
53250 }
53251 arg2 = static_cast< int >(val2);
53252 {
53253 PyThreadState* __tstate = wxPyBeginAllowThreads();
53254 (arg1)->SetColspan(arg2);
53255 wxPyEndAllowThreads(__tstate);
53256 if (PyErr_Occurred()) SWIG_fail;
53257 }
53258 resultobj = SWIG_Py_Void();
53259 return resultobj;
53260 fail:
53261 return NULL;
53262 }
53263
53264
53265 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53266 PyObject *resultobj = 0;
53267 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53268 PyObject *arg2 = (PyObject *) 0 ;
53269 bool result;
53270 void *argp1 = 0 ;
53271 int res1 = 0 ;
53272 PyObject * obj0 = 0 ;
53273 PyObject * obj1 = 0 ;
53274 char * kwnames[] = {
53275 (char *) "self",(char *) "other", NULL
53276 };
53277
53278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
53279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53280 if (!SWIG_IsOK(res1)) {
53281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53282 }
53283 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53284 arg2 = obj1;
53285 {
53286 result = (bool)wxGBSpan___eq__(arg1,arg2);
53287 if (PyErr_Occurred()) SWIG_fail;
53288 }
53289 {
53290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53291 }
53292 return resultobj;
53293 fail:
53294 return NULL;
53295 }
53296
53297
53298 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53299 PyObject *resultobj = 0;
53300 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53301 PyObject *arg2 = (PyObject *) 0 ;
53302 bool result;
53303 void *argp1 = 0 ;
53304 int res1 = 0 ;
53305 PyObject * obj0 = 0 ;
53306 PyObject * obj1 = 0 ;
53307 char * kwnames[] = {
53308 (char *) "self",(char *) "other", NULL
53309 };
53310
53311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
53312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53313 if (!SWIG_IsOK(res1)) {
53314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53315 }
53316 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53317 arg2 = obj1;
53318 {
53319 result = (bool)wxGBSpan___ne__(arg1,arg2);
53320 if (PyErr_Occurred()) SWIG_fail;
53321 }
53322 {
53323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53324 }
53325 return resultobj;
53326 fail:
53327 return NULL;
53328 }
53329
53330
53331 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53332 PyObject *resultobj = 0;
53333 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53334 int arg2 = (int) 1 ;
53335 int arg3 = (int) 1 ;
53336 void *argp1 = 0 ;
53337 int res1 = 0 ;
53338 int val2 ;
53339 int ecode2 = 0 ;
53340 int val3 ;
53341 int ecode3 = 0 ;
53342 PyObject * obj0 = 0 ;
53343 PyObject * obj1 = 0 ;
53344 PyObject * obj2 = 0 ;
53345 char * kwnames[] = {
53346 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
53347 };
53348
53349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53351 if (!SWIG_IsOK(res1)) {
53352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53353 }
53354 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53355 if (obj1) {
53356 ecode2 = SWIG_AsVal_int(obj1, &val2);
53357 if (!SWIG_IsOK(ecode2)) {
53358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
53359 }
53360 arg2 = static_cast< int >(val2);
53361 }
53362 if (obj2) {
53363 ecode3 = SWIG_AsVal_int(obj2, &val3);
53364 if (!SWIG_IsOK(ecode3)) {
53365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
53366 }
53367 arg3 = static_cast< int >(val3);
53368 }
53369 {
53370 PyThreadState* __tstate = wxPyBeginAllowThreads();
53371 wxGBSpan_Set(arg1,arg2,arg3);
53372 wxPyEndAllowThreads(__tstate);
53373 if (PyErr_Occurred()) SWIG_fail;
53374 }
53375 resultobj = SWIG_Py_Void();
53376 return resultobj;
53377 fail:
53378 return NULL;
53379 }
53380
53381
53382 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53383 PyObject *resultobj = 0;
53384 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53385 PyObject *result = 0 ;
53386 void *argp1 = 0 ;
53387 int res1 = 0 ;
53388 PyObject *swig_obj[1] ;
53389
53390 if (!args) SWIG_fail;
53391 swig_obj[0] = args;
53392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53393 if (!SWIG_IsOK(res1)) {
53394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53395 }
53396 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53397 {
53398 PyThreadState* __tstate = wxPyBeginAllowThreads();
53399 result = (PyObject *)wxGBSpan_Get(arg1);
53400 wxPyEndAllowThreads(__tstate);
53401 if (PyErr_Occurred()) SWIG_fail;
53402 }
53403 resultobj = result;
53404 return resultobj;
53405 fail:
53406 return NULL;
53407 }
53408
53409
53410 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53411 PyObject *obj;
53412 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53413 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
53414 return SWIG_Py_Void();
53415 }
53416
53417 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53418 return SWIG_Python_InitShadowInstance(args);
53419 }
53420
53421 SWIGINTERN int DefaultSpan_set(PyObject *) {
53422 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
53423 return 1;
53424 }
53425
53426
53427 SWIGINTERN PyObject *DefaultSpan_get(void) {
53428 PyObject *pyobj = 0;
53429
53430 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
53431 return pyobj;
53432 }
53433
53434
53435 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53436 PyObject *resultobj = 0;
53437 wxGBSizerItem *result = 0 ;
53438
53439 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
53440 {
53441 PyThreadState* __tstate = wxPyBeginAllowThreads();
53442 result = (wxGBSizerItem *)new wxGBSizerItem();
53443 wxPyEndAllowThreads(__tstate);
53444 if (PyErr_Occurred()) SWIG_fail;
53445 }
53446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
53447 return resultobj;
53448 fail:
53449 return NULL;
53450 }
53451
53452
53453 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53454 PyObject *resultobj = 0;
53455 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53456 void *argp1 = 0 ;
53457 int res1 = 0 ;
53458 PyObject *swig_obj[1] ;
53459
53460 if (!args) SWIG_fail;
53461 swig_obj[0] = args;
53462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53463 if (!SWIG_IsOK(res1)) {
53464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53465 }
53466 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53467 {
53468 PyThreadState* __tstate = wxPyBeginAllowThreads();
53469 delete arg1;
53470
53471 wxPyEndAllowThreads(__tstate);
53472 if (PyErr_Occurred()) SWIG_fail;
53473 }
53474 resultobj = SWIG_Py_Void();
53475 return resultobj;
53476 fail:
53477 return NULL;
53478 }
53479
53480
53481 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53482 PyObject *resultobj = 0;
53483 wxWindow *arg1 = (wxWindow *) 0 ;
53484 wxGBPosition *arg2 = 0 ;
53485 wxGBSpan *arg3 = 0 ;
53486 int arg4 ;
53487 int arg5 ;
53488 PyObject *arg6 = (PyObject *) NULL ;
53489 wxGBSizerItem *result = 0 ;
53490 void *argp1 = 0 ;
53491 int res1 = 0 ;
53492 wxGBPosition temp2 ;
53493 wxGBSpan temp3 ;
53494 int val4 ;
53495 int ecode4 = 0 ;
53496 int val5 ;
53497 int ecode5 = 0 ;
53498 PyObject * obj0 = 0 ;
53499 PyObject * obj1 = 0 ;
53500 PyObject * obj2 = 0 ;
53501 PyObject * obj3 = 0 ;
53502 PyObject * obj4 = 0 ;
53503 PyObject * obj5 = 0 ;
53504 char * kwnames[] = {
53505 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53506 };
53507
53508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
53510 if (!SWIG_IsOK(res1)) {
53511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
53512 }
53513 arg1 = reinterpret_cast< wxWindow * >(argp1);
53514 {
53515 arg2 = &temp2;
53516 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53517 }
53518 {
53519 arg3 = &temp3;
53520 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53521 }
53522 ecode4 = SWIG_AsVal_int(obj3, &val4);
53523 if (!SWIG_IsOK(ecode4)) {
53524 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
53525 }
53526 arg4 = static_cast< int >(val4);
53527 ecode5 = SWIG_AsVal_int(obj4, &val5);
53528 if (!SWIG_IsOK(ecode5)) {
53529 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
53530 }
53531 arg5 = static_cast< int >(val5);
53532 if (obj5) {
53533 arg6 = obj5;
53534 }
53535 {
53536 PyThreadState* __tstate = wxPyBeginAllowThreads();
53537 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53538 wxPyEndAllowThreads(__tstate);
53539 if (PyErr_Occurred()) SWIG_fail;
53540 }
53541 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53542 return resultobj;
53543 fail:
53544 return NULL;
53545 }
53546
53547
53548 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53549 PyObject *resultobj = 0;
53550 wxSizer *arg1 = (wxSizer *) 0 ;
53551 wxGBPosition *arg2 = 0 ;
53552 wxGBSpan *arg3 = 0 ;
53553 int arg4 ;
53554 int arg5 ;
53555 PyObject *arg6 = (PyObject *) NULL ;
53556 wxGBSizerItem *result = 0 ;
53557 int res1 = 0 ;
53558 wxGBPosition temp2 ;
53559 wxGBSpan temp3 ;
53560 int val4 ;
53561 int ecode4 = 0 ;
53562 int val5 ;
53563 int ecode5 = 0 ;
53564 PyObject * obj0 = 0 ;
53565 PyObject * obj1 = 0 ;
53566 PyObject * obj2 = 0 ;
53567 PyObject * obj3 = 0 ;
53568 PyObject * obj4 = 0 ;
53569 PyObject * obj5 = 0 ;
53570 char * kwnames[] = {
53571 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53572 };
53573
53574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53575 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
53576 if (!SWIG_IsOK(res1)) {
53577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
53578 }
53579 {
53580 arg2 = &temp2;
53581 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53582 }
53583 {
53584 arg3 = &temp3;
53585 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53586 }
53587 ecode4 = SWIG_AsVal_int(obj3, &val4);
53588 if (!SWIG_IsOK(ecode4)) {
53589 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
53590 }
53591 arg4 = static_cast< int >(val4);
53592 ecode5 = SWIG_AsVal_int(obj4, &val5);
53593 if (!SWIG_IsOK(ecode5)) {
53594 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
53595 }
53596 arg5 = static_cast< int >(val5);
53597 if (obj5) {
53598 arg6 = obj5;
53599 }
53600 {
53601 PyThreadState* __tstate = wxPyBeginAllowThreads();
53602 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53603 wxPyEndAllowThreads(__tstate);
53604 if (PyErr_Occurred()) SWIG_fail;
53605 }
53606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53607 return resultobj;
53608 fail:
53609 return NULL;
53610 }
53611
53612
53613 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53614 PyObject *resultobj = 0;
53615 int arg1 ;
53616 int arg2 ;
53617 wxGBPosition *arg3 = 0 ;
53618 wxGBSpan *arg4 = 0 ;
53619 int arg5 ;
53620 int arg6 ;
53621 PyObject *arg7 = (PyObject *) NULL ;
53622 wxGBSizerItem *result = 0 ;
53623 int val1 ;
53624 int ecode1 = 0 ;
53625 int val2 ;
53626 int ecode2 = 0 ;
53627 wxGBPosition temp3 ;
53628 wxGBSpan temp4 ;
53629 int val5 ;
53630 int ecode5 = 0 ;
53631 int val6 ;
53632 int ecode6 = 0 ;
53633 PyObject * obj0 = 0 ;
53634 PyObject * obj1 = 0 ;
53635 PyObject * obj2 = 0 ;
53636 PyObject * obj3 = 0 ;
53637 PyObject * obj4 = 0 ;
53638 PyObject * obj5 = 0 ;
53639 PyObject * obj6 = 0 ;
53640 char * kwnames[] = {
53641 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53642 };
53643
53644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53645 ecode1 = SWIG_AsVal_int(obj0, &val1);
53646 if (!SWIG_IsOK(ecode1)) {
53647 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
53648 }
53649 arg1 = static_cast< int >(val1);
53650 ecode2 = SWIG_AsVal_int(obj1, &val2);
53651 if (!SWIG_IsOK(ecode2)) {
53652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
53653 }
53654 arg2 = static_cast< int >(val2);
53655 {
53656 arg3 = &temp3;
53657 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53658 }
53659 {
53660 arg4 = &temp4;
53661 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53662 }
53663 ecode5 = SWIG_AsVal_int(obj4, &val5);
53664 if (!SWIG_IsOK(ecode5)) {
53665 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
53666 }
53667 arg5 = static_cast< int >(val5);
53668 ecode6 = SWIG_AsVal_int(obj5, &val6);
53669 if (!SWIG_IsOK(ecode6)) {
53670 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
53671 }
53672 arg6 = static_cast< int >(val6);
53673 if (obj6) {
53674 arg7 = obj6;
53675 }
53676 {
53677 PyThreadState* __tstate = wxPyBeginAllowThreads();
53678 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53679 wxPyEndAllowThreads(__tstate);
53680 if (PyErr_Occurred()) SWIG_fail;
53681 }
53682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53683 return resultobj;
53684 fail:
53685 return NULL;
53686 }
53687
53688
53689 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53690 PyObject *resultobj = 0;
53691 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53692 wxGBPosition result;
53693 void *argp1 = 0 ;
53694 int res1 = 0 ;
53695 PyObject *swig_obj[1] ;
53696
53697 if (!args) SWIG_fail;
53698 swig_obj[0] = args;
53699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53700 if (!SWIG_IsOK(res1)) {
53701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53702 }
53703 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53704 {
53705 PyThreadState* __tstate = wxPyBeginAllowThreads();
53706 result = ((wxGBSizerItem const *)arg1)->GetPos();
53707 wxPyEndAllowThreads(__tstate);
53708 if (PyErr_Occurred()) SWIG_fail;
53709 }
53710 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53711 return resultobj;
53712 fail:
53713 return NULL;
53714 }
53715
53716
53717 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53718 PyObject *resultobj = 0;
53719 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53720 wxGBSpan result;
53721 void *argp1 = 0 ;
53722 int res1 = 0 ;
53723 PyObject *swig_obj[1] ;
53724
53725 if (!args) SWIG_fail;
53726 swig_obj[0] = args;
53727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53728 if (!SWIG_IsOK(res1)) {
53729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53730 }
53731 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53732 {
53733 PyThreadState* __tstate = wxPyBeginAllowThreads();
53734 result = ((wxGBSizerItem const *)arg1)->GetSpan();
53735 wxPyEndAllowThreads(__tstate);
53736 if (PyErr_Occurred()) SWIG_fail;
53737 }
53738 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
53739 return resultobj;
53740 fail:
53741 return NULL;
53742 }
53743
53744
53745 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53746 PyObject *resultobj = 0;
53747 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53748 wxGBPosition *arg2 = 0 ;
53749 bool result;
53750 void *argp1 = 0 ;
53751 int res1 = 0 ;
53752 wxGBPosition temp2 ;
53753 PyObject * obj0 = 0 ;
53754 PyObject * obj1 = 0 ;
53755 char * kwnames[] = {
53756 (char *) "self",(char *) "pos", NULL
53757 };
53758
53759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
53760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53761 if (!SWIG_IsOK(res1)) {
53762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53763 }
53764 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53765 {
53766 arg2 = &temp2;
53767 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53768 }
53769 {
53770 PyThreadState* __tstate = wxPyBeginAllowThreads();
53771 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
53772 wxPyEndAllowThreads(__tstate);
53773 if (PyErr_Occurred()) SWIG_fail;
53774 }
53775 {
53776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53777 }
53778 return resultobj;
53779 fail:
53780 return NULL;
53781 }
53782
53783
53784 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53785 PyObject *resultobj = 0;
53786 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53787 wxGBSpan *arg2 = 0 ;
53788 bool result;
53789 void *argp1 = 0 ;
53790 int res1 = 0 ;
53791 wxGBSpan temp2 ;
53792 PyObject * obj0 = 0 ;
53793 PyObject * obj1 = 0 ;
53794 char * kwnames[] = {
53795 (char *) "self",(char *) "span", NULL
53796 };
53797
53798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53800 if (!SWIG_IsOK(res1)) {
53801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53802 }
53803 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53804 {
53805 arg2 = &temp2;
53806 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
53807 }
53808 {
53809 PyThreadState* __tstate = wxPyBeginAllowThreads();
53810 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
53811 wxPyEndAllowThreads(__tstate);
53812 if (PyErr_Occurred()) SWIG_fail;
53813 }
53814 {
53815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53816 }
53817 return resultobj;
53818 fail:
53819 return NULL;
53820 }
53821
53822
53823 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53824 PyObject *resultobj = 0;
53825 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53826 wxGBSizerItem *arg2 = 0 ;
53827 bool result;
53828 void *argp1 = 0 ;
53829 int res1 = 0 ;
53830 void *argp2 = 0 ;
53831 int res2 = 0 ;
53832 PyObject * obj0 = 0 ;
53833 PyObject * obj1 = 0 ;
53834 char * kwnames[] = {
53835 (char *) "self",(char *) "other", NULL
53836 };
53837
53838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
53839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53840 if (!SWIG_IsOK(res1)) {
53841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53842 }
53843 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53844 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
53845 if (!SWIG_IsOK(res2)) {
53846 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53847 }
53848 if (!argp2) {
53849 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53850 }
53851 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
53852 {
53853 PyThreadState* __tstate = wxPyBeginAllowThreads();
53854 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
53855 wxPyEndAllowThreads(__tstate);
53856 if (PyErr_Occurred()) SWIG_fail;
53857 }
53858 {
53859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53860 }
53861 return resultobj;
53862 fail:
53863 return NULL;
53864 }
53865
53866
53867 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53868 PyObject *resultobj = 0;
53869 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53870 wxGBPosition *arg2 = 0 ;
53871 wxGBSpan *arg3 = 0 ;
53872 bool result;
53873 void *argp1 = 0 ;
53874 int res1 = 0 ;
53875 wxGBPosition temp2 ;
53876 wxGBSpan temp3 ;
53877 PyObject * obj0 = 0 ;
53878 PyObject * obj1 = 0 ;
53879 PyObject * obj2 = 0 ;
53880 char * kwnames[] = {
53881 (char *) "self",(char *) "pos",(char *) "span", NULL
53882 };
53883
53884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53886 if (!SWIG_IsOK(res1)) {
53887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53888 }
53889 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53890 {
53891 arg2 = &temp2;
53892 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53893 }
53894 {
53895 arg3 = &temp3;
53896 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53897 }
53898 {
53899 PyThreadState* __tstate = wxPyBeginAllowThreads();
53900 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
53901 wxPyEndAllowThreads(__tstate);
53902 if (PyErr_Occurred()) SWIG_fail;
53903 }
53904 {
53905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53906 }
53907 return resultobj;
53908 fail:
53909 return NULL;
53910 }
53911
53912
53913 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53914 PyObject *resultobj = 0;
53915 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53916 wxGBPosition result;
53917 void *argp1 = 0 ;
53918 int res1 = 0 ;
53919 PyObject *swig_obj[1] ;
53920
53921 if (!args) SWIG_fail;
53922 swig_obj[0] = args;
53923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53924 if (!SWIG_IsOK(res1)) {
53925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53926 }
53927 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53928 {
53929 PyThreadState* __tstate = wxPyBeginAllowThreads();
53930 result = wxGBSizerItem_GetEndPos(arg1);
53931 wxPyEndAllowThreads(__tstate);
53932 if (PyErr_Occurred()) SWIG_fail;
53933 }
53934 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53935 return resultobj;
53936 fail:
53937 return NULL;
53938 }
53939
53940
53941 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53942 PyObject *resultobj = 0;
53943 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53944 wxGridBagSizer *result = 0 ;
53945 void *argp1 = 0 ;
53946 int res1 = 0 ;
53947 PyObject *swig_obj[1] ;
53948
53949 if (!args) SWIG_fail;
53950 swig_obj[0] = args;
53951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53952 if (!SWIG_IsOK(res1)) {
53953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53954 }
53955 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53956 {
53957 PyThreadState* __tstate = wxPyBeginAllowThreads();
53958 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
53959 wxPyEndAllowThreads(__tstate);
53960 if (PyErr_Occurred()) SWIG_fail;
53961 }
53962 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53963 return resultobj;
53964 fail:
53965 return NULL;
53966 }
53967
53968
53969 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53970 PyObject *resultobj = 0;
53971 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53972 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
53973 void *argp1 = 0 ;
53974 int res1 = 0 ;
53975 void *argp2 = 0 ;
53976 int res2 = 0 ;
53977 PyObject * obj0 = 0 ;
53978 PyObject * obj1 = 0 ;
53979 char * kwnames[] = {
53980 (char *) "self",(char *) "sizer", NULL
53981 };
53982
53983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53985 if (!SWIG_IsOK(res1)) {
53986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53987 }
53988 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53989 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53990 if (!SWIG_IsOK(res2)) {
53991 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
53992 }
53993 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
53994 {
53995 PyThreadState* __tstate = wxPyBeginAllowThreads();
53996 (arg1)->SetGBSizer(arg2);
53997 wxPyEndAllowThreads(__tstate);
53998 if (PyErr_Occurred()) SWIG_fail;
53999 }
54000 resultobj = SWIG_Py_Void();
54001 return resultobj;
54002 fail:
54003 return NULL;
54004 }
54005
54006
54007 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54008 PyObject *obj;
54009 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54010 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
54011 return SWIG_Py_Void();
54012 }
54013
54014 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54015 return SWIG_Python_InitShadowInstance(args);
54016 }
54017
54018 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54019 PyObject *resultobj = 0;
54020 int arg1 = (int) 0 ;
54021 int arg2 = (int) 0 ;
54022 wxGridBagSizer *result = 0 ;
54023 int val1 ;
54024 int ecode1 = 0 ;
54025 int val2 ;
54026 int ecode2 = 0 ;
54027 PyObject * obj0 = 0 ;
54028 PyObject * obj1 = 0 ;
54029 char * kwnames[] = {
54030 (char *) "vgap",(char *) "hgap", NULL
54031 };
54032
54033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
54034 if (obj0) {
54035 ecode1 = SWIG_AsVal_int(obj0, &val1);
54036 if (!SWIG_IsOK(ecode1)) {
54037 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
54038 }
54039 arg1 = static_cast< int >(val1);
54040 }
54041 if (obj1) {
54042 ecode2 = SWIG_AsVal_int(obj1, &val2);
54043 if (!SWIG_IsOK(ecode2)) {
54044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
54045 }
54046 arg2 = static_cast< int >(val2);
54047 }
54048 {
54049 PyThreadState* __tstate = wxPyBeginAllowThreads();
54050 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
54051 wxPyEndAllowThreads(__tstate);
54052 if (PyErr_Occurred()) SWIG_fail;
54053 }
54054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
54055 return resultobj;
54056 fail:
54057 return NULL;
54058 }
54059
54060
54061 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54062 PyObject *resultobj = 0;
54063 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54064 PyObject *arg2 = (PyObject *) 0 ;
54065 wxGBPosition *arg3 = 0 ;
54066 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
54067 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
54068 int arg5 = (int) 0 ;
54069 int arg6 = (int) 0 ;
54070 PyObject *arg7 = (PyObject *) NULL ;
54071 wxGBSizerItem *result = 0 ;
54072 void *argp1 = 0 ;
54073 int res1 = 0 ;
54074 wxGBPosition temp3 ;
54075 wxGBSpan temp4 ;
54076 int val5 ;
54077 int ecode5 = 0 ;
54078 int val6 ;
54079 int ecode6 = 0 ;
54080 PyObject * obj0 = 0 ;
54081 PyObject * obj1 = 0 ;
54082 PyObject * obj2 = 0 ;
54083 PyObject * obj3 = 0 ;
54084 PyObject * obj4 = 0 ;
54085 PyObject * obj5 = 0 ;
54086 PyObject * obj6 = 0 ;
54087 char * kwnames[] = {
54088 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
54089 };
54090
54091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
54092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54093 if (!SWIG_IsOK(res1)) {
54094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54095 }
54096 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54097 arg2 = obj1;
54098 {
54099 arg3 = &temp3;
54100 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
54101 }
54102 if (obj3) {
54103 {
54104 arg4 = &temp4;
54105 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
54106 }
54107 }
54108 if (obj4) {
54109 ecode5 = SWIG_AsVal_int(obj4, &val5);
54110 if (!SWIG_IsOK(ecode5)) {
54111 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
54112 }
54113 arg5 = static_cast< int >(val5);
54114 }
54115 if (obj5) {
54116 ecode6 = SWIG_AsVal_int(obj5, &val6);
54117 if (!SWIG_IsOK(ecode6)) {
54118 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
54119 }
54120 arg6 = static_cast< int >(val6);
54121 }
54122 if (obj6) {
54123 arg7 = obj6;
54124 }
54125 {
54126 PyThreadState* __tstate = wxPyBeginAllowThreads();
54127 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
54128 wxPyEndAllowThreads(__tstate);
54129 if (PyErr_Occurred()) SWIG_fail;
54130 }
54131 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54132 return resultobj;
54133 fail:
54134 return NULL;
54135 }
54136
54137
54138 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54139 PyObject *resultobj = 0;
54140 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54141 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54142 wxGBSizerItem *result = 0 ;
54143 void *argp1 = 0 ;
54144 int res1 = 0 ;
54145 int res2 = 0 ;
54146 PyObject * obj0 = 0 ;
54147 PyObject * obj1 = 0 ;
54148 char * kwnames[] = {
54149 (char *) "self",(char *) "item", NULL
54150 };
54151
54152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
54153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54154 if (!SWIG_IsOK(res1)) {
54155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54156 }
54157 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54158 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
54159 if (!SWIG_IsOK(res2)) {
54160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54161 }
54162 {
54163 PyThreadState* __tstate = wxPyBeginAllowThreads();
54164 result = (wxGBSizerItem *)(arg1)->Add(arg2);
54165 wxPyEndAllowThreads(__tstate);
54166 if (PyErr_Occurred()) SWIG_fail;
54167 }
54168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54169 return resultobj;
54170 fail:
54171 return NULL;
54172 }
54173
54174
54175 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54176 PyObject *resultobj = 0;
54177 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54178 int arg2 ;
54179 int arg3 ;
54180 wxSize result;
54181 void *argp1 = 0 ;
54182 int res1 = 0 ;
54183 int val2 ;
54184 int ecode2 = 0 ;
54185 int val3 ;
54186 int ecode3 = 0 ;
54187 PyObject * obj0 = 0 ;
54188 PyObject * obj1 = 0 ;
54189 PyObject * obj2 = 0 ;
54190 char * kwnames[] = {
54191 (char *) "self",(char *) "row",(char *) "col", NULL
54192 };
54193
54194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54196 if (!SWIG_IsOK(res1)) {
54197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54198 }
54199 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54200 ecode2 = SWIG_AsVal_int(obj1, &val2);
54201 if (!SWIG_IsOK(ecode2)) {
54202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
54203 }
54204 arg2 = static_cast< int >(val2);
54205 ecode3 = SWIG_AsVal_int(obj2, &val3);
54206 if (!SWIG_IsOK(ecode3)) {
54207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
54208 }
54209 arg3 = static_cast< int >(val3);
54210 {
54211 PyThreadState* __tstate = wxPyBeginAllowThreads();
54212 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
54213 wxPyEndAllowThreads(__tstate);
54214 if (PyErr_Occurred()) SWIG_fail;
54215 }
54216 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54217 return resultobj;
54218 fail:
54219 return NULL;
54220 }
54221
54222
54223 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54224 PyObject *resultobj = 0;
54225 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54226 wxSize result;
54227 void *argp1 = 0 ;
54228 int res1 = 0 ;
54229 PyObject *swig_obj[1] ;
54230
54231 if (!args) SWIG_fail;
54232 swig_obj[0] = args;
54233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54234 if (!SWIG_IsOK(res1)) {
54235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54236 }
54237 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54238 {
54239 PyThreadState* __tstate = wxPyBeginAllowThreads();
54240 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
54241 wxPyEndAllowThreads(__tstate);
54242 if (PyErr_Occurred()) SWIG_fail;
54243 }
54244 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54245 return resultobj;
54246 fail:
54247 return NULL;
54248 }
54249
54250
54251 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54252 PyObject *resultobj = 0;
54253 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54254 wxSize *arg2 = 0 ;
54255 void *argp1 = 0 ;
54256 int res1 = 0 ;
54257 wxSize temp2 ;
54258 PyObject * obj0 = 0 ;
54259 PyObject * obj1 = 0 ;
54260 char * kwnames[] = {
54261 (char *) "self",(char *) "sz", NULL
54262 };
54263
54264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
54265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54266 if (!SWIG_IsOK(res1)) {
54267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54268 }
54269 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54270 {
54271 arg2 = &temp2;
54272 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
54273 }
54274 {
54275 PyThreadState* __tstate = wxPyBeginAllowThreads();
54276 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
54277 wxPyEndAllowThreads(__tstate);
54278 if (PyErr_Occurred()) SWIG_fail;
54279 }
54280 resultobj = SWIG_Py_Void();
54281 return resultobj;
54282 fail:
54283 return NULL;
54284 }
54285
54286
54287 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54288 PyObject *resultobj = 0;
54289 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54290 wxWindow *arg2 = (wxWindow *) 0 ;
54291 wxGBPosition result;
54292 void *argp1 = 0 ;
54293 int res1 = 0 ;
54294 void *argp2 = 0 ;
54295 int res2 = 0 ;
54296
54297 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54299 if (!SWIG_IsOK(res1)) {
54300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54301 }
54302 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54303 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54304 if (!SWIG_IsOK(res2)) {
54305 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54306 }
54307 arg2 = reinterpret_cast< wxWindow * >(argp2);
54308 {
54309 PyThreadState* __tstate = wxPyBeginAllowThreads();
54310 result = (arg1)->GetItemPosition(arg2);
54311 wxPyEndAllowThreads(__tstate);
54312 if (PyErr_Occurred()) SWIG_fail;
54313 }
54314 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54315 return resultobj;
54316 fail:
54317 return NULL;
54318 }
54319
54320
54321 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54322 PyObject *resultobj = 0;
54323 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54324 wxSizer *arg2 = (wxSizer *) 0 ;
54325 wxGBPosition result;
54326 void *argp1 = 0 ;
54327 int res1 = 0 ;
54328 void *argp2 = 0 ;
54329 int res2 = 0 ;
54330
54331 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54333 if (!SWIG_IsOK(res1)) {
54334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54335 }
54336 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54337 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54338 if (!SWIG_IsOK(res2)) {
54339 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54340 }
54341 arg2 = reinterpret_cast< wxSizer * >(argp2);
54342 {
54343 PyThreadState* __tstate = wxPyBeginAllowThreads();
54344 result = (arg1)->GetItemPosition(arg2);
54345 wxPyEndAllowThreads(__tstate);
54346 if (PyErr_Occurred()) SWIG_fail;
54347 }
54348 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54349 return resultobj;
54350 fail:
54351 return NULL;
54352 }
54353
54354
54355 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54356 PyObject *resultobj = 0;
54357 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54358 size_t arg2 ;
54359 wxGBPosition result;
54360 void *argp1 = 0 ;
54361 int res1 = 0 ;
54362 size_t val2 ;
54363 int ecode2 = 0 ;
54364
54365 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54367 if (!SWIG_IsOK(res1)) {
54368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54369 }
54370 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54371 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54372 if (!SWIG_IsOK(ecode2)) {
54373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54374 }
54375 arg2 = static_cast< size_t >(val2);
54376 {
54377 PyThreadState* __tstate = wxPyBeginAllowThreads();
54378 result = (arg1)->GetItemPosition(arg2);
54379 wxPyEndAllowThreads(__tstate);
54380 if (PyErr_Occurred()) SWIG_fail;
54381 }
54382 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54383 return resultobj;
54384 fail:
54385 return NULL;
54386 }
54387
54388
54389 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
54390 int argc;
54391 PyObject *argv[3];
54392
54393 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
54394 --argc;
54395 if (argc == 2) {
54396 int _v = 0;
54397 {
54398 void *vptr = 0;
54399 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54400 _v = SWIG_CheckState(res);
54401 }
54402 if (!_v) goto check_1;
54403 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
54404 }
54405 check_1:
54406
54407 if (argc == 2) {
54408 int _v = 0;
54409 {
54410 void *vptr = 0;
54411 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54412 _v = SWIG_CheckState(res);
54413 }
54414 if (!_v) goto check_2;
54415 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
54416 }
54417 check_2:
54418
54419 if (argc == 2) {
54420 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
54421 }
54422
54423 fail:
54424 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
54425 return NULL;
54426 }
54427
54428
54429 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54430 PyObject *resultobj = 0;
54431 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54432 wxWindow *arg2 = (wxWindow *) 0 ;
54433 wxGBPosition *arg3 = 0 ;
54434 bool result;
54435 void *argp1 = 0 ;
54436 int res1 = 0 ;
54437 void *argp2 = 0 ;
54438 int res2 = 0 ;
54439 wxGBPosition temp3 ;
54440
54441 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54443 if (!SWIG_IsOK(res1)) {
54444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54445 }
54446 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54447 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54448 if (!SWIG_IsOK(res2)) {
54449 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54450 }
54451 arg2 = reinterpret_cast< wxWindow * >(argp2);
54452 {
54453 arg3 = &temp3;
54454 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54455 }
54456 {
54457 PyThreadState* __tstate = wxPyBeginAllowThreads();
54458 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54459 wxPyEndAllowThreads(__tstate);
54460 if (PyErr_Occurred()) SWIG_fail;
54461 }
54462 {
54463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54464 }
54465 return resultobj;
54466 fail:
54467 return NULL;
54468 }
54469
54470
54471 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54472 PyObject *resultobj = 0;
54473 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54474 wxSizer *arg2 = (wxSizer *) 0 ;
54475 wxGBPosition *arg3 = 0 ;
54476 bool result;
54477 void *argp1 = 0 ;
54478 int res1 = 0 ;
54479 void *argp2 = 0 ;
54480 int res2 = 0 ;
54481 wxGBPosition temp3 ;
54482
54483 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54485 if (!SWIG_IsOK(res1)) {
54486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54487 }
54488 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54489 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54490 if (!SWIG_IsOK(res2)) {
54491 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54492 }
54493 arg2 = reinterpret_cast< wxSizer * >(argp2);
54494 {
54495 arg3 = &temp3;
54496 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54497 }
54498 {
54499 PyThreadState* __tstate = wxPyBeginAllowThreads();
54500 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54501 wxPyEndAllowThreads(__tstate);
54502 if (PyErr_Occurred()) SWIG_fail;
54503 }
54504 {
54505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54506 }
54507 return resultobj;
54508 fail:
54509 return NULL;
54510 }
54511
54512
54513 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54514 PyObject *resultobj = 0;
54515 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54516 size_t arg2 ;
54517 wxGBPosition *arg3 = 0 ;
54518 bool result;
54519 void *argp1 = 0 ;
54520 int res1 = 0 ;
54521 size_t val2 ;
54522 int ecode2 = 0 ;
54523 wxGBPosition temp3 ;
54524
54525 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54527 if (!SWIG_IsOK(res1)) {
54528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54529 }
54530 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54531 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54532 if (!SWIG_IsOK(ecode2)) {
54533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54534 }
54535 arg2 = static_cast< size_t >(val2);
54536 {
54537 arg3 = &temp3;
54538 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54539 }
54540 {
54541 PyThreadState* __tstate = wxPyBeginAllowThreads();
54542 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54543 wxPyEndAllowThreads(__tstate);
54544 if (PyErr_Occurred()) SWIG_fail;
54545 }
54546 {
54547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54548 }
54549 return resultobj;
54550 fail:
54551 return NULL;
54552 }
54553
54554
54555 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
54556 int argc;
54557 PyObject *argv[4];
54558
54559 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
54560 --argc;
54561 if (argc == 3) {
54562 int _v = 0;
54563 {
54564 void *vptr = 0;
54565 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54566 _v = SWIG_CheckState(res);
54567 }
54568 if (!_v) goto check_1;
54569 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
54570 }
54571 check_1:
54572
54573 if (argc == 3) {
54574 int _v = 0;
54575 {
54576 void *vptr = 0;
54577 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54578 _v = SWIG_CheckState(res);
54579 }
54580 if (!_v) goto check_2;
54581 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
54582 }
54583 check_2:
54584
54585 if (argc == 3) {
54586 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
54587 }
54588
54589 fail:
54590 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
54591 return NULL;
54592 }
54593
54594
54595 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54596 PyObject *resultobj = 0;
54597 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54598 wxWindow *arg2 = (wxWindow *) 0 ;
54599 wxGBSpan result;
54600 void *argp1 = 0 ;
54601 int res1 = 0 ;
54602 void *argp2 = 0 ;
54603 int res2 = 0 ;
54604
54605 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54607 if (!SWIG_IsOK(res1)) {
54608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54609 }
54610 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54611 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54612 if (!SWIG_IsOK(res2)) {
54613 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54614 }
54615 arg2 = reinterpret_cast< wxWindow * >(argp2);
54616 {
54617 PyThreadState* __tstate = wxPyBeginAllowThreads();
54618 result = (arg1)->GetItemSpan(arg2);
54619 wxPyEndAllowThreads(__tstate);
54620 if (PyErr_Occurred()) SWIG_fail;
54621 }
54622 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54623 return resultobj;
54624 fail:
54625 return NULL;
54626 }
54627
54628
54629 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54630 PyObject *resultobj = 0;
54631 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54632 wxSizer *arg2 = (wxSizer *) 0 ;
54633 wxGBSpan result;
54634 void *argp1 = 0 ;
54635 int res1 = 0 ;
54636 void *argp2 = 0 ;
54637 int res2 = 0 ;
54638
54639 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54641 if (!SWIG_IsOK(res1)) {
54642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54643 }
54644 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54645 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54646 if (!SWIG_IsOK(res2)) {
54647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54648 }
54649 arg2 = reinterpret_cast< wxSizer * >(argp2);
54650 {
54651 PyThreadState* __tstate = wxPyBeginAllowThreads();
54652 result = (arg1)->GetItemSpan(arg2);
54653 wxPyEndAllowThreads(__tstate);
54654 if (PyErr_Occurred()) SWIG_fail;
54655 }
54656 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54657 return resultobj;
54658 fail:
54659 return NULL;
54660 }
54661
54662
54663 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54664 PyObject *resultobj = 0;
54665 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54666 size_t arg2 ;
54667 wxGBSpan result;
54668 void *argp1 = 0 ;
54669 int res1 = 0 ;
54670 size_t val2 ;
54671 int ecode2 = 0 ;
54672
54673 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54675 if (!SWIG_IsOK(res1)) {
54676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54677 }
54678 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54679 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54680 if (!SWIG_IsOK(ecode2)) {
54681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54682 }
54683 arg2 = static_cast< size_t >(val2);
54684 {
54685 PyThreadState* __tstate = wxPyBeginAllowThreads();
54686 result = (arg1)->GetItemSpan(arg2);
54687 wxPyEndAllowThreads(__tstate);
54688 if (PyErr_Occurred()) SWIG_fail;
54689 }
54690 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54691 return resultobj;
54692 fail:
54693 return NULL;
54694 }
54695
54696
54697 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
54698 int argc;
54699 PyObject *argv[3];
54700
54701 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
54702 --argc;
54703 if (argc == 2) {
54704 int _v = 0;
54705 {
54706 void *vptr = 0;
54707 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54708 _v = SWIG_CheckState(res);
54709 }
54710 if (!_v) goto check_1;
54711 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
54712 }
54713 check_1:
54714
54715 if (argc == 2) {
54716 int _v = 0;
54717 {
54718 void *vptr = 0;
54719 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54720 _v = SWIG_CheckState(res);
54721 }
54722 if (!_v) goto check_2;
54723 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
54724 }
54725 check_2:
54726
54727 if (argc == 2) {
54728 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
54729 }
54730
54731 fail:
54732 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
54733 return NULL;
54734 }
54735
54736
54737 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54738 PyObject *resultobj = 0;
54739 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54740 wxWindow *arg2 = (wxWindow *) 0 ;
54741 wxGBSpan *arg3 = 0 ;
54742 bool result;
54743 void *argp1 = 0 ;
54744 int res1 = 0 ;
54745 void *argp2 = 0 ;
54746 int res2 = 0 ;
54747 wxGBSpan temp3 ;
54748
54749 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54751 if (!SWIG_IsOK(res1)) {
54752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54753 }
54754 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54755 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54756 if (!SWIG_IsOK(res2)) {
54757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54758 }
54759 arg2 = reinterpret_cast< wxWindow * >(argp2);
54760 {
54761 arg3 = &temp3;
54762 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54763 }
54764 {
54765 PyThreadState* __tstate = wxPyBeginAllowThreads();
54766 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54767 wxPyEndAllowThreads(__tstate);
54768 if (PyErr_Occurred()) SWIG_fail;
54769 }
54770 {
54771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54772 }
54773 return resultobj;
54774 fail:
54775 return NULL;
54776 }
54777
54778
54779 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54780 PyObject *resultobj = 0;
54781 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54782 wxSizer *arg2 = (wxSizer *) 0 ;
54783 wxGBSpan *arg3 = 0 ;
54784 bool result;
54785 void *argp1 = 0 ;
54786 int res1 = 0 ;
54787 void *argp2 = 0 ;
54788 int res2 = 0 ;
54789 wxGBSpan temp3 ;
54790
54791 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54793 if (!SWIG_IsOK(res1)) {
54794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54795 }
54796 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54797 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54798 if (!SWIG_IsOK(res2)) {
54799 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54800 }
54801 arg2 = reinterpret_cast< wxSizer * >(argp2);
54802 {
54803 arg3 = &temp3;
54804 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54805 }
54806 {
54807 PyThreadState* __tstate = wxPyBeginAllowThreads();
54808 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54809 wxPyEndAllowThreads(__tstate);
54810 if (PyErr_Occurred()) SWIG_fail;
54811 }
54812 {
54813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54814 }
54815 return resultobj;
54816 fail:
54817 return NULL;
54818 }
54819
54820
54821 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54822 PyObject *resultobj = 0;
54823 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54824 size_t arg2 ;
54825 wxGBSpan *arg3 = 0 ;
54826 bool result;
54827 void *argp1 = 0 ;
54828 int res1 = 0 ;
54829 size_t val2 ;
54830 int ecode2 = 0 ;
54831 wxGBSpan temp3 ;
54832
54833 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54835 if (!SWIG_IsOK(res1)) {
54836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54837 }
54838 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54839 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54840 if (!SWIG_IsOK(ecode2)) {
54841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54842 }
54843 arg2 = static_cast< size_t >(val2);
54844 {
54845 arg3 = &temp3;
54846 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54847 }
54848 {
54849 PyThreadState* __tstate = wxPyBeginAllowThreads();
54850 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54851 wxPyEndAllowThreads(__tstate);
54852 if (PyErr_Occurred()) SWIG_fail;
54853 }
54854 {
54855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54856 }
54857 return resultobj;
54858 fail:
54859 return NULL;
54860 }
54861
54862
54863 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
54864 int argc;
54865 PyObject *argv[4];
54866
54867 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
54868 --argc;
54869 if (argc == 3) {
54870 int _v = 0;
54871 {
54872 void *vptr = 0;
54873 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54874 _v = SWIG_CheckState(res);
54875 }
54876 if (!_v) goto check_1;
54877 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
54878 }
54879 check_1:
54880
54881 if (argc == 3) {
54882 int _v = 0;
54883 {
54884 void *vptr = 0;
54885 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54886 _v = SWIG_CheckState(res);
54887 }
54888 if (!_v) goto check_2;
54889 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
54890 }
54891 check_2:
54892
54893 if (argc == 3) {
54894 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
54895 }
54896
54897 fail:
54898 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
54899 return NULL;
54900 }
54901
54902
54903 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54904 PyObject *resultobj = 0;
54905 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54906 wxWindow *arg2 = (wxWindow *) 0 ;
54907 wxGBSizerItem *result = 0 ;
54908 void *argp1 = 0 ;
54909 int res1 = 0 ;
54910 void *argp2 = 0 ;
54911 int res2 = 0 ;
54912
54913 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54915 if (!SWIG_IsOK(res1)) {
54916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54917 }
54918 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54919 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54920 if (!SWIG_IsOK(res2)) {
54921 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
54922 }
54923 arg2 = reinterpret_cast< wxWindow * >(argp2);
54924 {
54925 PyThreadState* __tstate = wxPyBeginAllowThreads();
54926 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54927 wxPyEndAllowThreads(__tstate);
54928 if (PyErr_Occurred()) SWIG_fail;
54929 }
54930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54931 return resultobj;
54932 fail:
54933 return NULL;
54934 }
54935
54936
54937 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54938 PyObject *resultobj = 0;
54939 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54940 wxSizer *arg2 = (wxSizer *) 0 ;
54941 wxGBSizerItem *result = 0 ;
54942 void *argp1 = 0 ;
54943 int res1 = 0 ;
54944 void *argp2 = 0 ;
54945 int res2 = 0 ;
54946
54947 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54949 if (!SWIG_IsOK(res1)) {
54950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54951 }
54952 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54953 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54954 if (!SWIG_IsOK(res2)) {
54955 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
54956 }
54957 arg2 = reinterpret_cast< wxSizer * >(argp2);
54958 {
54959 PyThreadState* __tstate = wxPyBeginAllowThreads();
54960 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54961 wxPyEndAllowThreads(__tstate);
54962 if (PyErr_Occurred()) SWIG_fail;
54963 }
54964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54965 return resultobj;
54966 fail:
54967 return NULL;
54968 }
54969
54970
54971 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
54972 int argc;
54973 PyObject *argv[3];
54974
54975 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
54976 --argc;
54977 if (argc == 2) {
54978 int _v = 0;
54979 {
54980 void *vptr = 0;
54981 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54982 _v = SWIG_CheckState(res);
54983 }
54984 if (!_v) goto check_1;
54985 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
54986 }
54987 check_1:
54988
54989 if (argc == 2) {
54990 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
54991 }
54992
54993 fail:
54994 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
54995 return NULL;
54996 }
54997
54998
54999 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55000 PyObject *resultobj = 0;
55001 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55002 wxGBPosition *arg2 = 0 ;
55003 wxGBSizerItem *result = 0 ;
55004 void *argp1 = 0 ;
55005 int res1 = 0 ;
55006 wxGBPosition temp2 ;
55007 PyObject * obj0 = 0 ;
55008 PyObject * obj1 = 0 ;
55009 char * kwnames[] = {
55010 (char *) "self",(char *) "pos", NULL
55011 };
55012
55013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
55014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55015 if (!SWIG_IsOK(res1)) {
55016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55017 }
55018 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55019 {
55020 arg2 = &temp2;
55021 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55022 }
55023 {
55024 PyThreadState* __tstate = wxPyBeginAllowThreads();
55025 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
55026 wxPyEndAllowThreads(__tstate);
55027 if (PyErr_Occurred()) SWIG_fail;
55028 }
55029 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55030 return resultobj;
55031 fail:
55032 return NULL;
55033 }
55034
55035
55036 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55037 PyObject *resultobj = 0;
55038 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55039 wxPoint *arg2 = 0 ;
55040 wxGBSizerItem *result = 0 ;
55041 void *argp1 = 0 ;
55042 int res1 = 0 ;
55043 wxPoint temp2 ;
55044 PyObject * obj0 = 0 ;
55045 PyObject * obj1 = 0 ;
55046 char * kwnames[] = {
55047 (char *) "self",(char *) "pt", NULL
55048 };
55049
55050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
55051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55052 if (!SWIG_IsOK(res1)) {
55053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55054 }
55055 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55056 {
55057 arg2 = &temp2;
55058 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
55059 }
55060 {
55061 PyThreadState* __tstate = wxPyBeginAllowThreads();
55062 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
55063 wxPyEndAllowThreads(__tstate);
55064 if (PyErr_Occurred()) SWIG_fail;
55065 }
55066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55067 return resultobj;
55068 fail:
55069 return NULL;
55070 }
55071
55072
55073 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55074 PyObject *resultobj = 0;
55075 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55076 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
55077 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
55078 bool result;
55079 void *argp1 = 0 ;
55080 int res1 = 0 ;
55081 void *argp2 = 0 ;
55082 int res2 = 0 ;
55083 void *argp3 = 0 ;
55084 int res3 = 0 ;
55085 PyObject * obj0 = 0 ;
55086 PyObject * obj1 = 0 ;
55087 PyObject * obj2 = 0 ;
55088 char * kwnames[] = {
55089 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
55090 };
55091
55092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55094 if (!SWIG_IsOK(res1)) {
55095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55096 }
55097 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55098 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55099 if (!SWIG_IsOK(res2)) {
55100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
55101 }
55102 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
55103 if (obj2) {
55104 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55105 if (!SWIG_IsOK(res3)) {
55106 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
55107 }
55108 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
55109 }
55110 {
55111 PyThreadState* __tstate = wxPyBeginAllowThreads();
55112 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
55113 wxPyEndAllowThreads(__tstate);
55114 if (PyErr_Occurred()) SWIG_fail;
55115 }
55116 {
55117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55118 }
55119 return resultobj;
55120 fail:
55121 return NULL;
55122 }
55123
55124
55125 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55126 PyObject *resultobj = 0;
55127 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55128 wxGBPosition *arg2 = 0 ;
55129 wxGBSpan *arg3 = 0 ;
55130 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
55131 bool result;
55132 void *argp1 = 0 ;
55133 int res1 = 0 ;
55134 wxGBPosition temp2 ;
55135 wxGBSpan temp3 ;
55136 void *argp4 = 0 ;
55137 int res4 = 0 ;
55138 PyObject * obj0 = 0 ;
55139 PyObject * obj1 = 0 ;
55140 PyObject * obj2 = 0 ;
55141 PyObject * obj3 = 0 ;
55142 char * kwnames[] = {
55143 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
55144 };
55145
55146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55148 if (!SWIG_IsOK(res1)) {
55149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55150 }
55151 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55152 {
55153 arg2 = &temp2;
55154 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55155 }
55156 {
55157 arg3 = &temp3;
55158 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55159 }
55160 if (obj3) {
55161 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55162 if (!SWIG_IsOK(res4)) {
55163 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
55164 }
55165 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
55166 }
55167 {
55168 PyThreadState* __tstate = wxPyBeginAllowThreads();
55169 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
55170 wxPyEndAllowThreads(__tstate);
55171 if (PyErr_Occurred()) SWIG_fail;
55172 }
55173 {
55174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55175 }
55176 return resultobj;
55177 fail:
55178 return NULL;
55179 }
55180
55181
55182 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55183 PyObject *obj;
55184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55185 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
55186 return SWIG_Py_Void();
55187 }
55188
55189 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55190 return SWIG_Python_InitShadowInstance(args);
55191 }
55192
55193 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55194 PyObject *resultobj = 0;
55195 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55196 wxRelationship arg2 ;
55197 wxWindow *arg3 = (wxWindow *) 0 ;
55198 wxEdge arg4 ;
55199 int arg5 = (int) 0 ;
55200 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
55201 void *argp1 = 0 ;
55202 int res1 = 0 ;
55203 int val2 ;
55204 int ecode2 = 0 ;
55205 void *argp3 = 0 ;
55206 int res3 = 0 ;
55207 int val4 ;
55208 int ecode4 = 0 ;
55209 int val5 ;
55210 int ecode5 = 0 ;
55211 int val6 ;
55212 int ecode6 = 0 ;
55213 PyObject * obj0 = 0 ;
55214 PyObject * obj1 = 0 ;
55215 PyObject * obj2 = 0 ;
55216 PyObject * obj3 = 0 ;
55217 PyObject * obj4 = 0 ;
55218 PyObject * obj5 = 0 ;
55219 char * kwnames[] = {
55220 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
55221 };
55222
55223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55225 if (!SWIG_IsOK(res1)) {
55226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55227 }
55228 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55229 ecode2 = SWIG_AsVal_int(obj1, &val2);
55230 if (!SWIG_IsOK(ecode2)) {
55231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
55232 }
55233 arg2 = static_cast< wxRelationship >(val2);
55234 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55235 if (!SWIG_IsOK(res3)) {
55236 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
55237 }
55238 arg3 = reinterpret_cast< wxWindow * >(argp3);
55239 ecode4 = SWIG_AsVal_int(obj3, &val4);
55240 if (!SWIG_IsOK(ecode4)) {
55241 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
55242 }
55243 arg4 = static_cast< wxEdge >(val4);
55244 if (obj4) {
55245 ecode5 = SWIG_AsVal_int(obj4, &val5);
55246 if (!SWIG_IsOK(ecode5)) {
55247 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
55248 }
55249 arg5 = static_cast< int >(val5);
55250 }
55251 if (obj5) {
55252 ecode6 = SWIG_AsVal_int(obj5, &val6);
55253 if (!SWIG_IsOK(ecode6)) {
55254 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
55255 }
55256 arg6 = static_cast< int >(val6);
55257 }
55258 {
55259 PyThreadState* __tstate = wxPyBeginAllowThreads();
55260 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
55261 wxPyEndAllowThreads(__tstate);
55262 if (PyErr_Occurred()) SWIG_fail;
55263 }
55264 resultobj = SWIG_Py_Void();
55265 return resultobj;
55266 fail:
55267 return NULL;
55268 }
55269
55270
55271 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55272 PyObject *resultobj = 0;
55273 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55274 wxWindow *arg2 = (wxWindow *) 0 ;
55275 int arg3 = (int) 0 ;
55276 void *argp1 = 0 ;
55277 int res1 = 0 ;
55278 void *argp2 = 0 ;
55279 int res2 = 0 ;
55280 int val3 ;
55281 int ecode3 = 0 ;
55282 PyObject * obj0 = 0 ;
55283 PyObject * obj1 = 0 ;
55284 PyObject * obj2 = 0 ;
55285 char * kwnames[] = {
55286 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55287 };
55288
55289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55291 if (!SWIG_IsOK(res1)) {
55292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55293 }
55294 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55295 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55296 if (!SWIG_IsOK(res2)) {
55297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55298 }
55299 arg2 = reinterpret_cast< wxWindow * >(argp2);
55300 if (obj2) {
55301 ecode3 = SWIG_AsVal_int(obj2, &val3);
55302 if (!SWIG_IsOK(ecode3)) {
55303 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
55304 }
55305 arg3 = static_cast< int >(val3);
55306 }
55307 {
55308 PyThreadState* __tstate = wxPyBeginAllowThreads();
55309 (arg1)->LeftOf(arg2,arg3);
55310 wxPyEndAllowThreads(__tstate);
55311 if (PyErr_Occurred()) SWIG_fail;
55312 }
55313 resultobj = SWIG_Py_Void();
55314 return resultobj;
55315 fail:
55316 return NULL;
55317 }
55318
55319
55320 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55321 PyObject *resultobj = 0;
55322 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55323 wxWindow *arg2 = (wxWindow *) 0 ;
55324 int arg3 = (int) 0 ;
55325 void *argp1 = 0 ;
55326 int res1 = 0 ;
55327 void *argp2 = 0 ;
55328 int res2 = 0 ;
55329 int val3 ;
55330 int ecode3 = 0 ;
55331 PyObject * obj0 = 0 ;
55332 PyObject * obj1 = 0 ;
55333 PyObject * obj2 = 0 ;
55334 char * kwnames[] = {
55335 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55336 };
55337
55338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55340 if (!SWIG_IsOK(res1)) {
55341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55342 }
55343 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55344 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55345 if (!SWIG_IsOK(res2)) {
55346 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55347 }
55348 arg2 = reinterpret_cast< wxWindow * >(argp2);
55349 if (obj2) {
55350 ecode3 = SWIG_AsVal_int(obj2, &val3);
55351 if (!SWIG_IsOK(ecode3)) {
55352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
55353 }
55354 arg3 = static_cast< int >(val3);
55355 }
55356 {
55357 PyThreadState* __tstate = wxPyBeginAllowThreads();
55358 (arg1)->RightOf(arg2,arg3);
55359 wxPyEndAllowThreads(__tstate);
55360 if (PyErr_Occurred()) SWIG_fail;
55361 }
55362 resultobj = SWIG_Py_Void();
55363 return resultobj;
55364 fail:
55365 return NULL;
55366 }
55367
55368
55369 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55370 PyObject *resultobj = 0;
55371 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55372 wxWindow *arg2 = (wxWindow *) 0 ;
55373 int arg3 = (int) 0 ;
55374 void *argp1 = 0 ;
55375 int res1 = 0 ;
55376 void *argp2 = 0 ;
55377 int res2 = 0 ;
55378 int val3 ;
55379 int ecode3 = 0 ;
55380 PyObject * obj0 = 0 ;
55381 PyObject * obj1 = 0 ;
55382 PyObject * obj2 = 0 ;
55383 char * kwnames[] = {
55384 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55385 };
55386
55387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55389 if (!SWIG_IsOK(res1)) {
55390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55391 }
55392 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55393 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55394 if (!SWIG_IsOK(res2)) {
55395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
55396 }
55397 arg2 = reinterpret_cast< wxWindow * >(argp2);
55398 if (obj2) {
55399 ecode3 = SWIG_AsVal_int(obj2, &val3);
55400 if (!SWIG_IsOK(ecode3)) {
55401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
55402 }
55403 arg3 = static_cast< int >(val3);
55404 }
55405 {
55406 PyThreadState* __tstate = wxPyBeginAllowThreads();
55407 (arg1)->Above(arg2,arg3);
55408 wxPyEndAllowThreads(__tstate);
55409 if (PyErr_Occurred()) SWIG_fail;
55410 }
55411 resultobj = SWIG_Py_Void();
55412 return resultobj;
55413 fail:
55414 return NULL;
55415 }
55416
55417
55418 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55419 PyObject *resultobj = 0;
55420 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55421 wxWindow *arg2 = (wxWindow *) 0 ;
55422 int arg3 = (int) 0 ;
55423 void *argp1 = 0 ;
55424 int res1 = 0 ;
55425 void *argp2 = 0 ;
55426 int res2 = 0 ;
55427 int val3 ;
55428 int ecode3 = 0 ;
55429 PyObject * obj0 = 0 ;
55430 PyObject * obj1 = 0 ;
55431 PyObject * obj2 = 0 ;
55432 char * kwnames[] = {
55433 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55434 };
55435
55436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55438 if (!SWIG_IsOK(res1)) {
55439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55440 }
55441 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55442 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55443 if (!SWIG_IsOK(res2)) {
55444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
55445 }
55446 arg2 = reinterpret_cast< wxWindow * >(argp2);
55447 if (obj2) {
55448 ecode3 = SWIG_AsVal_int(obj2, &val3);
55449 if (!SWIG_IsOK(ecode3)) {
55450 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
55451 }
55452 arg3 = static_cast< int >(val3);
55453 }
55454 {
55455 PyThreadState* __tstate = wxPyBeginAllowThreads();
55456 (arg1)->Below(arg2,arg3);
55457 wxPyEndAllowThreads(__tstate);
55458 if (PyErr_Occurred()) SWIG_fail;
55459 }
55460 resultobj = SWIG_Py_Void();
55461 return resultobj;
55462 fail:
55463 return NULL;
55464 }
55465
55466
55467 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55468 PyObject *resultobj = 0;
55469 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55470 wxWindow *arg2 = (wxWindow *) 0 ;
55471 wxEdge arg3 ;
55472 int arg4 = (int) 0 ;
55473 void *argp1 = 0 ;
55474 int res1 = 0 ;
55475 void *argp2 = 0 ;
55476 int res2 = 0 ;
55477 int val3 ;
55478 int ecode3 = 0 ;
55479 int val4 ;
55480 int ecode4 = 0 ;
55481 PyObject * obj0 = 0 ;
55482 PyObject * obj1 = 0 ;
55483 PyObject * obj2 = 0 ;
55484 PyObject * obj3 = 0 ;
55485 char * kwnames[] = {
55486 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
55487 };
55488
55489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55491 if (!SWIG_IsOK(res1)) {
55492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55493 }
55494 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55495 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55496 if (!SWIG_IsOK(res2)) {
55497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
55498 }
55499 arg2 = reinterpret_cast< wxWindow * >(argp2);
55500 ecode3 = SWIG_AsVal_int(obj2, &val3);
55501 if (!SWIG_IsOK(ecode3)) {
55502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
55503 }
55504 arg3 = static_cast< wxEdge >(val3);
55505 if (obj3) {
55506 ecode4 = SWIG_AsVal_int(obj3, &val4);
55507 if (!SWIG_IsOK(ecode4)) {
55508 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
55509 }
55510 arg4 = static_cast< int >(val4);
55511 }
55512 {
55513 PyThreadState* __tstate = wxPyBeginAllowThreads();
55514 (arg1)->SameAs(arg2,arg3,arg4);
55515 wxPyEndAllowThreads(__tstate);
55516 if (PyErr_Occurred()) SWIG_fail;
55517 }
55518 resultobj = SWIG_Py_Void();
55519 return resultobj;
55520 fail:
55521 return NULL;
55522 }
55523
55524
55525 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55526 PyObject *resultobj = 0;
55527 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55528 wxWindow *arg2 = (wxWindow *) 0 ;
55529 wxEdge arg3 ;
55530 int arg4 ;
55531 void *argp1 = 0 ;
55532 int res1 = 0 ;
55533 void *argp2 = 0 ;
55534 int res2 = 0 ;
55535 int val3 ;
55536 int ecode3 = 0 ;
55537 int val4 ;
55538 int ecode4 = 0 ;
55539 PyObject * obj0 = 0 ;
55540 PyObject * obj1 = 0 ;
55541 PyObject * obj2 = 0 ;
55542 PyObject * obj3 = 0 ;
55543 char * kwnames[] = {
55544 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
55545 };
55546
55547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55549 if (!SWIG_IsOK(res1)) {
55550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55551 }
55552 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55553 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55554 if (!SWIG_IsOK(res2)) {
55555 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55556 }
55557 arg2 = reinterpret_cast< wxWindow * >(argp2);
55558 ecode3 = SWIG_AsVal_int(obj2, &val3);
55559 if (!SWIG_IsOK(ecode3)) {
55560 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
55561 }
55562 arg3 = static_cast< wxEdge >(val3);
55563 ecode4 = SWIG_AsVal_int(obj3, &val4);
55564 if (!SWIG_IsOK(ecode4)) {
55565 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
55566 }
55567 arg4 = static_cast< int >(val4);
55568 {
55569 PyThreadState* __tstate = wxPyBeginAllowThreads();
55570 (arg1)->PercentOf(arg2,arg3,arg4);
55571 wxPyEndAllowThreads(__tstate);
55572 if (PyErr_Occurred()) SWIG_fail;
55573 }
55574 resultobj = SWIG_Py_Void();
55575 return resultobj;
55576 fail:
55577 return NULL;
55578 }
55579
55580
55581 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55582 PyObject *resultobj = 0;
55583 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55584 int arg2 ;
55585 void *argp1 = 0 ;
55586 int res1 = 0 ;
55587 int val2 ;
55588 int ecode2 = 0 ;
55589 PyObject * obj0 = 0 ;
55590 PyObject * obj1 = 0 ;
55591 char * kwnames[] = {
55592 (char *) "self",(char *) "val", NULL
55593 };
55594
55595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
55596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55597 if (!SWIG_IsOK(res1)) {
55598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55599 }
55600 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55601 ecode2 = SWIG_AsVal_int(obj1, &val2);
55602 if (!SWIG_IsOK(ecode2)) {
55603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
55604 }
55605 arg2 = static_cast< int >(val2);
55606 {
55607 PyThreadState* __tstate = wxPyBeginAllowThreads();
55608 (arg1)->Absolute(arg2);
55609 wxPyEndAllowThreads(__tstate);
55610 if (PyErr_Occurred()) SWIG_fail;
55611 }
55612 resultobj = SWIG_Py_Void();
55613 return resultobj;
55614 fail:
55615 return NULL;
55616 }
55617
55618
55619 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55620 PyObject *resultobj = 0;
55621 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55622 void *argp1 = 0 ;
55623 int res1 = 0 ;
55624 PyObject *swig_obj[1] ;
55625
55626 if (!args) SWIG_fail;
55627 swig_obj[0] = args;
55628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55629 if (!SWIG_IsOK(res1)) {
55630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55631 }
55632 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55633 {
55634 PyThreadState* __tstate = wxPyBeginAllowThreads();
55635 (arg1)->Unconstrained();
55636 wxPyEndAllowThreads(__tstate);
55637 if (PyErr_Occurred()) SWIG_fail;
55638 }
55639 resultobj = SWIG_Py_Void();
55640 return resultobj;
55641 fail:
55642 return NULL;
55643 }
55644
55645
55646 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55647 PyObject *resultobj = 0;
55648 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55649 void *argp1 = 0 ;
55650 int res1 = 0 ;
55651 PyObject *swig_obj[1] ;
55652
55653 if (!args) SWIG_fail;
55654 swig_obj[0] = args;
55655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55656 if (!SWIG_IsOK(res1)) {
55657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55658 }
55659 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55660 {
55661 PyThreadState* __tstate = wxPyBeginAllowThreads();
55662 (arg1)->AsIs();
55663 wxPyEndAllowThreads(__tstate);
55664 if (PyErr_Occurred()) SWIG_fail;
55665 }
55666 resultobj = SWIG_Py_Void();
55667 return resultobj;
55668 fail:
55669 return NULL;
55670 }
55671
55672
55673 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55674 PyObject *resultobj = 0;
55675 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55676 wxWindow *result = 0 ;
55677 void *argp1 = 0 ;
55678 int res1 = 0 ;
55679 PyObject *swig_obj[1] ;
55680
55681 if (!args) SWIG_fail;
55682 swig_obj[0] = args;
55683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55684 if (!SWIG_IsOK(res1)) {
55685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55686 }
55687 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55688 {
55689 PyThreadState* __tstate = wxPyBeginAllowThreads();
55690 result = (wxWindow *)(arg1)->GetOtherWindow();
55691 wxPyEndAllowThreads(__tstate);
55692 if (PyErr_Occurred()) SWIG_fail;
55693 }
55694 {
55695 resultobj = wxPyMake_wxObject(result, 0);
55696 }
55697 return resultobj;
55698 fail:
55699 return NULL;
55700 }
55701
55702
55703 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55704 PyObject *resultobj = 0;
55705 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55706 wxEdge result;
55707 void *argp1 = 0 ;
55708 int res1 = 0 ;
55709 PyObject *swig_obj[1] ;
55710
55711 if (!args) SWIG_fail;
55712 swig_obj[0] = args;
55713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55714 if (!SWIG_IsOK(res1)) {
55715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55716 }
55717 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55718 {
55719 PyThreadState* __tstate = wxPyBeginAllowThreads();
55720 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
55721 wxPyEndAllowThreads(__tstate);
55722 if (PyErr_Occurred()) SWIG_fail;
55723 }
55724 resultobj = SWIG_From_int(static_cast< int >(result));
55725 return resultobj;
55726 fail:
55727 return NULL;
55728 }
55729
55730
55731 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55732 PyObject *resultobj = 0;
55733 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55734 wxEdge arg2 ;
55735 void *argp1 = 0 ;
55736 int res1 = 0 ;
55737 int val2 ;
55738 int ecode2 = 0 ;
55739 PyObject * obj0 = 0 ;
55740 PyObject * obj1 = 0 ;
55741 char * kwnames[] = {
55742 (char *) "self",(char *) "which", NULL
55743 };
55744
55745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
55746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55747 if (!SWIG_IsOK(res1)) {
55748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55749 }
55750 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55751 ecode2 = SWIG_AsVal_int(obj1, &val2);
55752 if (!SWIG_IsOK(ecode2)) {
55753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55754 }
55755 arg2 = static_cast< wxEdge >(val2);
55756 {
55757 PyThreadState* __tstate = wxPyBeginAllowThreads();
55758 (arg1)->SetEdge(arg2);
55759 wxPyEndAllowThreads(__tstate);
55760 if (PyErr_Occurred()) SWIG_fail;
55761 }
55762 resultobj = SWIG_Py_Void();
55763 return resultobj;
55764 fail:
55765 return NULL;
55766 }
55767
55768
55769 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55770 PyObject *resultobj = 0;
55771 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55772 int arg2 ;
55773 void *argp1 = 0 ;
55774 int res1 = 0 ;
55775 int val2 ;
55776 int ecode2 = 0 ;
55777 PyObject * obj0 = 0 ;
55778 PyObject * obj1 = 0 ;
55779 char * kwnames[] = {
55780 (char *) "self",(char *) "v", NULL
55781 };
55782
55783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
55784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55785 if (!SWIG_IsOK(res1)) {
55786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55787 }
55788 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55789 ecode2 = SWIG_AsVal_int(obj1, &val2);
55790 if (!SWIG_IsOK(ecode2)) {
55791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
55792 }
55793 arg2 = static_cast< int >(val2);
55794 {
55795 PyThreadState* __tstate = wxPyBeginAllowThreads();
55796 (arg1)->SetValue(arg2);
55797 wxPyEndAllowThreads(__tstate);
55798 if (PyErr_Occurred()) SWIG_fail;
55799 }
55800 resultobj = SWIG_Py_Void();
55801 return resultobj;
55802 fail:
55803 return NULL;
55804 }
55805
55806
55807 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55808 PyObject *resultobj = 0;
55809 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55810 int result;
55811 void *argp1 = 0 ;
55812 int res1 = 0 ;
55813 PyObject *swig_obj[1] ;
55814
55815 if (!args) SWIG_fail;
55816 swig_obj[0] = args;
55817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55818 if (!SWIG_IsOK(res1)) {
55819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55820 }
55821 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55822 {
55823 PyThreadState* __tstate = wxPyBeginAllowThreads();
55824 result = (int)(arg1)->GetMargin();
55825 wxPyEndAllowThreads(__tstate);
55826 if (PyErr_Occurred()) SWIG_fail;
55827 }
55828 resultobj = SWIG_From_int(static_cast< int >(result));
55829 return resultobj;
55830 fail:
55831 return NULL;
55832 }
55833
55834
55835 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55836 PyObject *resultobj = 0;
55837 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55838 int arg2 ;
55839 void *argp1 = 0 ;
55840 int res1 = 0 ;
55841 int val2 ;
55842 int ecode2 = 0 ;
55843 PyObject * obj0 = 0 ;
55844 PyObject * obj1 = 0 ;
55845 char * kwnames[] = {
55846 (char *) "self",(char *) "m", NULL
55847 };
55848
55849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
55850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55851 if (!SWIG_IsOK(res1)) {
55852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55853 }
55854 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55855 ecode2 = SWIG_AsVal_int(obj1, &val2);
55856 if (!SWIG_IsOK(ecode2)) {
55857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
55858 }
55859 arg2 = static_cast< int >(val2);
55860 {
55861 PyThreadState* __tstate = wxPyBeginAllowThreads();
55862 (arg1)->SetMargin(arg2);
55863 wxPyEndAllowThreads(__tstate);
55864 if (PyErr_Occurred()) SWIG_fail;
55865 }
55866 resultobj = SWIG_Py_Void();
55867 return resultobj;
55868 fail:
55869 return NULL;
55870 }
55871
55872
55873 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55874 PyObject *resultobj = 0;
55875 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55876 int result;
55877 void *argp1 = 0 ;
55878 int res1 = 0 ;
55879 PyObject *swig_obj[1] ;
55880
55881 if (!args) SWIG_fail;
55882 swig_obj[0] = args;
55883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55884 if (!SWIG_IsOK(res1)) {
55885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55886 }
55887 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55888 {
55889 PyThreadState* __tstate = wxPyBeginAllowThreads();
55890 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
55891 wxPyEndAllowThreads(__tstate);
55892 if (PyErr_Occurred()) SWIG_fail;
55893 }
55894 resultobj = SWIG_From_int(static_cast< int >(result));
55895 return resultobj;
55896 fail:
55897 return NULL;
55898 }
55899
55900
55901 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55902 PyObject *resultobj = 0;
55903 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55904 int result;
55905 void *argp1 = 0 ;
55906 int res1 = 0 ;
55907 PyObject *swig_obj[1] ;
55908
55909 if (!args) SWIG_fail;
55910 swig_obj[0] = args;
55911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55912 if (!SWIG_IsOK(res1)) {
55913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55914 }
55915 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55916 {
55917 PyThreadState* __tstate = wxPyBeginAllowThreads();
55918 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
55919 wxPyEndAllowThreads(__tstate);
55920 if (PyErr_Occurred()) SWIG_fail;
55921 }
55922 resultobj = SWIG_From_int(static_cast< int >(result));
55923 return resultobj;
55924 fail:
55925 return NULL;
55926 }
55927
55928
55929 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55930 PyObject *resultobj = 0;
55931 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55932 int result;
55933 void *argp1 = 0 ;
55934 int res1 = 0 ;
55935 PyObject *swig_obj[1] ;
55936
55937 if (!args) SWIG_fail;
55938 swig_obj[0] = args;
55939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55940 if (!SWIG_IsOK(res1)) {
55941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55942 }
55943 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55944 {
55945 PyThreadState* __tstate = wxPyBeginAllowThreads();
55946 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
55947 wxPyEndAllowThreads(__tstate);
55948 if (PyErr_Occurred()) SWIG_fail;
55949 }
55950 resultobj = SWIG_From_int(static_cast< int >(result));
55951 return resultobj;
55952 fail:
55953 return NULL;
55954 }
55955
55956
55957 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55958 PyObject *resultobj = 0;
55959 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55960 bool result;
55961 void *argp1 = 0 ;
55962 int res1 = 0 ;
55963 PyObject *swig_obj[1] ;
55964
55965 if (!args) SWIG_fail;
55966 swig_obj[0] = args;
55967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55968 if (!SWIG_IsOK(res1)) {
55969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55970 }
55971 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55972 {
55973 PyThreadState* __tstate = wxPyBeginAllowThreads();
55974 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
55975 wxPyEndAllowThreads(__tstate);
55976 if (PyErr_Occurred()) SWIG_fail;
55977 }
55978 {
55979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55980 }
55981 return resultobj;
55982 fail:
55983 return NULL;
55984 }
55985
55986
55987 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55988 PyObject *resultobj = 0;
55989 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55990 bool arg2 ;
55991 void *argp1 = 0 ;
55992 int res1 = 0 ;
55993 bool val2 ;
55994 int ecode2 = 0 ;
55995 PyObject * obj0 = 0 ;
55996 PyObject * obj1 = 0 ;
55997 char * kwnames[] = {
55998 (char *) "self",(char *) "d", NULL
55999 };
56000
56001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
56002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56003 if (!SWIG_IsOK(res1)) {
56004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56005 }
56006 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56007 ecode2 = SWIG_AsVal_bool(obj1, &val2);
56008 if (!SWIG_IsOK(ecode2)) {
56009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
56010 }
56011 arg2 = static_cast< bool >(val2);
56012 {
56013 PyThreadState* __tstate = wxPyBeginAllowThreads();
56014 (arg1)->SetDone(arg2);
56015 wxPyEndAllowThreads(__tstate);
56016 if (PyErr_Occurred()) SWIG_fail;
56017 }
56018 resultobj = SWIG_Py_Void();
56019 return resultobj;
56020 fail:
56021 return NULL;
56022 }
56023
56024
56025 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56026 PyObject *resultobj = 0;
56027 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56028 wxRelationship result;
56029 void *argp1 = 0 ;
56030 int res1 = 0 ;
56031 PyObject *swig_obj[1] ;
56032
56033 if (!args) SWIG_fail;
56034 swig_obj[0] = args;
56035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56036 if (!SWIG_IsOK(res1)) {
56037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56038 }
56039 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56040 {
56041 PyThreadState* __tstate = wxPyBeginAllowThreads();
56042 result = (wxRelationship)(arg1)->GetRelationship();
56043 wxPyEndAllowThreads(__tstate);
56044 if (PyErr_Occurred()) SWIG_fail;
56045 }
56046 resultobj = SWIG_From_int(static_cast< int >(result));
56047 return resultobj;
56048 fail:
56049 return NULL;
56050 }
56051
56052
56053 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56054 PyObject *resultobj = 0;
56055 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56056 wxRelationship arg2 ;
56057 void *argp1 = 0 ;
56058 int res1 = 0 ;
56059 int val2 ;
56060 int ecode2 = 0 ;
56061 PyObject * obj0 = 0 ;
56062 PyObject * obj1 = 0 ;
56063 char * kwnames[] = {
56064 (char *) "self",(char *) "r", NULL
56065 };
56066
56067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
56068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56069 if (!SWIG_IsOK(res1)) {
56070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56071 }
56072 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56073 ecode2 = SWIG_AsVal_int(obj1, &val2);
56074 if (!SWIG_IsOK(ecode2)) {
56075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
56076 }
56077 arg2 = static_cast< wxRelationship >(val2);
56078 {
56079 PyThreadState* __tstate = wxPyBeginAllowThreads();
56080 (arg1)->SetRelationship(arg2);
56081 wxPyEndAllowThreads(__tstate);
56082 if (PyErr_Occurred()) SWIG_fail;
56083 }
56084 resultobj = SWIG_Py_Void();
56085 return resultobj;
56086 fail:
56087 return NULL;
56088 }
56089
56090
56091 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56092 PyObject *resultobj = 0;
56093 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56094 wxWindow *arg2 = (wxWindow *) 0 ;
56095 bool result;
56096 void *argp1 = 0 ;
56097 int res1 = 0 ;
56098 void *argp2 = 0 ;
56099 int res2 = 0 ;
56100 PyObject * obj0 = 0 ;
56101 PyObject * obj1 = 0 ;
56102 char * kwnames[] = {
56103 (char *) "self",(char *) "otherW", NULL
56104 };
56105
56106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
56107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56108 if (!SWIG_IsOK(res1)) {
56109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56110 }
56111 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56112 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56113 if (!SWIG_IsOK(res2)) {
56114 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
56115 }
56116 arg2 = reinterpret_cast< wxWindow * >(argp2);
56117 {
56118 PyThreadState* __tstate = wxPyBeginAllowThreads();
56119 result = (bool)(arg1)->ResetIfWin(arg2);
56120 wxPyEndAllowThreads(__tstate);
56121 if (PyErr_Occurred()) SWIG_fail;
56122 }
56123 {
56124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56125 }
56126 return resultobj;
56127 fail:
56128 return NULL;
56129 }
56130
56131
56132 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56133 PyObject *resultobj = 0;
56134 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56135 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
56136 wxWindow *arg3 = (wxWindow *) 0 ;
56137 bool result;
56138 void *argp1 = 0 ;
56139 int res1 = 0 ;
56140 void *argp2 = 0 ;
56141 int res2 = 0 ;
56142 void *argp3 = 0 ;
56143 int res3 = 0 ;
56144 PyObject * obj0 = 0 ;
56145 PyObject * obj1 = 0 ;
56146 PyObject * obj2 = 0 ;
56147 char * kwnames[] = {
56148 (char *) "self",(char *) "constraints",(char *) "win", NULL
56149 };
56150
56151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56153 if (!SWIG_IsOK(res1)) {
56154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56155 }
56156 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56157 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56158 if (!SWIG_IsOK(res2)) {
56159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
56160 }
56161 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
56162 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56163 if (!SWIG_IsOK(res3)) {
56164 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
56165 }
56166 arg3 = reinterpret_cast< wxWindow * >(argp3);
56167 {
56168 PyThreadState* __tstate = wxPyBeginAllowThreads();
56169 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
56170 wxPyEndAllowThreads(__tstate);
56171 if (PyErr_Occurred()) SWIG_fail;
56172 }
56173 {
56174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56175 }
56176 return resultobj;
56177 fail:
56178 return NULL;
56179 }
56180
56181
56182 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56183 PyObject *resultobj = 0;
56184 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56185 wxEdge arg2 ;
56186 wxWindow *arg3 = (wxWindow *) 0 ;
56187 wxWindow *arg4 = (wxWindow *) 0 ;
56188 int result;
56189 void *argp1 = 0 ;
56190 int res1 = 0 ;
56191 int val2 ;
56192 int ecode2 = 0 ;
56193 void *argp3 = 0 ;
56194 int res3 = 0 ;
56195 void *argp4 = 0 ;
56196 int res4 = 0 ;
56197 PyObject * obj0 = 0 ;
56198 PyObject * obj1 = 0 ;
56199 PyObject * obj2 = 0 ;
56200 PyObject * obj3 = 0 ;
56201 char * kwnames[] = {
56202 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
56203 };
56204
56205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56207 if (!SWIG_IsOK(res1)) {
56208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56209 }
56210 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56211 ecode2 = SWIG_AsVal_int(obj1, &val2);
56212 if (!SWIG_IsOK(ecode2)) {
56213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
56214 }
56215 arg2 = static_cast< wxEdge >(val2);
56216 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56217 if (!SWIG_IsOK(res3)) {
56218 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
56219 }
56220 arg3 = reinterpret_cast< wxWindow * >(argp3);
56221 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
56222 if (!SWIG_IsOK(res4)) {
56223 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
56224 }
56225 arg4 = reinterpret_cast< wxWindow * >(argp4);
56226 {
56227 PyThreadState* __tstate = wxPyBeginAllowThreads();
56228 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
56229 wxPyEndAllowThreads(__tstate);
56230 if (PyErr_Occurred()) SWIG_fail;
56231 }
56232 resultobj = SWIG_From_int(static_cast< int >(result));
56233 return resultobj;
56234 fail:
56235 return NULL;
56236 }
56237
56238
56239 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56240 PyObject *obj;
56241 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56242 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
56243 return SWIG_Py_Void();
56244 }
56245
56246 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56247 PyObject *resultobj = 0;
56248 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56249 wxIndividualLayoutConstraint *result = 0 ;
56250 void *argp1 = 0 ;
56251 int res1 = 0 ;
56252 PyObject *swig_obj[1] ;
56253
56254 if (!args) SWIG_fail;
56255 swig_obj[0] = args;
56256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56257 if (!SWIG_IsOK(res1)) {
56258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56259 }
56260 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56261 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
56262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56263 return resultobj;
56264 fail:
56265 return NULL;
56266 }
56267
56268
56269 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56270 PyObject *resultobj = 0;
56271 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56272 wxIndividualLayoutConstraint *result = 0 ;
56273 void *argp1 = 0 ;
56274 int res1 = 0 ;
56275 PyObject *swig_obj[1] ;
56276
56277 if (!args) SWIG_fail;
56278 swig_obj[0] = args;
56279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56280 if (!SWIG_IsOK(res1)) {
56281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56282 }
56283 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56284 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
56285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56286 return resultobj;
56287 fail:
56288 return NULL;
56289 }
56290
56291
56292 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56293 PyObject *resultobj = 0;
56294 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56295 wxIndividualLayoutConstraint *result = 0 ;
56296 void *argp1 = 0 ;
56297 int res1 = 0 ;
56298 PyObject *swig_obj[1] ;
56299
56300 if (!args) SWIG_fail;
56301 swig_obj[0] = args;
56302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56303 if (!SWIG_IsOK(res1)) {
56304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56305 }
56306 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56307 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
56308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56309 return resultobj;
56310 fail:
56311 return NULL;
56312 }
56313
56314
56315 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56316 PyObject *resultobj = 0;
56317 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56318 wxIndividualLayoutConstraint *result = 0 ;
56319 void *argp1 = 0 ;
56320 int res1 = 0 ;
56321 PyObject *swig_obj[1] ;
56322
56323 if (!args) SWIG_fail;
56324 swig_obj[0] = args;
56325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56326 if (!SWIG_IsOK(res1)) {
56327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56328 }
56329 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56330 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
56331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56332 return resultobj;
56333 fail:
56334 return NULL;
56335 }
56336
56337
56338 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56339 PyObject *resultobj = 0;
56340 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56341 wxIndividualLayoutConstraint *result = 0 ;
56342 void *argp1 = 0 ;
56343 int res1 = 0 ;
56344 PyObject *swig_obj[1] ;
56345
56346 if (!args) SWIG_fail;
56347 swig_obj[0] = args;
56348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56349 if (!SWIG_IsOK(res1)) {
56350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56351 }
56352 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56353 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
56354 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56355 return resultobj;
56356 fail:
56357 return NULL;
56358 }
56359
56360
56361 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56362 PyObject *resultobj = 0;
56363 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56364 wxIndividualLayoutConstraint *result = 0 ;
56365 void *argp1 = 0 ;
56366 int res1 = 0 ;
56367 PyObject *swig_obj[1] ;
56368
56369 if (!args) SWIG_fail;
56370 swig_obj[0] = args;
56371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56372 if (!SWIG_IsOK(res1)) {
56373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56374 }
56375 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56376 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
56377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56378 return resultobj;
56379 fail:
56380 return NULL;
56381 }
56382
56383
56384 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56385 PyObject *resultobj = 0;
56386 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56387 wxIndividualLayoutConstraint *result = 0 ;
56388 void *argp1 = 0 ;
56389 int res1 = 0 ;
56390 PyObject *swig_obj[1] ;
56391
56392 if (!args) SWIG_fail;
56393 swig_obj[0] = args;
56394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56395 if (!SWIG_IsOK(res1)) {
56396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56397 }
56398 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56399 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
56400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56401 return resultobj;
56402 fail:
56403 return NULL;
56404 }
56405
56406
56407 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56408 PyObject *resultobj = 0;
56409 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56410 wxIndividualLayoutConstraint *result = 0 ;
56411 void *argp1 = 0 ;
56412 int res1 = 0 ;
56413 PyObject *swig_obj[1] ;
56414
56415 if (!args) SWIG_fail;
56416 swig_obj[0] = args;
56417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56418 if (!SWIG_IsOK(res1)) {
56419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56420 }
56421 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56422 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
56423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56424 return resultobj;
56425 fail:
56426 return NULL;
56427 }
56428
56429
56430 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56431 PyObject *resultobj = 0;
56432 wxLayoutConstraints *result = 0 ;
56433
56434 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
56435 {
56436 PyThreadState* __tstate = wxPyBeginAllowThreads();
56437 result = (wxLayoutConstraints *)new wxLayoutConstraints();
56438 wxPyEndAllowThreads(__tstate);
56439 if (PyErr_Occurred()) SWIG_fail;
56440 }
56441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
56442 return resultobj;
56443 fail:
56444 return NULL;
56445 }
56446
56447
56448 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56449 PyObject *resultobj = 0;
56450 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56451 void *argp1 = 0 ;
56452 int res1 = 0 ;
56453 PyObject *swig_obj[1] ;
56454
56455 if (!args) SWIG_fail;
56456 swig_obj[0] = args;
56457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
56458 if (!SWIG_IsOK(res1)) {
56459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56460 }
56461 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56462 {
56463 PyThreadState* __tstate = wxPyBeginAllowThreads();
56464 delete arg1;
56465
56466 wxPyEndAllowThreads(__tstate);
56467 if (PyErr_Occurred()) SWIG_fail;
56468 }
56469 resultobj = SWIG_Py_Void();
56470 return resultobj;
56471 fail:
56472 return NULL;
56473 }
56474
56475
56476 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56477 PyObject *resultobj = 0;
56478 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56479 wxWindow *arg2 = (wxWindow *) 0 ;
56480 int *arg3 = (int *) 0 ;
56481 bool result;
56482 void *argp1 = 0 ;
56483 int res1 = 0 ;
56484 void *argp2 = 0 ;
56485 int res2 = 0 ;
56486 int temp3 ;
56487 int res3 = SWIG_TMPOBJ ;
56488 PyObject * obj0 = 0 ;
56489 PyObject * obj1 = 0 ;
56490 char * kwnames[] = {
56491 (char *) "self",(char *) "win", NULL
56492 };
56493
56494 arg3 = &temp3;
56495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
56496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56497 if (!SWIG_IsOK(res1)) {
56498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56499 }
56500 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56501 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56502 if (!SWIG_IsOK(res2)) {
56503 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
56504 }
56505 arg2 = reinterpret_cast< wxWindow * >(argp2);
56506 {
56507 PyThreadState* __tstate = wxPyBeginAllowThreads();
56508 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
56509 wxPyEndAllowThreads(__tstate);
56510 if (PyErr_Occurred()) SWIG_fail;
56511 }
56512 {
56513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56514 }
56515 if (SWIG_IsTmpObj(res3)) {
56516 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
56517 } else {
56518 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
56519 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
56520 }
56521 return resultobj;
56522 fail:
56523 return NULL;
56524 }
56525
56526
56527 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56528 PyObject *resultobj = 0;
56529 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56530 bool result;
56531 void *argp1 = 0 ;
56532 int res1 = 0 ;
56533 PyObject *swig_obj[1] ;
56534
56535 if (!args) SWIG_fail;
56536 swig_obj[0] = args;
56537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56538 if (!SWIG_IsOK(res1)) {
56539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
56540 }
56541 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56542 {
56543 PyThreadState* __tstate = wxPyBeginAllowThreads();
56544 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
56545 wxPyEndAllowThreads(__tstate);
56546 if (PyErr_Occurred()) SWIG_fail;
56547 }
56548 {
56549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56550 }
56551 return resultobj;
56552 fail:
56553 return NULL;
56554 }
56555
56556
56557 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56558 PyObject *obj;
56559 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56560 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
56561 return SWIG_Py_Void();
56562 }
56563
56564 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56565 return SWIG_Python_InitShadowInstance(args);
56566 }
56567
56568 static PyMethodDef SwigMethods[] = {
56569 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
56570 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
56571 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
56572 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
56573 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
56574 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
56575 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
56576 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
56577 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
56578 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56579 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
56580 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56581 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56582 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56583 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56584 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
56585 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
56586 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
56587 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
56588 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56589 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56590 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56591 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56592 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
56593 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
56594 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
56595 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
56596 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
56597 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
56598 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
56599 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
56600 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
56601 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
56602 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
56603 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56604 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
56605 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56606 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56607 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56608 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56609 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56610 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
56611 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
56612 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
56613 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
56614 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
56615 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
56616 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
56617 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
56618 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
56619 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56620 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56621 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56622 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56623 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56624 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56625 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56626 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
56627 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
56628 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
56629 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
56630 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
56631 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
56632 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
56633 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
56634 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
56635 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
56636 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
56637 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
56638 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
56639 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56640 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
56641 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56642 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
56643 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56644 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
56645 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
56646 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
56647 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
56648 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56649 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
56650 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
56651 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
56652 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
56653 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
56654 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56655 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
56656 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
56657 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
56658 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
56659 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56660 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56661 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56662 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56663 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
56664 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
56665 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
56666 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56667 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56668 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56669 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56670 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56671 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56672 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56673 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
56674 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56675 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56676 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56677 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
56678 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
56679 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
56680 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
56681 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
56682 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
56683 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
56684 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
56685 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
56686 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56687 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
56688 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
56689 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
56690 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
56691 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
56692 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
56693 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56694 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
56695 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
56696 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
56697 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
56698 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
56699 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
56700 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
56701 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
56702 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
56703 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56704 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56705 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
56706 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56707 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56708 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
56709 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
56710 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56711 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56712 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
56713 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
56714 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
56715 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
56716 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56717 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
56718 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
56719 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
56720 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
56721 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
56722 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
56723 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
56724 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
56725 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56726 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
56727 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
56728 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56729 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56730 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
56731 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56732 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56733 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
56734 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56735 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
56736 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
56737 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
56738 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56739 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
56740 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56741 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56742 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
56743 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
56744 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56745 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
56746 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56747 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56748 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
56749 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
56750 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
56751 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
56752 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56753 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56754 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
56755 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
56756 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
56757 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56758 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
56759 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
56760 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56761 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
56762 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56763 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56764 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
56765 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
56766 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56767 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56768 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
56769 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
56770 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
56771 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
56772 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
56773 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
56774 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
56775 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
56776 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56777 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
56778 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
56779 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
56780 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
56781 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
56782 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
56783 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
56784 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
56785 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
56786 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
56787 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
56788 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
56789 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
56790 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
56791 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
56792 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
56793 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
56794 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
56795 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
56796 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
56797 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
56798 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
56799 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
56800 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
56801 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
56802 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
56803 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
56804 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
56805 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
56806 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
56807 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
56808 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
56809 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
56810 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
56811 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
56812 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
56813 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
56814 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
56815 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
56816 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56817 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56818 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56819 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56820 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
56821 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
56822 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56823 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
56824 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56825 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
56826 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
56827 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
56828 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
56829 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
56830 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
56831 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
56832 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56833 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56834 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
56835 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56836 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56837 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
56838 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
56839 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
56840 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
56841 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
56842 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
56843 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56844 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56845 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
56846 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
56847 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
56848 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56849 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56850 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56851 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
56852 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
56853 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
56854 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
56855 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56856 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
56857 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
56858 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56859 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56860 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56861 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56862 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
56863 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
56864 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
56865 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
56866 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
56867 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
56868 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
56869 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56870 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56871 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
56872 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
56873 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
56874 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
56875 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
56876 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
56877 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
56878 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
56879 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
56880 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
56881 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56882 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56883 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
56884 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56885 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
56886 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
56887 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
56888 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
56889 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
56890 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
56891 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
56892 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
56893 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
56894 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
56895 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
56896 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
56897 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
56898 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
56899 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
56900 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
56901 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
56902 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
56903 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
56904 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
56905 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
56906 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
56907 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
56908 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
56909 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
56910 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
56911 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
56912 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56913 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
56914 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56915 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
56916 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
56917 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56918 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
56919 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
56920 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
56921 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
56922 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
56923 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
56924 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
56925 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
56926 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56927 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
56928 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
56929 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
56930 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
56931 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56932 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56933 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
56934 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
56935 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
56936 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56937 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
56938 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56939 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
56940 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56941 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
56942 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
56943 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56944 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56945 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56946 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56947 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56948 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
56949 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
56950 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
56951 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
56952 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
56953 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
56954 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56955 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
56956 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
56957 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
56958 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
56959 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
56960 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56961 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
56962 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
56963 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
56964 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56965 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
56966 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
56967 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
56968 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
56969 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
56970 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
56971 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
56972 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
56973 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
56974 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
56975 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
56976 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
56977 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
56978 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56979 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56980 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56981 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56982 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
56983 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
56984 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
56985 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56986 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56987 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56988 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
56989 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
56990 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56991 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56992 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
56993 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
56994 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56995 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
56996 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
56997 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56998 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
56999 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
57000 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
57001 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
57002 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
57003 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
57004 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
57005 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
57006 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
57007 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
57008 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
57009 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
57010 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
57011 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
57012 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
57013 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
57014 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
57015 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
57016 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
57017 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
57018 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
57019 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
57020 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
57021 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
57022 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
57023 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
57024 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
57025 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
57026 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
57027 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
57028 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
57029 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
57030 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
57031 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
57032 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
57033 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
57034 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
57035 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
57036 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
57037 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
57038 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
57039 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57040 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57041 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
57042 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57043 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57044 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57045 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
57046 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
57047 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
57048 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57049 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
57050 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
57051 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
57052 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
57053 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
57054 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
57055 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
57056 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
57057 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
57058 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
57059 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
57060 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57061 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
57062 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
57063 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
57064 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
57065 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
57066 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
57067 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
57068 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
57069 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
57070 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
57071 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
57072 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
57073 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
57074 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
57075 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
57076 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
57077 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57078 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
57079 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57080 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
57081 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
57082 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
57083 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
57084 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
57085 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
57086 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
57087 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
57088 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57089 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
57090 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
57091 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
57092 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57093 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
57094 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
57095 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
57096 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
57097 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
57098 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57099 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
57100 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
57101 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57102 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57103 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
57104 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
57105 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57106 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
57107 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
57108 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57109 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57110 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
57111 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
57112 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57113 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
57114 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
57115 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
57116 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
57117 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
57118 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
57119 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
57120 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
57121 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
57122 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
57123 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
57124 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
57125 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
57126 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
57127 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
57128 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
57129 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
57130 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
57131 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
57132 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
57133 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
57134 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
57135 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
57136 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
57137 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
57138 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
57139 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
57140 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
57141 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
57142 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
57143 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57144 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
57145 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
57146 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
57147 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
57148 { (char *)"MouseEvent_GetWheelAxis", (PyCFunction)_wrap_MouseEvent_GetWheelAxis, METH_O, NULL},
57149 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
57150 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
57151 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
57152 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
57153 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
57154 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
57155 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
57156 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
57157 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
57158 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
57159 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
57160 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
57161 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
57162 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
57163 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
57164 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
57165 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
57166 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
57167 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
57168 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
57169 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
57170 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
57171 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
57172 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
57173 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
57174 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
57175 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
57176 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
57177 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57178 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
57179 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
57180 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57181 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
57182 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
57183 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
57184 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
57185 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57186 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
57187 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
57188 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
57189 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
57190 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
57191 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
57192 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
57193 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
57194 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
57195 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
57196 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
57197 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
57198 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
57199 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
57200 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
57201 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
57202 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
57203 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
57204 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
57205 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
57206 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
57207 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
57208 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
57209 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
57210 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
57211 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
57212 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
57213 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
57214 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
57215 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
57216 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
57217 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
57218 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
57219 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
57220 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
57221 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
57222 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
57223 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
57224 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57225 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
57226 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
57227 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57228 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57229 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
57230 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
57231 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
57232 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
57233 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
57234 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
57235 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57236 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
57237 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
57238 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57239 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57240 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
57241 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
57242 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57243 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
57244 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
57245 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57246 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
57247 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
57248 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57249 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
57250 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
57251 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
57252 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57253 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
57254 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57255 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
57256 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
57257 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57258 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
57259 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
57260 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
57261 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57262 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
57263 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
57264 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
57265 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57266 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
57267 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
57268 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57269 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
57270 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
57271 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
57272 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
57273 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
57274 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57275 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
57276 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
57277 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
57278 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
57279 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
57280 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
57281 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
57282 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
57283 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57284 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
57285 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
57286 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
57287 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
57288 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57289 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
57290 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
57291 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
57292 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57293 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
57294 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
57295 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
57296 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
57297 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
57298 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
57299 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57300 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
57301 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
57302 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
57303 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
57304 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
57305 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
57306 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
57307 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
57308 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57309 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57310 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57311 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57312 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
57313 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
57314 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
57315 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
57316 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57317 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
57318 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
57319 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
57320 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
57321 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
57322 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
57323 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57324 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
57325 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
57326 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
57327 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57328 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
57329 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
57330 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
57331 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
57332 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
57333 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57334 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57335 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
57336 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
57337 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
57338 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57339 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
57340 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
57341 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
57342 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
57343 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
57344 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
57345 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57346 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
57347 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
57348 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
57349 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
57350 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
57351 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
57352 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
57353 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
57354 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
57355 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57356 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
57357 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
57358 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
57359 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57360 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
57361 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
57362 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
57363 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57364 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
57365 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57366 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
57367 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
57368 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
57369 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
57370 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
57371 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57372 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
57373 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
57374 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
57375 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
57376 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57377 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
57378 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
57379 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57380 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
57381 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57382 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
57383 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
57384 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
57385 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57386 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
57387 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57388 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
57389 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
57390 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
57391 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57392 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
57393 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
57394 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
57395 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
57396 { (char *)"new_EventBlocker", (PyCFunction) _wrap_new_EventBlocker, METH_VARARGS | METH_KEYWORDS, NULL},
57397 { (char *)"delete_EventBlocker", (PyCFunction)_wrap_delete_EventBlocker, METH_O, NULL},
57398 { (char *)"EventBlocker_Block", (PyCFunction) _wrap_EventBlocker_Block, METH_VARARGS | METH_KEYWORDS, NULL},
57399 { (char *)"EventBlocker_swigregister", EventBlocker_swigregister, METH_VARARGS, NULL},
57400 { (char *)"EventBlocker_swiginit", EventBlocker_swiginit, METH_VARARGS, NULL},
57401 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
57402 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
57403 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57404 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
57405 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
57406 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
57407 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
57408 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
57409 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
57410 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
57411 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
57412 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
57413 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
57414 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
57415 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
57416 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
57417 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
57418 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
57419 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
57420 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
57421 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
57422 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
57423 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
57424 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57425 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
57426 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
57427 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
57428 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
57429 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
57430 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
57431 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
57432 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
57433 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
57434 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
57435 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
57436 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
57437 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
57438 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
57439 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
57440 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57441 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57442 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57443 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
57444 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
57445 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
57446 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
57447 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
57448 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
57449 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
57450 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
57451 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
57452 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
57453 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
57454 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57455 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
57456 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
57457 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
57458 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
57459 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
57460 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
57461 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
57462 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
57463 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
57464 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
57465 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
57466 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
57467 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
57468 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
57469 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
57470 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
57471 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
57472 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
57473 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
57474 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
57475 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
57476 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57477 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57478 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
57479 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
57480 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
57481 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
57482 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
57483 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
57484 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
57485 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
57486 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57487 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
57488 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
57489 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
57490 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
57491 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
57492 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
57493 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
57494 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
57495 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
57496 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
57497 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
57498 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
57499 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
57500 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
57501 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
57502 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
57503 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
57504 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57505 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
57506 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
57507 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
57508 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
57509 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57510 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
57511 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57512 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
57513 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
57514 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
57515 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57516 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
57517 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
57518 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57519 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57520 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
57521 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57522 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57523 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57524 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
57525 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57526 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57527 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
57528 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
57529 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
57530 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
57531 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
57532 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
57533 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57534 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
57535 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
57536 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
57537 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
57538 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
57539 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
57540 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
57541 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
57542 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
57543 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
57544 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
57545 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
57546 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
57547 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
57548 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
57549 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
57550 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
57551 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
57552 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
57553 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
57554 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
57555 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
57556 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57557 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57558 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57559 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57560 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
57561 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
57562 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57563 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
57564 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
57565 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
57566 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
57567 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
57568 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57569 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57570 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
57571 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
57572 { (char *)"Window_GetWindowBorderSize", (PyCFunction)_wrap_Window_GetWindowBorderSize, METH_O, NULL},
57573 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
57574 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57575 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
57576 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57577 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
57578 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
57579 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
57580 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
57581 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57582 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
57583 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57584 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
57585 { (char *)"Window_ToggleWindowStyle", (PyCFunction) _wrap_Window_ToggleWindowStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57586 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57587 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
57588 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
57589 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57590 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
57591 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
57592 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
57593 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
57594 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
57595 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
57596 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
57597 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57598 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57599 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
57600 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
57601 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
57602 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
57603 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
57604 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
57605 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
57606 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
57607 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57608 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57609 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
57610 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57611 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57612 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57613 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57614 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
57615 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
57616 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
57617 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
57618 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
57619 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
57620 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57621 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
57622 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57623 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57624 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57625 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57626 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
57627 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
57628 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57629 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57630 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
57631 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
57632 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
57633 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
57634 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
57635 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
57636 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
57637 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
57638 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
57639 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
57640 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
57641 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
57642 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
57643 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
57644 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
57645 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
57646 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
57647 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57648 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
57649 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
57650 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57651 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57652 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57653 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57654 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57655 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
57656 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
57657 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
57658 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
57659 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57660 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
57661 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
57662 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57663 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
57664 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57665 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
57666 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
57667 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
57668 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
57669 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
57670 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
57671 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57672 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57673 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
57674 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
57675 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
57676 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
57677 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
57678 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
57679 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
57680 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
57681 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
57682 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57683 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
57684 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
57685 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
57686 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
57687 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57688 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57689 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57690 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57691 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
57692 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
57693 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57694 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
57695 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
57696 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
57697 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
57698 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
57699 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
57700 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
57701 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
57702 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57703 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
57704 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
57705 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
57706 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
57707 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
57708 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
57709 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
57710 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57711 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
57712 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
57713 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
57714 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
57715 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57716 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
57717 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
57718 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57719 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
57720 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
57721 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
57722 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
57723 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
57724 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
57725 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
57726 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57727 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57728 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57729 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
57730 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
57731 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
57732 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
57733 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
57734 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
57735 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
57736 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
57737 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57738 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
57739 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
57740 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
57741 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
57742 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
57743 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57744 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
57745 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
57746 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
57747 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57748 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
57749 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57750 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57751 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57752 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57753 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
57754 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57755 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57756 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
57757 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57758 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
57759 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57760 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57761 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57762 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57763 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
57764 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57765 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57766 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57767 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57768 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
57769 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57770 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
57771 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
57772 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
57773 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
57774 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
57775 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
57776 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
57777 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57778 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57779 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57780 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57781 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57782 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57783 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57784 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57785 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57786 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57787 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
57788 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
57789 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57790 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
57791 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57792 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
57793 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
57794 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
57795 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
57796 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57797 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
57798 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
57799 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
57800 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
57801 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
57802 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
57803 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
57804 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57805 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57806 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
57807 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57808 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57809 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57810 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
57811 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
57812 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57813 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57814 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57815 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57816 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57817 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57818 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57819 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57820 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57821 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57822 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57823 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57824 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57825 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
57826 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
57827 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57828 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
57829 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
57830 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57831 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
57832 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
57833 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
57834 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57835 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
57836 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
57837 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57838 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57839 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
57840 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
57841 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57842 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
57843 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
57844 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
57845 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
57846 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
57847 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
57848 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
57849 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
57850 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57851 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
57852 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57853 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
57854 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57855 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
57856 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
57857 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
57858 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
57859 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
57860 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
57861 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57862 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
57863 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57864 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
57865 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
57866 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
57867 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57868 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
57869 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
57870 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57871 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
57872 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57873 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
57874 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
57875 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
57876 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
57877 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
57878 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
57879 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
57880 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
57881 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
57882 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57883 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
57884 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
57885 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
57886 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57887 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
57888 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
57889 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57890 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
57891 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57892 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
57893 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57894 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57895 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57896 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
57897 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
57898 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
57899 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
57900 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57901 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
57902 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57903 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
57904 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57905 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
57906 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
57907 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
57908 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
57909 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
57910 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
57911 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57912 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57913 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57914 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
57915 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
57916 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
57917 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
57918 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57919 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
57920 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
57921 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
57922 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
57923 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
57924 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
57925 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
57926 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
57927 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
57928 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
57929 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
57930 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
57931 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
57932 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57933 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
57934 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
57935 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
57936 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
57937 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57938 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
57939 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57940 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
57941 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57942 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57943 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
57944 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
57945 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
57946 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
57947 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
57948 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
57949 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
57950 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57951 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57952 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57953 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57954 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57955 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
57956 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
57957 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57958 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
57959 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57960 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
57961 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57962 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
57963 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57964 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57965 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57966 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57967 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57968 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
57969 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
57970 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
57971 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
57972 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
57973 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
57974 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
57975 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
57976 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57977 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57978 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
57979 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
57980 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
57981 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57982 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
57983 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
57984 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
57985 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
57986 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57987 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
57988 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
57989 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57990 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
57991 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57992 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
57993 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
57994 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57995 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
57996 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
57997 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
57998 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57999 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
58000 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
58001 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
58002 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
58003 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
58004 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
58005 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
58006 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
58007 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
58008 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
58009 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
58010 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
58011 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
58012 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
58013 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
58014 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
58015 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
58016 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
58017 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
58018 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
58019 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
58020 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
58021 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
58022 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
58023 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
58024 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
58025 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
58026 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
58027 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
58028 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
58029 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
58030 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
58031 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
58032 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
58033 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
58034 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
58035 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58036 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
58037 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
58038 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
58039 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
58040 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
58041 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58042 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58043 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58044 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
58045 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
58046 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
58047 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
58048 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
58049 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
58050 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
58051 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
58052 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
58053 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58054 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58055 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58056 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
58057 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
58058 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
58059 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
58060 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
58061 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58062 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
58063 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
58064 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
58065 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
58066 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
58067 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
58068 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
58069 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
58070 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
58071 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
58072 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
58073 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
58074 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
58075 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
58076 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
58077 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
58078 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
58079 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
58080 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
58081 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
58082 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
58083 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
58084 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
58085 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
58086 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58087 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58088 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
58089 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
58090 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
58091 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
58092 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58093 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
58094 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
58095 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
58096 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
58097 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
58098 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
58099 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
58100 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
58101 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
58102 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
58103 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
58104 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
58105 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
58106 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
58107 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
58108 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
58109 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
58110 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
58111 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
58112 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
58113 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
58114 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
58115 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
58116 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
58117 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
58118 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
58119 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
58120 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
58121 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
58122 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
58123 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
58124 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
58125 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
58126 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
58127 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
58128 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
58129 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
58130 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
58131 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
58132 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
58133 { NULL, NULL, 0, NULL }
58134 };
58135
58136
58137 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
58138
58139 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
58140 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
58141 }
58142 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
58143 return (void *)((wxSizer *) ((wxBoxSizer *) x));
58144 }
58145 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
58146 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
58147 }
58148 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
58149 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58150 }
58151 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
58152 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58153 }
58154 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
58155 return (void *)((wxSizer *) ((wxGridSizer *) x));
58156 }
58157 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
58158 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
58159 }
58160 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
58161 return (void *)((wxSizer *) ((wxPySizer *) x));
58162 }
58163 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
58164 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
58165 }
58166 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
58167 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58168 }
58169 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
58170 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
58171 }
58172 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
58173 return (void *)((wxEvent *) ((wxMenuEvent *) x));
58174 }
58175 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
58176 return (void *)((wxEvent *) ((wxCloseEvent *) x));
58177 }
58178 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
58179 return (void *)((wxEvent *) ((wxMouseEvent *) x));
58180 }
58181 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
58182 return (void *)((wxEvent *) ((wxEraseEvent *) x));
58183 }
58184 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
58185 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
58186 }
58187 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
58188 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
58189 }
58190 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
58191 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
58192 }
58193 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
58194 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
58195 }
58196 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
58197 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
58198 }
58199 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
58200 return (void *)((wxEvent *) ((wxPyEvent *) x));
58201 }
58202 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
58203 return (void *)((wxEvent *) ((wxIdleEvent *) x));
58204 }
58205 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
58206 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
58207 }
58208 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
58209 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
58210 }
58211 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
58212 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
58213 }
58214 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
58215 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
58216 }
58217 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
58218 return (void *)((wxEvent *) ((wxActivateEvent *) x));
58219 }
58220 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
58221 return (void *)((wxEvent *) ((wxSizeEvent *) x));
58222 }
58223 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
58224 return (void *)((wxEvent *) ((wxMoveEvent *) x));
58225 }
58226 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
58227 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
58228 }
58229 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
58230 return (void *)((wxEvent *) ((wxPaintEvent *) x));
58231 }
58232 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
58233 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
58234 }
58235 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
58236 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
58237 }
58238 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
58239 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
58240 }
58241 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
58242 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
58243 }
58244 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
58245 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
58246 }
58247 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
58248 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58249 }
58250 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
58251 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
58252 }
58253 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
58254 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
58255 }
58256 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
58257 return (void *)((wxEvent *) ((wxFocusEvent *) x));
58258 }
58259 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
58260 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
58261 }
58262 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
58263 return (void *)((wxEvent *) ((wxShowEvent *) x));
58264 }
58265 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
58266 return (void *)((wxEvent *) ((wxCommandEvent *) x));
58267 }
58268 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
58269 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
58270 }
58271 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
58272 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58273 }
58274 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
58275 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
58276 }
58277 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
58278 return (void *)((wxEvent *) ((wxKeyEvent *) x));
58279 }
58280 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
58281 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
58282 }
58283 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
58284 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
58285 }
58286 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
58287 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
58288 }
58289 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
58290 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
58291 }
58292 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
58293 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
58294 }
58295 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
58296 return (void *)((wxControl *) ((wxControlWithItems *) x));
58297 }
58298 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
58299 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
58300 }
58301 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
58302 return (void *)((wxEvtHandler *) ((wxWindow *) x));
58303 }
58304 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
58305 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58306 }
58307 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
58308 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
58309 }
58310 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
58311 return (void *)((wxEvtHandler *) ((wxValidator *) x));
58312 }
58313 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
58314 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
58315 }
58316 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
58317 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
58318 }
58319 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
58320 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
58321 }
58322 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
58323 return (void *)((wxEvtHandler *) ((wxMenu *) x));
58324 }
58325 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
58326 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
58327 }
58328 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
58329 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
58330 }
58331 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
58332 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
58333 }
58334 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
58335 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
58336 }
58337 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
58338 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
58339 }
58340 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
58341 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58342 }
58343 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
58344 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
58345 }
58346 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
58347 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
58348 }
58349 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
58350 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
58351 }
58352 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
58353 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58354 }
58355 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
58356 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58357 }
58358 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
58359 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
58360 }
58361 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
58362 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
58363 }
58364 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
58365 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
58366 }
58367 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
58368 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
58369 }
58370 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
58371 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
58372 }
58373 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
58374 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
58375 }
58376 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
58377 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
58378 }
58379 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
58380 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
58381 }
58382 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
58383 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
58384 }
58385 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
58386 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
58387 }
58388 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
58389 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
58390 }
58391 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
58392 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
58393 }
58394 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
58395 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
58396 }
58397 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
58398 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
58399 }
58400 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
58401 return (void *)((wxObject *) ((wxSizerItem *) x));
58402 }
58403 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
58404 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
58405 }
58406 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
58407 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
58408 }
58409 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
58410 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
58411 }
58412 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
58413 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
58414 }
58415 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
58416 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
58417 }
58418 static void *_p_wxSizerTo_p_wxObject(void *x) {
58419 return (void *)((wxObject *) ((wxSizer *) x));
58420 }
58421 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
58422 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58423 }
58424 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
58425 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
58426 }
58427 static void *_p_wxEventTo_p_wxObject(void *x) {
58428 return (void *)((wxObject *) ((wxEvent *) x));
58429 }
58430 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
58431 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
58432 }
58433 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
58434 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
58435 }
58436 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
58437 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
58438 }
58439 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
58440 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
58441 }
58442 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
58443 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
58444 }
58445 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
58446 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
58447 }
58448 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
58449 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
58450 }
58451 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
58452 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
58453 }
58454 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
58455 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58456 }
58457 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
58458 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
58459 }
58460 static void *_p_wxControlTo_p_wxObject(void *x) {
58461 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
58462 }
58463 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
58464 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
58465 }
58466 static void *_p_wxFSFileTo_p_wxObject(void *x) {
58467 return (void *)((wxObject *) ((wxFSFile *) x));
58468 }
58469 static void *_p_wxPySizerTo_p_wxObject(void *x) {
58470 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
58471 }
58472 static void *_p_wxPyEventTo_p_wxObject(void *x) {
58473 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
58474 }
58475 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
58476 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
58477 }
58478 static void *_p_wxShowEventTo_p_wxObject(void *x) {
58479 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
58480 }
58481 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
58482 return (void *)((wxObject *) ((wxMenuItem *) x));
58483 }
58484 static void *_p_wxDateEventTo_p_wxObject(void *x) {
58485 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
58486 }
58487 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
58488 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
58489 }
58490 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
58491 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
58492 }
58493 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
58494 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
58495 }
58496 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
58497 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
58498 }
58499 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
58500 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
58501 }
58502 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
58503 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
58504 }
58505 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
58506 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
58507 }
58508 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
58509 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
58510 }
58511 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
58512 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
58513 }
58514 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
58515 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
58516 }
58517 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
58518 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
58519 }
58520 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
58521 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
58522 }
58523 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
58524 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
58525 }
58526 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
58527 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58528 }
58529 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
58530 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58531 }
58532 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
58533 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
58534 }
58535 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
58536 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
58537 }
58538 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
58539 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
58540 }
58541 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
58542 return (void *)((wxObject *) ((wxImageHandler *) x));
58543 }
58544 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
58545 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
58546 }
58547 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
58548 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
58549 }
58550 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
58551 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
58552 }
58553 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
58554 return (void *)((wxObject *) ((wxEvtHandler *) x));
58555 }
58556 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
58557 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
58558 }
58559 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
58560 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
58561 }
58562 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
58563 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58564 }
58565 static void *_p_wxImageTo_p_wxObject(void *x) {
58566 return (void *)((wxObject *) ((wxImage *) x));
58567 }
58568 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
58569 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
58570 }
58571 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
58572 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58573 }
58574 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
58575 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
58576 }
58577 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
58578 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
58579 }
58580 static void *_p_wxWindowTo_p_wxObject(void *x) {
58581 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
58582 }
58583 static void *_p_wxMenuTo_p_wxObject(void *x) {
58584 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
58585 }
58586 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
58587 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
58588 }
58589 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
58590 return (void *)((wxObject *) ((wxFileSystem *) x));
58591 }
58592 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
58593 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
58594 }
58595 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
58596 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
58597 }
58598 static void *_p_wxPyAppTo_p_wxObject(void *x) {
58599 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
58600 }
58601 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
58602 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
58603 }
58604 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
58605 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
58606 }
58607 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
58608 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
58609 }
58610 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
58611 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
58612 }
58613 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
58614 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
58615 }
58616 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
58617 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
58618 }
58619 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
58620 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
58621 }
58622 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
58623 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
58624 }
58625 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
58626 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58627 }
58628 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
58629 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
58630 }
58631 static void *_p_wxValidatorTo_p_wxObject(void *x) {
58632 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
58633 }
58634 static void *_p_wxControlTo_p_wxWindow(void *x) {
58635 return (void *)((wxWindow *) ((wxControl *) x));
58636 }
58637 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
58638 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
58639 }
58640 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
58641 return (void *)((wxWindow *) ((wxMenuBar *) x));
58642 }
58643 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
58644 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
58645 }
58646 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
58647 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
58648 }
58649 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
58650 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
58651 }
58652 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
58653 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
58654 }
58655 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
58656 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
58657 }
58658 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
58659 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
58660 }
58661 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
58662 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58663 }
58664 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
58665 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
58666 }
58667 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
58668 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
58669 }
58670 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
58671 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
58672 }
58673 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
58674 return (void *)((wxValidator *) ((wxPyValidator *) x));
58675 }
58676 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
58677 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
58678 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};
58679 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
58680 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
58681 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
58682 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
58683 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
58684 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
58685 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
58686 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
58687 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
58688 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
58689 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
58690 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
58691 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
58692 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
58693 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
58694 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
58695 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
58696 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
58697 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
58698 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
58699 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
58700 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
58701 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
58702 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
58703 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
58704 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
58705 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
58706 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
58707 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
58708 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
58709 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
58710 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
58711 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
58712 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
58713 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
58714 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", "wxEventBlocker *", 0, 0, (void*)0, 0};
58715 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
58716 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
58717 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
58718 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
58719 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
58720 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
58721 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
58722 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
58723 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
58724 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
58725 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
58726 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
58727 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
58728 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
58729 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
58730 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
58731 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
58732 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
58733 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
58734 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
58735 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
58736 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
58737 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
58738 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
58739 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
58740 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
58741 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
58742 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
58743 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
58744 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
58745 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
58746 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
58747 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
58748 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
58749 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
58750 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
58751 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
58752 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
58753 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
58754 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
58755 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
58756 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
58757 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
58758 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
58759 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
58760 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
58761 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
58762 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
58763 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
58764 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
58765 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
58766 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
58767 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
58768 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
58769 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
58770 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
58771 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
58772 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
58773 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
58774 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
58775 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
58776 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
58777 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
58778 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
58779 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
58780 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
58781 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
58782 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
58783 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
58784 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
58785 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
58786 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
58787 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
58788 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
58789 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
58790 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
58791 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
58792 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
58793 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
58794 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
58795 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
58796 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
58797 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
58798 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
58799 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
58800 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
58801 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
58802 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
58803 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
58804 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
58805 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
58806 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
58807 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
58808 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
58809 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
58810 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
58811 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
58812
58813 static swig_type_info *swig_type_initial[] = {
58814 &_swigt__p_buffer,
58815 &_swigt__p_char,
58816 &_swigt__p_form_ops_t,
58817 &_swigt__p_int,
58818 &_swigt__p_long,
58819 &_swigt__p_unsigned_char,
58820 &_swigt__p_unsigned_int,
58821 &_swigt__p_unsigned_long,
58822 &_swigt__p_wxANIHandler,
58823 &_swigt__p_wxAcceleratorEntry,
58824 &_swigt__p_wxAcceleratorTable,
58825 &_swigt__p_wxActivateEvent,
58826 &_swigt__p_wxAppTraits,
58827 &_swigt__p_wxArrayString,
58828 &_swigt__p_wxBMPHandler,
58829 &_swigt__p_wxBitmap,
58830 &_swigt__p_wxBoxSizer,
58831 &_swigt__p_wxButton,
58832 &_swigt__p_wxCURHandler,
58833 &_swigt__p_wxCaret,
58834 &_swigt__p_wxChildFocusEvent,
58835 &_swigt__p_wxClipboardTextEvent,
58836 &_swigt__p_wxCloseEvent,
58837 &_swigt__p_wxColour,
58838 &_swigt__p_wxCommandEvent,
58839 &_swigt__p_wxContextMenuEvent,
58840 &_swigt__p_wxControl,
58841 &_swigt__p_wxControlWithItems,
58842 &_swigt__p_wxCursor,
58843 &_swigt__p_wxDC,
58844 &_swigt__p_wxDateEvent,
58845 &_swigt__p_wxDateTime,
58846 &_swigt__p_wxDisplayChangedEvent,
58847 &_swigt__p_wxDouble,
58848 &_swigt__p_wxDropFilesEvent,
58849 &_swigt__p_wxDuplexMode,
58850 &_swigt__p_wxEraseEvent,
58851 &_swigt__p_wxEvent,
58852 &_swigt__p_wxEventBlocker,
58853 &_swigt__p_wxEventLoop,
58854 &_swigt__p_wxEventLoopActivator,
58855 &_swigt__p_wxEvtHandler,
58856 &_swigt__p_wxFSFile,
58857 &_swigt__p_wxFileSystem,
58858 &_swigt__p_wxFileSystemHandler,
58859 &_swigt__p_wxFlexGridSizer,
58860 &_swigt__p_wxFocusEvent,
58861 &_swigt__p_wxFont,
58862 &_swigt__p_wxFrame,
58863 &_swigt__p_wxGBPosition,
58864 &_swigt__p_wxGBSizerItem,
58865 &_swigt__p_wxGBSpan,
58866 &_swigt__p_wxGIFHandler,
58867 &_swigt__p_wxGridBagSizer,
58868 &_swigt__p_wxGridSizer,
58869 &_swigt__p_wxHelpEvent__Origin,
58870 &_swigt__p_wxICOHandler,
58871 &_swigt__p_wxIconizeEvent,
58872 &_swigt__p_wxIdleEvent,
58873 &_swigt__p_wxImage,
58874 &_swigt__p_wxImageHandler,
58875 &_swigt__p_wxImageHistogram,
58876 &_swigt__p_wxImage_HSVValue,
58877 &_swigt__p_wxImage_RGBValue,
58878 &_swigt__p_wxIndividualLayoutConstraint,
58879 &_swigt__p_wxInitDialogEvent,
58880 &_swigt__p_wxInputStream,
58881 &_swigt__p_wxInternetFSHandler,
58882 &_swigt__p_wxItemContainer,
58883 &_swigt__p_wxJPEGHandler,
58884 &_swigt__p_wxKeyEvent,
58885 &_swigt__p_wxLayoutConstraints,
58886 &_swigt__p_wxMaximizeEvent,
58887 &_swigt__p_wxMemoryFSHandler,
58888 &_swigt__p_wxMenu,
58889 &_swigt__p_wxMenuBar,
58890 &_swigt__p_wxMenuBarBase,
58891 &_swigt__p_wxMenuEvent,
58892 &_swigt__p_wxMenuItem,
58893 &_swigt__p_wxMouseCaptureChangedEvent,
58894 &_swigt__p_wxMouseCaptureLostEvent,
58895 &_swigt__p_wxMouseEvent,
58896 &_swigt__p_wxMoveEvent,
58897 &_swigt__p_wxNavigationKeyEvent,
58898 &_swigt__p_wxNcPaintEvent,
58899 &_swigt__p_wxNotifyEvent,
58900 &_swigt__p_wxObject,
58901 &_swigt__p_wxOutputStream,
58902 &_swigt__p_wxPCXHandler,
58903 &_swigt__p_wxPNGHandler,
58904 &_swigt__p_wxPNMHandler,
58905 &_swigt__p_wxPaintEvent,
58906 &_swigt__p_wxPaletteChangedEvent,
58907 &_swigt__p_wxPaperSize,
58908 &_swigt__p_wxPoint,
58909 &_swigt__p_wxPoint2D,
58910 &_swigt__p_wxPropagateOnce,
58911 &_swigt__p_wxPropagationDisabler,
58912 &_swigt__p_wxPyApp,
58913 &_swigt__p_wxPyCommandEvent,
58914 &_swigt__p_wxPyDropTarget,
58915 &_swigt__p_wxPyEvent,
58916 &_swigt__p_wxPyFileSystemHandler,
58917 &_swigt__p_wxPyImageHandler,
58918 &_swigt__p_wxPyInputStream,
58919 &_swigt__p_wxPySizer,
58920 &_swigt__p_wxPyValidator,
58921 &_swigt__p_wxQuantize,
58922 &_swigt__p_wxQueryNewPaletteEvent,
58923 &_swigt__p_wxRealPoint,
58924 &_swigt__p_wxRect,
58925 &_swigt__p_wxRect2D,
58926 &_swigt__p_wxRegion,
58927 &_swigt__p_wxScrollEvent,
58928 &_swigt__p_wxScrollWinEvent,
58929 &_swigt__p_wxSetCursorEvent,
58930 &_swigt__p_wxShowEvent,
58931 &_swigt__p_wxSize,
58932 &_swigt__p_wxSizeEvent,
58933 &_swigt__p_wxSizer,
58934 &_swigt__p_wxSizerItem,
58935 &_swigt__p_wxStaticBox,
58936 &_swigt__p_wxStaticBoxSizer,
58937 &_swigt__p_wxStdDialogButtonSizer,
58938 &_swigt__p_wxSysColourChangedEvent,
58939 &_swigt__p_wxTGAHandler,
58940 &_swigt__p_wxTIFFHandler,
58941 &_swigt__p_wxToolTip,
58942 &_swigt__p_wxUpdateUIEvent,
58943 &_swigt__p_wxValidator,
58944 &_swigt__p_wxVisualAttributes,
58945 &_swigt__p_wxWindow,
58946 &_swigt__p_wxWindowCreateEvent,
58947 &_swigt__p_wxWindowDestroyEvent,
58948 &_swigt__p_wxXPMHandler,
58949 &_swigt__p_wxZipFSHandler,
58950 };
58951
58952 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
58953 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
58954 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
58955 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
58956 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
58957 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
58958 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
58959 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
58960 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
58961 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
58962 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
58963 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
58964 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
58965 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
58966 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}};
58967 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
58968 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}};
58969 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
58970 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}};
58971 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
58972 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58973 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
58974 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
58975 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
58976 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}};
58977 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58978 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}};
58979 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
58980 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
58981 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
58982 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
58983 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
58984 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58985 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
58986 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
58987 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
58988 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
58989 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}};
58990 static swig_cast_info _swigc__p_wxEventBlocker[] = { {&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
58991 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
58992 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
58993 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}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
58994 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
58995 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
58996 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}};
58997 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}};
58998 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58999 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
59000 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
59001 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
59002 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
59003 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
59004 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
59005 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
59006 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}};
59007 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
59008 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}};
59009 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
59010 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
59011 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
59012 static swig_cast_info _swigc__p_wxImageHandler[] = { {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
59013 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
59014 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
59015 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
59016 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
59017 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
59018 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
59019 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
59020 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}};
59021 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
59022 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
59023 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
59024 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
59025 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
59026 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
59027 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
59028 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
59029 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
59030 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
59031 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
59032 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
59033 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
59034 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
59035 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
59036 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
59037 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
59038 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_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_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_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_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}};
59039 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
59040 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
59041 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
59042 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
59043 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
59044 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
59045 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
59046 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
59047 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
59048 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
59049 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
59050 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
59051 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
59052 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
59053 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
59054 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
59055 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
59056 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
59057 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
59058 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
59059 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
59060 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
59061 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
59062 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
59063 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
59064 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
59065 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
59066 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
59067 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
59068 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
59069 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
59070 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
59071 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}};
59072 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}};
59073 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
59074 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
59075 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
59076 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
59077 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
59078 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
59079 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
59080 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
59081 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}};
59082 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
59083 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}};
59084 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
59085 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
59086 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
59087 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
59088
59089 static swig_cast_info *swig_cast_initial[] = {
59090 _swigc__p_buffer,
59091 _swigc__p_char,
59092 _swigc__p_form_ops_t,
59093 _swigc__p_int,
59094 _swigc__p_long,
59095 _swigc__p_unsigned_char,
59096 _swigc__p_unsigned_int,
59097 _swigc__p_unsigned_long,
59098 _swigc__p_wxANIHandler,
59099 _swigc__p_wxAcceleratorEntry,
59100 _swigc__p_wxAcceleratorTable,
59101 _swigc__p_wxActivateEvent,
59102 _swigc__p_wxAppTraits,
59103 _swigc__p_wxArrayString,
59104 _swigc__p_wxBMPHandler,
59105 _swigc__p_wxBitmap,
59106 _swigc__p_wxBoxSizer,
59107 _swigc__p_wxButton,
59108 _swigc__p_wxCURHandler,
59109 _swigc__p_wxCaret,
59110 _swigc__p_wxChildFocusEvent,
59111 _swigc__p_wxClipboardTextEvent,
59112 _swigc__p_wxCloseEvent,
59113 _swigc__p_wxColour,
59114 _swigc__p_wxCommandEvent,
59115 _swigc__p_wxContextMenuEvent,
59116 _swigc__p_wxControl,
59117 _swigc__p_wxControlWithItems,
59118 _swigc__p_wxCursor,
59119 _swigc__p_wxDC,
59120 _swigc__p_wxDateEvent,
59121 _swigc__p_wxDateTime,
59122 _swigc__p_wxDisplayChangedEvent,
59123 _swigc__p_wxDouble,
59124 _swigc__p_wxDropFilesEvent,
59125 _swigc__p_wxDuplexMode,
59126 _swigc__p_wxEraseEvent,
59127 _swigc__p_wxEvent,
59128 _swigc__p_wxEventBlocker,
59129 _swigc__p_wxEventLoop,
59130 _swigc__p_wxEventLoopActivator,
59131 _swigc__p_wxEvtHandler,
59132 _swigc__p_wxFSFile,
59133 _swigc__p_wxFileSystem,
59134 _swigc__p_wxFileSystemHandler,
59135 _swigc__p_wxFlexGridSizer,
59136 _swigc__p_wxFocusEvent,
59137 _swigc__p_wxFont,
59138 _swigc__p_wxFrame,
59139 _swigc__p_wxGBPosition,
59140 _swigc__p_wxGBSizerItem,
59141 _swigc__p_wxGBSpan,
59142 _swigc__p_wxGIFHandler,
59143 _swigc__p_wxGridBagSizer,
59144 _swigc__p_wxGridSizer,
59145 _swigc__p_wxHelpEvent__Origin,
59146 _swigc__p_wxICOHandler,
59147 _swigc__p_wxIconizeEvent,
59148 _swigc__p_wxIdleEvent,
59149 _swigc__p_wxImage,
59150 _swigc__p_wxImageHandler,
59151 _swigc__p_wxImageHistogram,
59152 _swigc__p_wxImage_HSVValue,
59153 _swigc__p_wxImage_RGBValue,
59154 _swigc__p_wxIndividualLayoutConstraint,
59155 _swigc__p_wxInitDialogEvent,
59156 _swigc__p_wxInputStream,
59157 _swigc__p_wxInternetFSHandler,
59158 _swigc__p_wxItemContainer,
59159 _swigc__p_wxJPEGHandler,
59160 _swigc__p_wxKeyEvent,
59161 _swigc__p_wxLayoutConstraints,
59162 _swigc__p_wxMaximizeEvent,
59163 _swigc__p_wxMemoryFSHandler,
59164 _swigc__p_wxMenu,
59165 _swigc__p_wxMenuBar,
59166 _swigc__p_wxMenuBarBase,
59167 _swigc__p_wxMenuEvent,
59168 _swigc__p_wxMenuItem,
59169 _swigc__p_wxMouseCaptureChangedEvent,
59170 _swigc__p_wxMouseCaptureLostEvent,
59171 _swigc__p_wxMouseEvent,
59172 _swigc__p_wxMoveEvent,
59173 _swigc__p_wxNavigationKeyEvent,
59174 _swigc__p_wxNcPaintEvent,
59175 _swigc__p_wxNotifyEvent,
59176 _swigc__p_wxObject,
59177 _swigc__p_wxOutputStream,
59178 _swigc__p_wxPCXHandler,
59179 _swigc__p_wxPNGHandler,
59180 _swigc__p_wxPNMHandler,
59181 _swigc__p_wxPaintEvent,
59182 _swigc__p_wxPaletteChangedEvent,
59183 _swigc__p_wxPaperSize,
59184 _swigc__p_wxPoint,
59185 _swigc__p_wxPoint2D,
59186 _swigc__p_wxPropagateOnce,
59187 _swigc__p_wxPropagationDisabler,
59188 _swigc__p_wxPyApp,
59189 _swigc__p_wxPyCommandEvent,
59190 _swigc__p_wxPyDropTarget,
59191 _swigc__p_wxPyEvent,
59192 _swigc__p_wxPyFileSystemHandler,
59193 _swigc__p_wxPyImageHandler,
59194 _swigc__p_wxPyInputStream,
59195 _swigc__p_wxPySizer,
59196 _swigc__p_wxPyValidator,
59197 _swigc__p_wxQuantize,
59198 _swigc__p_wxQueryNewPaletteEvent,
59199 _swigc__p_wxRealPoint,
59200 _swigc__p_wxRect,
59201 _swigc__p_wxRect2D,
59202 _swigc__p_wxRegion,
59203 _swigc__p_wxScrollEvent,
59204 _swigc__p_wxScrollWinEvent,
59205 _swigc__p_wxSetCursorEvent,
59206 _swigc__p_wxShowEvent,
59207 _swigc__p_wxSize,
59208 _swigc__p_wxSizeEvent,
59209 _swigc__p_wxSizer,
59210 _swigc__p_wxSizerItem,
59211 _swigc__p_wxStaticBox,
59212 _swigc__p_wxStaticBoxSizer,
59213 _swigc__p_wxStdDialogButtonSizer,
59214 _swigc__p_wxSysColourChangedEvent,
59215 _swigc__p_wxTGAHandler,
59216 _swigc__p_wxTIFFHandler,
59217 _swigc__p_wxToolTip,
59218 _swigc__p_wxUpdateUIEvent,
59219 _swigc__p_wxValidator,
59220 _swigc__p_wxVisualAttributes,
59221 _swigc__p_wxWindow,
59222 _swigc__p_wxWindowCreateEvent,
59223 _swigc__p_wxWindowDestroyEvent,
59224 _swigc__p_wxXPMHandler,
59225 _swigc__p_wxZipFSHandler,
59226 };
59227
59228
59229 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
59230
59231 static swig_const_info swig_const_table[] = {
59232 {0, 0, 0, 0.0, 0, 0}};
59233
59234 #ifdef __cplusplus
59235 }
59236 #endif
59237 /* -----------------------------------------------------------------------------
59238 * Type initialization:
59239 * This problem is tough by the requirement that no dynamic
59240 * memory is used. Also, since swig_type_info structures store pointers to
59241 * swig_cast_info structures and swig_cast_info structures store pointers back
59242 * to swig_type_info structures, we need some lookup code at initialization.
59243 * The idea is that swig generates all the structures that are needed.
59244 * The runtime then collects these partially filled structures.
59245 * The SWIG_InitializeModule function takes these initial arrays out of
59246 * swig_module, and does all the lookup, filling in the swig_module.types
59247 * array with the correct data and linking the correct swig_cast_info
59248 * structures together.
59249 *
59250 * The generated swig_type_info structures are assigned staticly to an initial
59251 * array. We just loop though that array, and handle each type individually.
59252 * First we lookup if this type has been already loaded, and if so, use the
59253 * loaded structure instead of the generated one. Then we have to fill in the
59254 * cast linked list. The cast data is initially stored in something like a
59255 * two-dimensional array. Each row corresponds to a type (there are the same
59256 * number of rows as there are in the swig_type_initial array). Each entry in
59257 * a column is one of the swig_cast_info structures for that type.
59258 * The cast_initial array is actually an array of arrays, because each row has
59259 * a variable number of columns. So to actually build the cast linked list,
59260 * we find the array of casts associated with the type, and loop through it
59261 * adding the casts to the list. The one last trick we need to do is making
59262 * sure the type pointer in the swig_cast_info struct is correct.
59263 *
59264 * First off, we lookup the cast->type name to see if it is already loaded.
59265 * There are three cases to handle:
59266 * 1) If the cast->type has already been loaded AND the type we are adding
59267 * casting info to has not been loaded (it is in this module), THEN we
59268 * replace the cast->type pointer with the type pointer that has already
59269 * been loaded.
59270 * 2) If BOTH types (the one we are adding casting info to, and the
59271 * cast->type) are loaded, THEN the cast info has already been loaded by
59272 * the previous module so we just ignore it.
59273 * 3) Finally, if cast->type has not already been loaded, then we add that
59274 * swig_cast_info to the linked list (because the cast->type) pointer will
59275 * be correct.
59276 * ----------------------------------------------------------------------------- */
59277
59278 #ifdef __cplusplus
59279 extern "C" {
59280 #if 0
59281 } /* c-mode */
59282 #endif
59283 #endif
59284
59285 #if 0
59286 #define SWIGRUNTIME_DEBUG
59287 #endif
59288
59289 SWIGRUNTIME void
59290 SWIG_InitializeModule(void *clientdata) {
59291 size_t i;
59292 swig_module_info *module_head;
59293 static int init_run = 0;
59294
59295 clientdata = clientdata;
59296
59297 if (init_run) return;
59298 init_run = 1;
59299
59300 /* Initialize the swig_module */
59301 swig_module.type_initial = swig_type_initial;
59302 swig_module.cast_initial = swig_cast_initial;
59303
59304 /* Try and load any already created modules */
59305 module_head = SWIG_GetModule(clientdata);
59306 if (module_head) {
59307 swig_module.next = module_head->next;
59308 module_head->next = &swig_module;
59309 } else {
59310 /* This is the first module loaded */
59311 swig_module.next = &swig_module;
59312 SWIG_SetModule(clientdata, &swig_module);
59313 }
59314
59315 /* Now work on filling in swig_module.types */
59316 #ifdef SWIGRUNTIME_DEBUG
59317 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
59318 #endif
59319 for (i = 0; i < swig_module.size; ++i) {
59320 swig_type_info *type = 0;
59321 swig_type_info *ret;
59322 swig_cast_info *cast;
59323
59324 #ifdef SWIGRUNTIME_DEBUG
59325 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59326 #endif
59327
59328 /* if there is another module already loaded */
59329 if (swig_module.next != &swig_module) {
59330 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
59331 }
59332 if (type) {
59333 /* Overwrite clientdata field */
59334 #ifdef SWIGRUNTIME_DEBUG
59335 printf("SWIG_InitializeModule: found type %s\n", type->name);
59336 #endif
59337 if (swig_module.type_initial[i]->clientdata) {
59338 type->clientdata = swig_module.type_initial[i]->clientdata;
59339 #ifdef SWIGRUNTIME_DEBUG
59340 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
59341 #endif
59342 }
59343 } else {
59344 type = swig_module.type_initial[i];
59345 }
59346
59347 /* Insert casting types */
59348 cast = swig_module.cast_initial[i];
59349 while (cast->type) {
59350 /* Don't need to add information already in the list */
59351 ret = 0;
59352 #ifdef SWIGRUNTIME_DEBUG
59353 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
59354 #endif
59355 if (swig_module.next != &swig_module) {
59356 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
59357 #ifdef SWIGRUNTIME_DEBUG
59358 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
59359 #endif
59360 }
59361 if (ret) {
59362 if (type == swig_module.type_initial[i]) {
59363 #ifdef SWIGRUNTIME_DEBUG
59364 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
59365 #endif
59366 cast->type = ret;
59367 ret = 0;
59368 } else {
59369 /* Check for casting already in the list */
59370 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
59371 #ifdef SWIGRUNTIME_DEBUG
59372 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
59373 #endif
59374 if (!ocast) ret = 0;
59375 }
59376 }
59377
59378 if (!ret) {
59379 #ifdef SWIGRUNTIME_DEBUG
59380 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
59381 #endif
59382 if (type->cast) {
59383 type->cast->prev = cast;
59384 cast->next = type->cast;
59385 }
59386 type->cast = cast;
59387 }
59388 cast++;
59389 }
59390 /* Set entry in modules->types array equal to the type */
59391 swig_module.types[i] = type;
59392 }
59393 swig_module.types[i] = 0;
59394
59395 #ifdef SWIGRUNTIME_DEBUG
59396 printf("**** SWIG_InitializeModule: Cast List ******\n");
59397 for (i = 0; i < swig_module.size; ++i) {
59398 int j = 0;
59399 swig_cast_info *cast = swig_module.cast_initial[i];
59400 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59401 while (cast->type) {
59402 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
59403 cast++;
59404 ++j;
59405 }
59406 printf("---- Total casts: %d\n",j);
59407 }
59408 printf("**** SWIG_InitializeModule: Cast List ******\n");
59409 #endif
59410 }
59411
59412 /* This function will propagate the clientdata field of type to
59413 * any new swig_type_info structures that have been added into the list
59414 * of equivalent types. It is like calling
59415 * SWIG_TypeClientData(type, clientdata) a second time.
59416 */
59417 SWIGRUNTIME void
59418 SWIG_PropagateClientData(void) {
59419 size_t i;
59420 swig_cast_info *equiv;
59421 static int init_run = 0;
59422
59423 if (init_run) return;
59424 init_run = 1;
59425
59426 for (i = 0; i < swig_module.size; i++) {
59427 if (swig_module.types[i]->clientdata) {
59428 equiv = swig_module.types[i]->cast;
59429 while (equiv) {
59430 if (!equiv->converter) {
59431 if (equiv->type && !equiv->type->clientdata)
59432 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
59433 }
59434 equiv = equiv->next;
59435 }
59436 }
59437 }
59438 }
59439
59440 #ifdef __cplusplus
59441 #if 0
59442 {
59443 /* c-mode */
59444 #endif
59445 }
59446 #endif
59447
59448
59449
59450 #ifdef __cplusplus
59451 extern "C" {
59452 #endif
59453
59454 /* Python-specific SWIG API */
59455 #define SWIG_newvarlink() SWIG_Python_newvarlink()
59456 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
59457 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
59458
59459 /* -----------------------------------------------------------------------------
59460 * global variable support code.
59461 * ----------------------------------------------------------------------------- */
59462
59463 typedef struct swig_globalvar {
59464 char *name; /* Name of global variable */
59465 PyObject *(*get_attr)(void); /* Return the current value */
59466 int (*set_attr)(PyObject *); /* Set the value */
59467 struct swig_globalvar *next;
59468 } swig_globalvar;
59469
59470 typedef struct swig_varlinkobject {
59471 PyObject_HEAD
59472 swig_globalvar *vars;
59473 } swig_varlinkobject;
59474
59475 SWIGINTERN PyObject *
59476 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
59477 return PyString_FromString("<Swig global variables>");
59478 }
59479
59480 SWIGINTERN PyObject *
59481 swig_varlink_str(swig_varlinkobject *v) {
59482 PyObject *str = PyString_FromString("(");
59483 swig_globalvar *var;
59484 for (var = v->vars; var; var=var->next) {
59485 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
59486 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
59487 }
59488 PyString_ConcatAndDel(&str,PyString_FromString(")"));
59489 return str;
59490 }
59491
59492 SWIGINTERN int
59493 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
59494 PyObject *str = swig_varlink_str(v);
59495 fprintf(fp,"Swig global variables ");
59496 fprintf(fp,"%s\n", PyString_AsString(str));
59497 Py_DECREF(str);
59498 return 0;
59499 }
59500
59501 SWIGINTERN void
59502 swig_varlink_dealloc(swig_varlinkobject *v) {
59503 swig_globalvar *var = v->vars;
59504 while (var) {
59505 swig_globalvar *n = var->next;
59506 free(var->name);
59507 free(var);
59508 var = n;
59509 }
59510 }
59511
59512 SWIGINTERN PyObject *
59513 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
59514 PyObject *res = NULL;
59515 swig_globalvar *var = v->vars;
59516 while (var) {
59517 if (strcmp(var->name,n) == 0) {
59518 res = (*var->get_attr)();
59519 break;
59520 }
59521 var = var->next;
59522 }
59523 if (res == NULL && !PyErr_Occurred()) {
59524 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59525 }
59526 return res;
59527 }
59528
59529 SWIGINTERN int
59530 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
59531 int res = 1;
59532 swig_globalvar *var = v->vars;
59533 while (var) {
59534 if (strcmp(var->name,n) == 0) {
59535 res = (*var->set_attr)(p);
59536 break;
59537 }
59538 var = var->next;
59539 }
59540 if (res == 1 && !PyErr_Occurred()) {
59541 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59542 }
59543 return res;
59544 }
59545
59546 SWIGINTERN PyTypeObject*
59547 swig_varlink_type(void) {
59548 static char varlink__doc__[] = "Swig var link object";
59549 static PyTypeObject varlink_type;
59550 static int type_init = 0;
59551 if (!type_init) {
59552 const PyTypeObject tmp
59553 = {
59554 PyObject_HEAD_INIT(NULL)
59555 0, /* Number of items in variable part (ob_size) */
59556 (char *)"swigvarlink", /* Type name (tp_name) */
59557 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
59558 0, /* Itemsize (tp_itemsize) */
59559 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
59560 (printfunc) swig_varlink_print, /* Print (tp_print) */
59561 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
59562 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
59563 0, /* tp_compare */
59564 (reprfunc) swig_varlink_repr, /* tp_repr */
59565 0, /* tp_as_number */
59566 0, /* tp_as_sequence */
59567 0, /* tp_as_mapping */
59568 0, /* tp_hash */
59569 0, /* tp_call */
59570 (reprfunc)swig_varlink_str, /* tp_str */
59571 0, /* tp_getattro */
59572 0, /* tp_setattro */
59573 0, /* tp_as_buffer */
59574 0, /* tp_flags */
59575 varlink__doc__, /* tp_doc */
59576 0, /* tp_traverse */
59577 0, /* tp_clear */
59578 0, /* tp_richcompare */
59579 0, /* tp_weaklistoffset */
59580 #if PY_VERSION_HEX >= 0x02020000
59581 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
59582 #endif
59583 #if PY_VERSION_HEX >= 0x02030000
59584 0, /* tp_del */
59585 #endif
59586 #ifdef COUNT_ALLOCS
59587 0,0,0,0 /* tp_alloc -> tp_next */
59588 #endif
59589 };
59590 varlink_type = tmp;
59591 varlink_type.ob_type = &PyType_Type;
59592 type_init = 1;
59593 }
59594 return &varlink_type;
59595 }
59596
59597 /* Create a variable linking object for use later */
59598 SWIGINTERN PyObject *
59599 SWIG_Python_newvarlink(void) {
59600 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
59601 if (result) {
59602 result->vars = 0;
59603 }
59604 return ((PyObject*) result);
59605 }
59606
59607 SWIGINTERN void
59608 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
59609 swig_varlinkobject *v = (swig_varlinkobject *) p;
59610 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
59611 if (gv) {
59612 size_t size = strlen(name)+1;
59613 gv->name = (char *)malloc(size);
59614 if (gv->name) {
59615 strncpy(gv->name,name,size);
59616 gv->get_attr = get_attr;
59617 gv->set_attr = set_attr;
59618 gv->next = v->vars;
59619 }
59620 }
59621 v->vars = gv;
59622 }
59623
59624 SWIGINTERN PyObject *
59625 SWIG_globals() {
59626 static PyObject *_SWIG_globals = 0;
59627 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
59628 return _SWIG_globals;
59629 }
59630
59631 /* -----------------------------------------------------------------------------
59632 * constants/methods manipulation
59633 * ----------------------------------------------------------------------------- */
59634
59635 /* Install Constants */
59636 SWIGINTERN void
59637 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
59638 PyObject *obj = 0;
59639 size_t i;
59640 for (i = 0; constants[i].type; ++i) {
59641 switch(constants[i].type) {
59642 case SWIG_PY_POINTER:
59643 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
59644 break;
59645 case SWIG_PY_BINARY:
59646 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
59647 break;
59648 default:
59649 obj = 0;
59650 break;
59651 }
59652 if (obj) {
59653 PyDict_SetItemString(d, constants[i].name, obj);
59654 Py_DECREF(obj);
59655 }
59656 }
59657 }
59658
59659 /* -----------------------------------------------------------------------------*/
59660 /* Fix SwigMethods to carry the callback ptrs when needed */
59661 /* -----------------------------------------------------------------------------*/
59662
59663 SWIGINTERN void
59664 SWIG_Python_FixMethods(PyMethodDef *methods,
59665 swig_const_info *const_table,
59666 swig_type_info **types,
59667 swig_type_info **types_initial) {
59668 size_t i;
59669 for (i = 0; methods[i].ml_name; ++i) {
59670 const char *c = methods[i].ml_doc;
59671 if (c && (c = strstr(c, "swig_ptr: "))) {
59672 int j;
59673 swig_const_info *ci = 0;
59674 const char *name = c + 10;
59675 for (j = 0; const_table[j].type; ++j) {
59676 if (strncmp(const_table[j].name, name,
59677 strlen(const_table[j].name)) == 0) {
59678 ci = &(const_table[j]);
59679 break;
59680 }
59681 }
59682 if (ci) {
59683 size_t shift = (ci->ptype) - types;
59684 swig_type_info *ty = types_initial[shift];
59685 size_t ldoc = (c - methods[i].ml_doc);
59686 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
59687 char *ndoc = (char*)malloc(ldoc + lptr + 10);
59688 if (ndoc) {
59689 char *buff = ndoc;
59690 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
59691 if (ptr) {
59692 strncpy(buff, methods[i].ml_doc, ldoc);
59693 buff += ldoc;
59694 strncpy(buff, "swig_ptr: ", 10);
59695 buff += 10;
59696 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
59697 methods[i].ml_doc = ndoc;
59698 }
59699 }
59700 }
59701 }
59702 }
59703 }
59704
59705 #ifdef __cplusplus
59706 }
59707 #endif
59708
59709 /* -----------------------------------------------------------------------------*
59710 * Partial Init method
59711 * -----------------------------------------------------------------------------*/
59712
59713 #ifdef __cplusplus
59714 extern "C"
59715 #endif
59716 SWIGEXPORT void SWIG_init(void) {
59717 PyObject *m, *d;
59718
59719 /* Fix SwigMethods to carry the callback ptrs when needed */
59720 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
59721
59722 m = Py_InitModule((char *) SWIG_name, SwigMethods);
59723 d = PyModule_GetDict(m);
59724
59725 SWIG_InitializeModule(0);
59726 SWIG_InstallConstants(d,swig_const_table);
59727
59728
59729
59730 #ifndef wxPyUSE_EXPORT
59731 // Make our API structure a CObject so other modules can import it
59732 // from this module.
59733 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
59734 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
59735 Py_XDECREF(cobj);
59736 #endif
59737
59738 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
59739 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
59740 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
59741 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
59742 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
59743 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
59744 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
59745 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
59746 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
59747 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
59748 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
59749 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
59750 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
59751 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
59752 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
59753 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
59754 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
59755 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
59756 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
59757 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
59758 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
59759 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
59760 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
59761 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
59762 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
59763 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
59764 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
59765 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
59766 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
59767 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
59768 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
59769 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
59770 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
59771 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
59772 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
59773 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
59774 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
59775 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
59776 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
59777 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
59778 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
59779 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
59780 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
59781 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
59782 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
59783 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
59784 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
59785 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
59786 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
59787 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
59788 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
59789 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
59790 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
59791 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
59792 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
59793 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
59794 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
59795 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
59796 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
59797 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
59798 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
59799 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
59800 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
59801 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
59802 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
59803 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
59804 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
59805 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
59806 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
59807 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
59808 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
59809 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
59810 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
59811 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
59812 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
59813 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
59814 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
59815 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
59816 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
59817 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
59818 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
59819 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
59820 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
59821 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
59822 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
59823 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
59824 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
59825 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
59826 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
59827 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
59828 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
59829 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
59830 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
59831 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
59832 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
59833 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
59834 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
59835 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
59836 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
59837 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
59838 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
59839 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
59840 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
59841 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
59842 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
59843 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
59844 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
59845 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
59846 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
59847 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
59848 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
59849 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
59850 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
59851 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
59852 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
59853 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
59854 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
59855 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
59856 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
59857 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
59858 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
59859 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
59860 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
59861 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
59862 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
59863 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
59864 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
59865 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
59866 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
59867 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
59868 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
59869 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
59870 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
59871 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
59872 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
59873 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
59874 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
59875 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
59876 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
59877 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
59878 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
59879 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
59880 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
59881 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
59882 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
59883 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
59884 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
59885 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
59886 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
59887 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
59888 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
59889 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
59890 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
59891 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
59892 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
59893 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
59894 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
59895 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
59896 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
59897 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
59898 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
59899 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
59900 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
59901 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
59902 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
59903 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
59904 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
59905 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
59906 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
59907 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
59908 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
59909 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
59910 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
59911 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
59912 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
59913 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
59914 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
59915 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
59916 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
59917 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
59918 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
59919 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
59920 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
59921 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
59922 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
59923 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
59924 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
59925 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
59926 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
59927 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
59928 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
59929 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
59930 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
59931 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
59932 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
59933 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
59934 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
59935 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
59936 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
59937 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
59938 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
59939 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
59940 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
59941 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
59942 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
59943 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
59944 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
59945 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
59946 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
59947 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
59948 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
59949 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
59950 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
59951 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
59952 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
59953 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
59954 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
59955 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
59956 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
59957 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
59958 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
59959 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
59960 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
59961 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
59962 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
59963 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
59964 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
59965 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
59966 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
59967 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
59968 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
59969 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
59970 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
59971 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
59972 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
59973 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
59974 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
59975 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
59976 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
59977 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
59978 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
59979 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
59980 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
59981 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
59982 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
59983 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
59984 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
59985 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
59986 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
59987 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
59988 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
59989 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
59990 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
59991 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
59992 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
59993 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
59994 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
59995 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
59996 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
59997 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
59998 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
59999 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
60000 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
60001 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
60002 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
60003 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
60004 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
60005 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
60006 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
60007 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
60008 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
60009 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
60010 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
60011 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
60012 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
60013 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
60014 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
60015 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
60016 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
60017 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
60018 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
60019 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
60020 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
60021 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
60022 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
60023 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
60024 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
60025 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
60026 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
60027 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
60028 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
60029 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
60030 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
60031 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
60032 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
60033 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
60034 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
60035 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
60036 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
60037 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
60038 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
60039 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
60040 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
60041 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
60042 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
60043 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
60044 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
60045 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
60046 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
60047 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
60048 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
60049 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
60050 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
60051 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
60052 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
60053 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
60054 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
60055 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
60056 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
60057 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
60058 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
60059 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
60060 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
60061 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
60062 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
60063 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
60064 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
60065 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
60066 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
60067 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
60068 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
60069 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
60070 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
60071 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
60072 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
60073 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
60074 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
60075 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
60076 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
60077 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
60078 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
60079 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
60080 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
60081 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
60082 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
60083 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
60084 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
60085 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
60086 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
60087 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
60088 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
60089 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
60090 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
60091 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
60092 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
60093 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
60094 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
60095 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
60096 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
60097 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
60098 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
60099 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
60100 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
60101 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
60102 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
60103 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
60104 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
60105 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
60106 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
60107 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
60108 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
60109 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
60110 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
60111 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
60112 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
60113 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
60114 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
60115 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
60116 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
60117 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
60118 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
60119 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
60120 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
60121 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
60122 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
60123 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
60124 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
60125 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
60126 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
60127 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
60128 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
60129 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
60130 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
60131 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
60132 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
60133 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
60134 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
60135 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
60136 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
60137 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
60138 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
60139 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
60140 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
60141 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
60142 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
60143 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
60144 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
60145 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
60146 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
60147 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
60148 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
60149 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
60150 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
60151 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
60152 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
60153 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
60154 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
60155 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
60156 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
60157 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
60158 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
60159 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
60160 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
60161 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
60162 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
60163 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
60164 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
60165 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
60166 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
60167 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
60168 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
60169 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
60170 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
60171 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
60172 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
60173 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
60174 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
60175 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
60176 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
60177 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
60178 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
60179 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
60180 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
60181 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
60182 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
60183 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
60184 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
60185 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
60186 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
60187 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
60188 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
60189 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
60190 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
60191 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
60192 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
60193 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
60194 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
60195 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
60196 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
60197 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
60198 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
60199 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
60200 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
60201 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
60202 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
60203 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
60204 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
60205 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
60206 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
60207 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
60208 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
60209 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
60210 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
60211 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
60212 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
60213 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
60214 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
60215 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
60216 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
60217 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
60218 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
60219 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
60220 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
60221 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
60222 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
60223 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
60224 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
60225 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
60226 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
60227 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
60228 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
60229 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
60230 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
60231 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
60232 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
60233 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
60234 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
60235 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
60236 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
60237 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
60238 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
60239 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
60240 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
60241 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
60242 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
60243 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
60244 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
60245 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
60246 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
60247 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
60248 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
60249 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
60250 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
60251 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
60252 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
60253 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
60254 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
60255 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
60256 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
60257 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
60258 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
60259 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
60260 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
60261 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
60262 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
60263 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
60264 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
60265 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
60266 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
60267 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
60268 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
60269 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
60270 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
60271 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
60272 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
60273 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
60274 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
60275 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
60276 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
60277 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
60278 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
60279 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
60280 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
60281 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
60282 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
60283 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
60284 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
60285 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
60286 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
60287 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
60288 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
60289 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
60290 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
60291 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
60292 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
60293 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
60294 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
60295 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
60296 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
60297 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
60298 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
60299 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
60300 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
60301 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
60302 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
60303 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
60304 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
60305 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
60306 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
60307 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
60308 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
60309 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
60310 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
60311 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
60312 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
60313 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
60314 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
60315 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
60316 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
60317 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
60318 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
60319 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
60320 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
60321 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
60322 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
60323 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
60324 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
60325 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
60326 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
60327 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
60328 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
60329 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
60330 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
60331 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
60332 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
60333 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
60334 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
60335 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
60336 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
60337 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
60338 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
60339 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
60340 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
60341 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
60342 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
60343 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
60344 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
60345 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
60346 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
60347 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
60348 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
60349 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
60350 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
60351 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
60352 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
60353 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
60354 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
60355 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
60356 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
60357 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
60358 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
60359 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
60360 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
60361 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
60362 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
60363 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
60364 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
60365 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
60366 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
60367 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
60368 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
60369 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
60370 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
60371 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
60372 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
60373 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
60374 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
60375 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
60376 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
60377 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
60378 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
60379 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
60380 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
60381 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
60382 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
60383 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
60384 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
60385 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
60386 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
60387 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
60388 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
60389 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
60390 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
60391 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
60392 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
60393 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
60394 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
60395 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
60396 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
60397 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
60398 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
60399 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
60400 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
60401 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
60402 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
60403
60404 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
60405
60406
60407 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
60408
60409 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
60410 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
60411 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
60412 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
60413 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
60414 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
60415 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
60416 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
60417 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
60418 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
60419 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
60420 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
60421 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
60422 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
60423 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
60424 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
60425 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
60426 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
60427 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
60428 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
60429 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
60430 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
60431 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
60432 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
60433 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
60434 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
60435 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
60436 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
60437 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
60438 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
60439 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
60440 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
60441 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
60442 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
60443 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
60444 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
60445 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
60446 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
60447 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
60448 PyDict_SetItemString(d, "wxEVT_ANY", PyInt_FromLong(wxEVT_ANY));
60449 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
60450 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
60451 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
60452 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
60453 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
60454 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
60455 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
60456 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
60457 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
60458 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
60459 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
60460 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
60461 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
60462 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
60463 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
60464 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
60465 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
60466 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
60467 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
60468 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
60469 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
60470 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
60471 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
60472 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
60473 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
60474 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
60475 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
60476 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
60477 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
60478 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
60479 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
60480 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
60481 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
60482 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
60483 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
60484 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
60485 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
60486 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
60487 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
60488 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
60489 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
60490 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
60491 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
60492 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
60493 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
60494 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
60495 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
60496 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
60497 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
60498 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
60499 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
60500 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
60501 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
60502 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
60503 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
60504 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
60505 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
60506 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
60507 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
60508 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
60509 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
60510 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
60511 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
60512 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
60513 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
60514 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
60515 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
60516 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
60517 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
60518 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
60519 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
60520 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
60521 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
60522 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
60523 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
60524 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
60525 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
60526 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
60527 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
60528 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
60529 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
60530 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
60531 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
60532 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
60533 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
60534 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
60535 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
60536 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
60537 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
60538 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
60539 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
60540 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
60541 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
60542 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
60543 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
60544 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
60545 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
60546 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
60547 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
60548 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
60549 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
60550 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
60551 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
60552 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
60553 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
60554 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
60555 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
60556 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
60557 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
60558 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
60559 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
60560 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
60561 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
60562 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
60563 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
60564 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
60565 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
60566 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
60567 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
60568 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
60569 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
60570 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
60571 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
60572 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
60573 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
60574 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
60575 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
60576 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
60577 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
60578 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
60579 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
60580 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
60581 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
60582 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
60583 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
60584 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
60585 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
60586 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
60587 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
60588 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
60589 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
60590 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
60591 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
60592 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
60593 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
60594 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
60595 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
60596 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
60597 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
60598 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
60599 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
60600 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
60601 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
60602 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
60603 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
60604 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
60605 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
60606 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
60607 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
60608 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
60609 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
60610 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
60611 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
60612 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
60613 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
60614 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
60615 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
60616 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
60617 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
60618 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
60619 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
60620 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
60621 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
60622 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
60623 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
60624
60625 // Initialize threading, some globals and such
60626 __wxPyPreStart(d);
60627
60628
60629 // Although these are defined in __version__ they need to be here too so
60630 // that an assert can be done to ensure that the wxPython and the wxWindows
60631 // versions match.
60632 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
60633 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
60634 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
60635
60636 }
60637
wxWidgets (Impactor)